用于与Enum匹配的开关或模式的宏

Question

I would like to have some syntactic sugar for switching on an Enum . Of course, an if else block works as expected:

@enum Fruit apple=1 orange=2 kiwi=3

function talk1(fruit::Fruit)
    if fruit == apple
        "I like apples."
    elseif fruit == orange
        "I like oranges."
    else
        "I like kiwis."
    end
end

I could even do the following:

function talk2(fruit::Fruit)
    say = ["I like apples.", "I like oranges.", "I like kiwis."]
    say[Int(fruit)]
end

But I don't really like the approach in talk2 , since it allocates a vector and is less readable. I tried the Match.jl package, but I can't seem to match an Enum :

using Match

function talk3(fruit::Fruit)
    @match fruit begin
        apple  => "I like apples."
        orange => "I like oranges."
        kiwi   => "I like kiwis."
    end
end

julia> talk3(apple)
"I like apples."

julia> talk3(orange)
"I like apples."

julia> talk3(kiwi)
"I like apples."

Of course, in the @match macro I could cast the Enum as an Int and match the Int , but that hampers the readability of the switch.

Is there a way to get Match.jl to work on an Enum ? Or is there a macro from a different package that can switch on an Enum ?

Answer 1

This is perhaps the main reason to use types instead of enums. Then dispatch handles this for you:

abstract type Fruit end
struct Apple <: Fruit end
struct Orange <: Fruit end
struct Kiwi <: Fruit end

talk(fruit::Apple) = "I like apples."
talk(fruit::Orange) = "I like oranges."
talk(fruit::Fruit) = "I like kiwis."

As https://pixorblog.wordpress.com/2018/02/23/julia-dispatch-enum-vs-type-comparison/ point out, this code is efficiently inlined by the compiler.

Answer 2

Although I actually like your talk2() function, I guess you could improve on readability by using a Dict :

function talk(fruit::Fruit)
    phrases=Dict{Int,String}([
        (Int(apple)  => "I like apples"), 
        # or: (1->"I like apples"), or: (1,"I like apples")
        (Int(orange) => "I like oranges"),
        (Int(kiwi)   => "I like kiwis")
    ])
   phrases[Int(fruit)]
end

alternatively:

function talk(fruit::Fruit)
    phrases=Dict{Fruit,String}(
        apple=>"I like apples",
        orange=>"I like oranges",
        kiwi=>"I like kiwis"
    )
    phrases[fruit]
end

Note: this means you wouldn't even need to declare a function, but could just rely on phrases[fruit] instead; this will however give "weaker" warnings, ie a "key not found" error instead of a "MethodError" (if you give it a @enum Veg tomato=1 , for example), which may make debugging more difficult in the long run.

---

If you want to use Match.jl , I think you need to be evaluate a potential match on ::Int(fruit) , not ::Fruit (all three cases in talk3() are of type Fruit!), ie:

function talk3(fruit::Fruit)
    @match Int(fruit_int) begin
        1 => "I like apples."
        2 => "I like oranges."
        3 => "I like kiwis."
    end
end

or using the string() part of the enum :

function talk4(fruit::Fruit)
    @match string(fruit) begin
        "apple" => "I like apples."
        "orange" => "I like oranges."
        "kiwi" => "I like kiwis."
    end
end

Answer 3

I wrote a simple switch macro specifically for Enum s. The code is heavily inspired by Match.jl , and lacks the generality and error handling of Match.@match . My @enum_switch macro is implemented as follows:

import MacroTools.rmlines

# Assume the correct number of switches are provided for the Enum.
macro enum_switch(v, block_ex)
    block_ex = rmlines(block_ex)  # Remove `LineNumberNode`s from block quote
    pairs = block_ex.args
    ex = nothing

    for p in reverse(pairs)
        if isnothing(ex)
            ex = p.args[3]
        else
            ex = Expr(:if, Expr(:call, :(==), esc(v), p.args[2]), p.args[3], ex)
        end
    end

    ex
end

It can be used to define a talk_switch as follows:

@enum Fruit apple=1 orange=2 kiwi=3

function talk_switch(fruit::Fruit)
    @enum_switch fruit begin
        apple  => "I like apples."
        orange => "I like oranges."
        kiwi   => "I like kiwis."
    end
end

And we can see it works as intended:

julia> talk_switch(apple)
"I like apples."

julia> talk_switch(orange)
"I like oranges."

julia> talk_switch(kiwi)
"I like kiwis."

Now let's compare talk_switch to the other proposed approaches.

function talk_ifelse(fruit::Fruit)
    if fruit == apple
        "I like apples."
    elseif fruit == orange
        "I like oranges."
    else
        "I like kiwis."
    end
end

function talk_array(fruit::Fruit)
    say = ["I like apples.", "I like oranges.", "I like kiwis."]
    say[Int(fruit)]
end

function talk_dict(fruit::Fruit)
    phrases = Dict{Fruit, String}(
        apple  => "I like apples.",
        orange => "I like oranges.",
        kiwi   => "I like kiwis."
    )
    phrases[fruit]
end

abstract type AbstractFruit end
struct Apple <: AbstractFruit end
struct Orange <: AbstractFruit end
struct Kiwi <: AbstractFruit end

const APPLE = Apple()
const ORANGE = Orange()
const KIWI = Kiwi()

talk_type(fruit::Apple) = "I like apples."
talk_type(fruit::Orange) = "I like oranges."
talk_type(fruit::AbstractFruit) = "I like kiwis."

As intended, talk_switch and talk_ifelse produce the same lowered code:

julia> @code_lowered talk_switch(kiwi)
CodeInfo(
1 ─ %1 = fruit == Main.apple
└──      goto #3 if not %1
2 ─      return "I like apples."
3 ─ %4 = fruit == Main.orange
└──      goto #5 if not %4
4 ─      return "I like oranges."
5 ─      return "I like kiwis."
)

julia> @code_lowered talk_ifelse(kiwi)
CodeInfo(
1 ─ %1 = fruit == Main.apple
└──      goto #3 if not %1
2 ─      return "I like apples."
3 ─ %4 = fruit == Main.orange
└──      goto #5 if not %4
4 ─      return "I like oranges."
5 ─      return "I like kiwis."
)

Finally, we can benchmark the performance of the various solutions:

julia> using BenchmarkTools

julia> @btime talk_switch(kiwi);
  6.348 ns (0 allocations: 0 bytes)

julia> @btime talk_ifelse(kiwi);
  6.349 ns (0 allocations: 0 bytes)

julia> @btime talk_type(KIWI);
  6.353 ns (0 allocations: 0 bytes)

julia> @btime talk_array(kiwi);
  103.447 ns (1 allocation: 112 bytes)

julia> @btime talk_dict(kiwi);
  861.712 ns (11 allocations: 704 bytes)

As expected, talk_switch and talk_ifelse have the same performance since they produce the same lowered code. Interestingly, talk_type also performs the same as talk_switch and talk_ifelse . Finally, we can see that talk_array and talk_dict lag far behind the top three performers.