allow _ as the fallback 'wildcard' case (#56)

* allow `_` as the fallback 'wildcard' case

* bump version

* make coverage happy

* test on 1.10.0-rc1

Author: MasonProtter

.github/workflows/CI.yml

@@ -14,6 +14,7 @@ jobs:
           - '1.6'
           - '1.8'
           - '1.9'
+          - '1.10.0-rc1'
           - 'nightly'
         os:
           - ubuntu-latest

Project.toml

@@ -1,7 +1,7 @@
 name = "SumTypes"
 uuid = "8e1ec7a9-0e02-4297-b0fe-6433085c89f2"
 authors = ["MasonProtter <[email protected]>"]
-version = "0.5.0"
+version = "0.5.1"
 
 [deps]
 MacroTools = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09"

README.md

@@ -165,8 +165,8 @@ The `@cases` macro still falls far short of a full on pattern matching system, l
 
 ### Defining many repetitive cases simultaneously 
 
-`@cases` does not allow for fallback branches, and it also does not allow one to write inexhaustive cases. To avoid making some code overly verbose and repetitive, we instead provide syntax for defining many cases in one line:
-
+Generally, it's good to explicitly handle all cases of a sum type, but sometimes you just want one set of behaviour for
+a large set of cases. One option, is 'collections' of cases like so:
 ``` julia
 @sum_type Re begin
     Empty
@@ -209,6 +209,16 @@ count_classes(r::Re, c=0) = @cases r begin
 end;
 ```
 
+SumTypes also lets you use `_` as a case predicate that accepts anything, but this only works in the final position, and
+does not allow destructuring:
+
+``` julia
+isEmpty(x::Re) = @cases x begin
+    Empty => true
+    _     => false
+end
+```
+
 <!-- </details> -->
 
 

src/cases.jl

@@ -19,18 +19,24 @@
 end
 
 macro cases(to_match, block)
-    @assert block.head == :block
+    esc(_cases(to_match, block))
+end
+
+function _cases(to_match, block) 
+    block.head == :block || error("The second argument to @cases must be a code block")
     lnns = filter(block.args) do arg
         arg isa LineNumberNode
     end
     # Base.remove_linenums!(block)
 
     stmts = []
-    foreach(block.args) do arg
+    wildcard_stmt = Ref{Any}()
+    
+    foreach(enumerate(block.args)) do (i, arg)
         if arg isa LineNumberNode
             return nothing
         end
-        arg.head == :call && arg.args[1] == :(=>) || throw(error("Malformed case $arg"))
+        arg.head == :call && arg.args[1] == :(=>) || error("Malformed case $arg")
         lhs = arg.args[2]
         rhs = arg.args[3]
         if isexpr(lhs, :call) # arg.args[2] isa Expr && arg.args[2].head == :call
@@ -43,7 +49,15 @@ macro cases(to_match, block)
             iscall = false
         end
         if variant isa Symbol
-            push!(stmts, (;variant=variant, rhs=rhs, fieldnames=fieldnames, iscall=iscall))
+            if variant === :_
+                if i == length(block.args)
+                    wildcard_stmt[] = rhs
+                else
+                    error("The wildcard variant _ can only be used as the last option to @cases")
+                end
+            else
+                push!(stmts, (;variant=variant, rhs=rhs, fieldnames=fieldnames, iscall=iscall))
+            end
         elseif isexpr(variant, :vect)
             for subvariant ∈ variant.args
                 if !(subvariant isa Symbol)
@@ -90,13 +104,20 @@ macro cases(to_match, block)
     end
     # push!(to_push, :($matching_error()))
     deparameterize(x) = x isa Symbol ? x : x isa Expr && x.head == :curly ? x.args[1] : throw("Invalid variant name $x")
+    if isdefined(wildcard_stmt, :x)
+        push!(to_push, wildcard_stmt[])
+        exhaustive_stmt = nothing
+    else
+        exhaustive_stmt = :($assert_exhaustive(Val{$tags($Typ)},
+                                               Val{$(Expr(:tuple, QuoteNode.(deparameterize.(variants))...))}))
+    end
     quote
         let $data = $to_match
             $Typ = $typeof($data)
             $check_sum_type($Typ)
-            $assert_exhaustive(Val{$tags($Typ)}, Val{$(Expr(:tuple, QuoteNode.(deparameterize.(variants))...))})
+            $exhaustive_stmt
             $unwrapped = $unwrap($data)
             $ex
         end
-    end |> esc
+    end
 end

test/runtests.jl

@@ -99,7 +99,24 @@ Base.getproperty(f::Result, s::Symbol) = error("Don't do that!")
     @test_throws Exception SumTypes._sum_type(
         :(Blah{T}), :(begin
                          foo{U}(::U)
-                     end ))
+                      end ))
+    @test_throws Exception SumTypes._cases(:(Fruit), :(1))
+    @test_throws Exception SumTypes._cases(:(Fruit), :([1, 2, 3]))
+    @test_throws Exception SumTypes._cases(:(Fruit), :(begin
+                                                       true
+                                                       _ => false
+                                                       banana => false
+                                                       end))
+    @test_throws Exception SumTypes._cases(:(Fruit), :(begin
+                                                       apple => true
+                                                       _ => false
+                                                       banana => false
+                                                       end))
+    @test_throws Exception SumTypes._cases(:(Fruit), :(begin
+                                                       apple => true
+                                                       [banana, orange()] => false
+                                                       _ => false
+                                                       end))
 
     let x = Left([1]), y = Left([1.0]), z = Right([1])
         @test x == y
@@ -320,10 +337,10 @@ end
     Empty
     Class(::UInt8)
     Rep(::Re)
-    Alt(::Re, ::Re)
-    Cat(::Re, ::Re)
+    Alt(::Re,  ::Re)
+    Cat(::Re,  ::Re)
     Diff(::Re, ::Re)
-    And(::Re, ::Re)
+    And(::Re,  ::Re)
 end;
 
 count_classes(r::Re, c=0) = @cases r begin
@@ -332,14 +349,24 @@ count_classes(r::Re, c=0) = @cases r begin
     Rep(x) => c + count_classes(x)
     [Alt, Cat, Diff, And](x, y)  => c + count_classes(x) + count_classes(y)
 end;
-  
+
+is_empty(r::Re) = @cases r begin
+    Empty => true
+    _     => false
+end
+
 @testset "Collection of variants" begin
     @test foo(A(1, 1)) == 2
     @test foo(B(1, 1.5)) == 2.5
     @test foo(C("3")) == 3
     @test foo(D(:a => 4)) == 4
 
     @test count_classes(And(Alt(Rep(Class(0x1)), And(Class(0x1), Empty)), Class(0x0))) == 3
+
+    @test is_empty(Empty)
+    for r ∈ (Class(1), Rep(Class(1)), Alt(Empty, Empty), Cat(Empty, Empty), Diff(Empty, Empty), And(Empty, Empty))
+        @test !is_empty(r)
+    end
 end
 
 end