further changes

Author: schlichtanders

src/ExtensibleEffects.jl

@@ -17,11 +17,35 @@ using TypeClasses
 @reexport using DataTypesBasic
 export @pure  # users need @pure for the monadic syntax @syntax_eff
 
+include("utils.jl")
 include("core.jl")
 include("effecthandler.jl")
 include("outereffecthandler.jl")
 include("autorun.jl")
 include("syntax.jl")
 include("instances.jl")
 
+
+# Type Inference Workarounds
+# --------------------------
+
+# TODO unfortunately this does not work yet for everything
+# Cthulhu still tells that inference failed because of recursion
+
+# define recursion_relation so that inference works better
+# we probably have problems with true infinite cases now, but that should be still
+# better in total
+
+# It is a workaround this issue https://github.com/JuliaLang/julia/issues/45759
+
+recursion_relation_always_true(@nospecialize(_...)) = true
+
+for f in (TypeClasses.flatmap, eff_flatmap, map, Eff)
+  for m in methods(f)
+    if Base.moduleroot(m.module) === ExtensibleEffects
+      m.recursion_relation = recursion_relation_always_true
+    end
+  end
+end
+
 end # module

src/autorun.jl

@@ -67,9 +67,10 @@ function _autorun(handlers, eff::Eff)
 end
 
 """
-    eff_autohandler(value) = Base.typename(typeof(value)).wrapper
+    eff_autohandler(value) = type of value
 
 Overwrite this if the default autohandler extraction does not work for your case.
 E.g. for `value::Vector` the default would return `Array`, hence we need to overwrite it individually.
 """
-eff_autohandler(value) = Base.typename(typeof(value)).wrapper
+eff_autohandler(value) = TypeVal{Base.typename(typeof(value)).wrapper}()
+# we wrap the type into a TypeVal as Type values have limited support for specialization

src/core.jl

@@ -12,25 +12,26 @@ only for internal purposes, captures the still unevaluated part of an Eff
 """
 struct Continuation{Fs}
   functions::Fs
-  Continuation(functions...) = new{typeof(functions)}(functions)
+  # specialization on vararg `...` is triggered by explicit ::Vararg type annotation
+  Continuation(functions::Vararg{Any,N}) where {N} = new{typeof(functions)}(functions)
 end
 
 """
 central data structure which can capture Effects in a way that they can interact, while each
 is handled independently on its own
 """
-struct Eff{Effectful, Fs}
+struct Eff{Effectful,Fs}
   effectful::Effectful
   cont::Continuation{Fs}
 end
 
-function Eff(effectful::E, cont::Continuation{Tuple{}}) where E<:NoEffect
+function Eff(effectful::E, cont::Continuation{Tuple{}}) where {E<:NoEffect}
   # also run this if isempty(cont) to stop infinite recursion
   # (which happens otherwise because empty cont results returns noeffect for convenience)
-  Eff{E, Tuple{}}(effectful, cont)
+  Eff{E,Tuple{}}(effectful, cont)
 end
 
-function Eff(effectful::NoEffect, cont::Continuation{Fs}) where Fs
+function Eff(effectful::NoEffect, cont::Continuation{Fs}) where {Fs}
   # Evaluate NoEffect directly to make sure, we don't have a chain of NoEffect function accumulating
   # e.g. with ContextManager this could lead to things not being evaluated, while the syntax suggest
   # everything is evaluated, and hence the ContextManager may finalize resource despite they are still used.
@@ -79,5 +80,13 @@ Base.map(f, c::Continuation) = Continuation(c.functions..., noeffect ∘ f)
 # -----------------------
 
 TypeClasses.pure(::Type{<:Eff}, a) = noeffect(a)
-TypeClasses.map(f, eff::Eff) = TypeClasses.flatmap(noeffect ∘ f, eff)
-TypeClasses.flatmap(f, eff::Eff) = Eff(eff.effectful, Continuation(eff.cont.functions..., f))
+
+# we use @generated functions to force inlining of the definition
+# which prevents bad type inference on recursive calls
+function TypeClasses.map(f::F, eff::Eff) where {F}
+  Eff(eff.effectful, Continuation(eff.cont.functions..., noeffect ∘ f))
+end
+
+function TypeClasses.flatmap(f::F, eff::Eff) where {F}
+  Eff(eff.effectful, Continuation(eff.cont.functions..., f))
+end

src/effecthandler.jl

@@ -1,3 +1,5 @@
+using SimpleMatch: @match
+
 """
     runhandlers(handlers, eff)
     runhandlers((Vector, Option), eff)::Vector{Option{...}}
@@ -32,13 +34,15 @@ end
 like `ExtensibleEffects.runlast`, however if the Eff is not yet completely handled, it just returns it.
 """
 function runlast_ifpossible(final::Eff)
-  if isempty(final.cont) && final.effectful isa NoEffect
-    final.effectful.value
-  else
-    final
+  @match(final.cont, final.effectful) do f
+    f(::Continuation{Tuple{}}, effectful::NoEffect) = effectful.value
+    f(_, _) = final
   end
 end
 
+# we reinterpret Types as TypeVal typevariables in order to automatically
+# specialize functions on these types
+runhandler(::Type{Handler}, eff::Eff) where Handler = runhandler(TypeVal{Handler}(), eff)
 
 """
     runhandler(handler, eff::Eff)
