Good sumtypes

src/util/MyActive.jl

@@ -0,0 +1,150 @@
+# Active patterns
+module MyActive
+
+if isdefined(Base, :Experimental) && isdefined(Base.Experimental, Symbol("@compiler_options"))
+    @eval Base.Experimental.@compiler_options compile=min infer=no optimize=0
+end
+
+using MLStyle
+using MLStyle.Qualification
+using MLStyle.AbstractPatterns
+
+export @active, active_def
+@nospecialize
+function active_def(P, body, mod::Module, line::LineNumberNode)
+    inferred_type = @switch P begin
+        @case :($P::$t_expr)
+        mod.eval(t_expr)
+        @case _
+        Any
+    end
+
+    @switch P begin
+        @case Expr(
+            :call,
+            Expr(:curly, t, type_args...) || t && let type_args = []
+            end,
+            arg,
+        ) && if t isa Symbol
+        end
+
+        @case _
+        error("malformed active pattern definition: $P")
+    end
+
+    # We don't want to redefine the struct
+    definition = line
+    parametric = isempty(type_args) ? [] : type_args
+    prepr = "$P"
+    token = gensym(prepr)
+    v_ty = Val{(view, token)}
+    v_val = Val((view, token))
+
+    quote
+        $definition
+        (::$v_ty)($(parametric...)) = $arg -> $body
+        $line
+        function $MLStyle.pattern_uncall(
+            t::($t isa Function ? typeof($t) : Type{$t}),
+            self::Function,
+            type_params,
+            type_args,
+            args,
+        )
+            $line
+            isempty(type_params) || error("A ($t) pattern requires no type params.")
+            parametric = isempty(type_args) ? [] : type_args
+            n_args = length(args)
+
+            function trans(expr)
+                Expr(:call, Expr(:call, $v_val, parametric...), expr)
+            end
+
+            function guard2(expr)
+                if n_args === 0
+                    :($expr isa Bool && $expr)
+                elseif n_args === 1
+                    expr_s = "$t(x)"
+                    msg =
+                        "invalid use of active patterns: " *
+                        "1-ary view pattern($expr_s) should accept Union{Some{T}, Nothing} " *
+                        "instead of Union{T, Nothing}! " *
+                        "A simple solution is:\n" *
+                        "  (@active $expr_s ex) =>\n  (@active $expr_s let r=ex; r === nothing? r : Some(r)) end"
+
+                    :($expr !== nothing && ($expr isa $Some || begin
+                        $error($msg)
+                    end))
+                else
+                    :($expr isa $Tuple && length($expr) === $n_args)
+                end
+            end
+
+            extract = if n_args <= 1
+                function (expr::Any, i::Int, ::Any, ::Any)
+                    expr
+                end
+            else
+                function (expr::Any, i::Int, ::Any, ::Any)
+                    :($expr[$i])
+                end
+            end
+
+            type_infer(_...) = $inferred_type
+
+            comp = $PComp(
+                $prepr,
+                type_infer;
+                view = $SimpleCachablePre(trans),
+                guard2 = $NoncachablePre(guard2),
+            )
+            ps = if n_args === 0
+                []
+            elseif n_args === 1
+                [self(Expr(:call, Some, args[1]))]
+            else
+                [self(e) for e in args]
+            end
+            $decons(comp, extract, ps)
+        end
+    end
+end
+
+"""
+Simple active pattern implementation.
+You can give a qualifier in the first argument of `@active` to customize its visibility in other modules.
+```julia
+    @active F(x) begin
+        if x > 0
+            nothing
+        else
+            :ok
+        end
+    end
+
+    @match -1 begin
+        F(:ok) => false
+        _ => true
+    end # true
+
+    @active public IsEven(x) begin
+        x % 2 === 0
+    end
+
+    @match 4 begin
+        IsEven() => :ok
+        _ => :err
+    end # :ok
+```
+"""
+macro active(qualifier, case, active_body)
+    deprecate_qualifier_macro(qualifier, __source__)
+    active_def(case, active_body, __module__, __source__) |> esc
+end
+
+macro active(case, active_body)
+    active_def(case, active_body, __module__, __source__) |> esc
+end
+@specialize
+
+end