@@ -49,11 +53,11 @@ key method to run an effect on some effecthandler Eff
 note that we represent effectrunners as plain types in order to associate
 standard effect runners with types like Vector, Option, ...
 """
-function runhandler(handler, eff::Eff)
+function runhandler(handler, eff::Eff)  # this weird type parameter is needed because of https://discourse.julialang.org/t/need-help-on-understanding-type-inference-performance/80600
   eff_applies(handler, eff.effectful) || return runhandler_not_applies(handler, eff)
 
   interpreted_continuation = if isempty(eff.cont)
-    # you may think we could simplify this, however for eff `eff_flatmap(handler, x -> eff_pure(handler,  x), eff) != eff` 
+    # you may think we could simplify this, however for eff `eff_flatmap(handler, x -> eff_pure(handler,  x), eff) != eff`
     # because there is the handler which may have extra information
     Continuation(x -> _eff_pure(handler, x))
   else
@@ -62,10 +66,11 @@ function runhandler(handler, eff::Eff)
   _eff_flatmap(handler, interpreted_continuation, eff.effectful)
 end
 
+
 """
     runhandler_not_applies(handler, eff)
 
-if your handler does not apply, use this as the fallback to handle the unknown effect. 
+if your handler does not apply, use this as the fallback to handle the unknown effect.
 """
 function runhandler_not_applies(handler, eff::Eff)
   interpreted_continuation = if isempty(eff.cont)
@@ -78,6 +83,7 @@ function runhandler_not_applies(handler, eff::Eff)
   Eff(eff.effectful, interpreted_continuation)
 end
 
+
 """
     @runhandlers handlers eff
 
@@ -138,6 +144,9 @@ i.e. assuming the effect is handled afterwards.
 """
 eff_flatmap(handler, interpreted_continuation, value) = eff_flatmap(interpreted_continuation, value)
 
+# extra support for Type handlers
+eff_flatmap(::TypeVal{Handler}, interpreted_continuation, value) where Handler = eff_flatmap(Handler, interpreted_continuation, value)
+
 
 # eff_pure
 # --------
@@ -155,6 +164,9 @@ Plain values will be wrapped with `noeffect` automatically.
 """
 function eff_pure end
 
+# extra support for Type handlers
+eff_pure(::TypeVal{Handler}, value) where Handler = eff_pure(Handler, value)
+
 
 # eff_applies
 # -----------
@@ -171,3 +183,6 @@ which are captured in the handler type `CallableHandler(args, kwargs)`.
 Hence above you would choose YourHandlerType = `CallableHandler`, and ToBeHandledEffectType = `Callable`.
 """
 eff_applies(handler, value) = false
+
+# extra support for Type handlers
+eff_applies(::TypeVal{Handler}, value) where Handler = eff_applies(Handler, value)

src/instances.jl

@@ -17,6 +17,30 @@ function ExtensibleEffects.eff_flatmap(continuation, a)
   eff_of_a
 end
 
+# Try to improve performance by merging map and flip_types
+function eff_flatmap_iteration(continuation::F, iter::T) where {F, T}
+  first = iterate(iter)
+  if first === nothing
+    # only in this case we actually need `pure(eltype(T))` and `neutral(T)`
+    # for non-empty sequences everything works for Types without both
+    # TODO include continuation
+    pure(T, neutral(eltype(T)))
+  else
+    _b, state = first
+    b = continuation(_b)
+    # we need to abstract out details so that combine can actually work
+    # note that because of its definition, pure(ABC, x) == pure(A, x)
+    # start = feltype_unionall_implementationdetails(fmap(traitsof, a -> pure(traitsof, T, a), x)) # we can only combine on S
+    start = map(c -> pure(T, c), b)  # we can only combine on ABC
+    Base.foldl(Iterators.rest(iter, state); init = start) do acc, _b
+      b = continuation(_b)
+      mapn(acc, b) do acc′, c  # working in applicative context B
+        acc′ ⊕ pure(T, c)  # combining on T
+      end
+    end
+  end
+end
+
 # NoEffect
 # --------
 ExtensibleEffects.eff_applies(handler::Type{<:NoEffect}, effectful::NoEffect) = true
@@ -38,7 +62,7 @@ ExtensibleEffects.eff_flatmap(continuation, effectful::Identity) = continuation(
 # -----
 ExtensibleEffects.eff_applies(handler::Type{<:Const}, effectful::Const) = true
 # usually Const does not have a pure, however within Eff, it is totally fine,
-# as continuations on Const never get evaluated anyways, 
+# as continuations on Const never get evaluated anyways,
 # (and eff_pure is only called at the very end, when literal values are reached)
 ExtensibleEffects.eff_pure(handler::Type{<:Const}, value) = value
 ExtensibleEffects.eff_flatmap(continuation, effectful::Const) = effectful
@@ -305,7 +329,7 @@ ExtensibleEffects.eff_pure(handler::StateHandler, value) = (value, handler.state
 # We need to define our own runhandler instead. It is a bit more complex, but still straightforward and compact.
 function ExtensibleEffects.runhandler(handler::StateHandler, eff::Eff)
   eff_applies(handler, eff.effectful) || return runhandler_not_applies(handler, eff)
-  
+
   value, nextstate = eff.effectful(handler.state)
   nexthandler = StateHandler(nextstate)
   if isempty(eff.cont)

src/utils.jl

@@ -0,0 +1,16 @@
+struct TypeVal{T}
+    TypeVal{T}() where T = new{T}()
+end
+
+# needed because of https://discourse.julialang.org/t/need-help-on-understanding-type-inference-performance/80600/5
+macro specializetype(var, expr)
+    var = esc(var)
+    expr = esc(expr)
+    quote
+        let
+            f(::Type{$var}) where $var = $expr
+            f($var) = $expr
+            f($var)
+        end
+    end
+end

test/benchmarks.jl

@@ -1,5 +1,5 @@
 using ExtensibleEffects
-using ExtensibleEffects: runhandler, Continuation, Eff, _eff_pure, @specializetype, myeff_flatmap, myeff_flatmap2
+using ExtensibleEffects: runhandler, Continuation, Eff, _eff_pure, @specializetype, myeff_flatmap #, myeff_flatmap2
 using TypeClasses
 using BenchmarkTools
 using JET
@@ -19,11 +19,11 @@ runhandlers(Vector, program1)
 
 function test(handler, eff)
     continuation = if isempty(eff.cont)
-        # you may think we could simplify this, however for eff `eff_flatmap(handler, x -> eff_pure(handler,  x), eff) != eff` 
+        # you may think we could simplify this, however for eff `eff_flatmap(handler, x -> eff_pure(handler,  x), eff) != eff`
         # because there is the handler which may have extra information
-        @specializetype handler Continuation(x -> ExtensibleEffects._eff_pure(handler, x))
+        Continuation(x -> ExtensibleEffects._eff_pure(handler, x))
     else
-        @specializetype handler Continuation(x -> ExtensibleEffects.runhandler(handler, eff.cont(x)))
+        Continuation(x -> ExtensibleEffects.runhandler(handler, eff.cont(x)))
     end
 
     a = eff.effectful
@@ -58,7 +58,7 @@ eff_mark_eltype(eltype, eff) = EffWithEltype2{eltype, typeof(eff)}(eff)
 eff_mark_eltype(::Type{eltype}) where eltype = eff -> eff_mark_eltype(eltype, eff)
 
 Base.IteratorEltype(::EffWithEltype2) = Iterators.HasEltype()
-Base.eltype(::EffWithEltype2{ElType}) where ElType = ElType 
+Base.eltype(::EffWithEltype2{ElType}) where ElType = ElType
 
 @code_warntype eff_mark_eltype(Vector, eff)
 @code_warntype map(eff_mark_eltype(Vector), a_of_eff_of_a)
@@ -121,7 +121,7 @@ function _foldl_3(op::OP, init, itr) where {OP}
     y = iterate(itr)
     y === nothing && return init
     v = op(init, y[1])
-    
+
     y = iterate(itr, y[2])
     y === nothing && return v
     v = op(v, y[1])
@@ -194,7 +194,7 @@ function test3(::Type{T}, a1, a2) where T
         #= /home/ssahm/.julia/dev/TypeClasses/src/TypeClasses/FunctorApplicativeMonad.jl:167 =#
         a2 -> func(a1, a2)
     end
-    
+
     ap1 = map(curried_func, a1)
     ap2 = a2
 
@@ -217,15 +217,15 @@ function test3(::Type{T}, a1, a2) where T
     TypeClasses.flatmap(f_flatmap, ap1)
 
     myeff_flatmap(f_flatmap, ap1)
-    
+
     # myflatmap2(f_flatmap, ap1)
-    
+
 
     # myflatmap(f, eff::Eff) = Eff(eff.effectful, Continuation(eff.cont.functions..., f))
     # myflatmap(f_flatmap, ap1)
-    
-    
-    
+
+
+
     # eff = ap1
     # f = f_flatmap
     # Eff(eff.effectful, Continuation(eff.cont.functions..., f))
@@ -263,7 +263,7 @@ test2(ap1, ap2) = TypeClasses.flatmap(ap1) do f
         f(a)
     end
 end
-@code_warntype test2(ap1, ap2) 
+@code_warntype test2(ap1, ap2)
 
 create_fflatmap(ap2) = f -> TypeClasses.map(ap2) do a
     f(a)
@@ -363,7 +363,7 @@ mapn_code(2)
 
 
 
-singleton_array(T::Type{<:AbstractArray}, a) = convert(T, [a]) 
+singleton_array(T::Type{<:AbstractArray}, a) = convert(T, [a])
 
 struct ChainedFunctions{Fs}
     functions::Fs