switched to use more restricted version of flatten, which does not use nested dispatch

instead we now use Base.convert() for elementwise interactions between 
nested containers

Author: S. Sahm

src/ContextManager.jl

@@ -1,13 +1,6 @@
 """
 As ContextManager we denote a computation which has a pre-computation and possibly a cleaning up step
 when run with x->x it is supposed to return x.
-
-Because Julia's typeinference is and stays inaccurate, we cannot really work with TypeTags denoting the elementtype.
-The reason is that for a ContextManager there is no way to get from a ``ContextManager{ElemType=Any}`` to a
-``ContextManager{ElemType=ContextManager}`` in case Any was just ContextManager. This runtime type cast is impossible
-because we would have to run the contextmanager for it, which we don`t want to.
-
-Hence we fallback to using runtime approach, and don't need the elemtype as typetag
 """
 
 """
@@ -35,47 +28,16 @@ macro ContextManager(func)
   end
 end
 
-"""
-we denote flattening by simply checking for this wrapper when executing a ContextManager
-
-if it is FlattenMe{ContextManager}, we will flatten it out, otherwise the FlattenMe will be output
-so that other monads can flatten it later
-"""
-struct FlattenMe{T}
-  value::T
-end
-
-
 # ContextManager is just a wrapper
 # pass through function call syntax
-# in addition we do flattening at runtime
-function (c::ContextManager)(cont)
-  # in words:
-  # cont is the function provided from the outside,
-  # i.e. think about calling this resulting context with cont=identity ``resultingcontext(identity)``
-
-  # flattening something means that the context managers are executed in order
-  # first both preparations in order (1, 2) and then both cleanups in reverse order (2, 1)
-  # if no inner contextmanager is to be called, we found the inner value to return outside
-  function recfunc(inner)
-    if inner isa FlattenMe{<:ContextManager}
-      # TODO check whether inner.value(recfunc) is lethal
-      # .f should be safer, i.e. lead to less recursion
-      inner.value.f(recfunc)
-    else
-      cont(inner)
-    end
-  end
-  c.f(recfunc)
-end
+(c::ContextManager)(cont) = c.f(cont)
 
 
 function Base.eltype(::Type{<:ContextManager{F}}) where F
   Out(apply, F, typeof(identity))
 end
 Base.eltype(::Type{<:ContextManager}) = Any
 
-
 function Base.foreach(f, c::ContextManager)
   Base.map(f, c)(x -> x)
   nothing
@@ -87,3 +49,11 @@ end
 
 # we do flatten via a mere TypeWrapper to be able to do flattening at runtime if type inference is not good enough
 Iterators.flatten(c::ContextManager) = map(FlattenMe, c)
+function Iterators.flatten(contextmanager::ContextManager)
+  @ContextManager cont -> begin
+    # execute both nested ContextManagers in the nested manner
+    contextmanager() do inner_contextmanager
+      convert(ContextManager, inner_contextmanager)(cont)
+    end
+  end
+end

src/DataTypesBasic.jl

@@ -29,7 +29,7 @@ functions, we go with Approach 2. That applies to Option, Try and Either.
 """
 module DataTypesBasic
 
-export @overwrite_Base, @overwrite_Some,
+export @overwrite_Some,
   Const,
   Identity,
   Option, None, Some, issomething, iftrue, iffalse, getOption, # isnothing comes from Base
@@ -45,6 +45,7 @@ include("Option.jl")
 include("Try.jl")
 include("Either.jl")
 include("ContextManager.jl")
+include("convert.jl")
 
 macro overwrite_Base()
   esc(quote

src/Either.jl

@@ -49,14 +49,6 @@ end
 flip(x::Left{L, R}) where {L, R} = Right{R, L}(x.value)
 flip(x::Right{L, R}) where {L, R} = Left{R, L}(x.value)
 
-Base.get(e::Either) = either_get(e)
-either_get(e::Left) = nothing
-either_get(e::Right) = e.value
-
-getOption(e::Either) = either_getOption(e)
-either_getOption(::Left{L, R}) where {L, R} = None{R}()
-either_getOption(e::Right{L, R}) where {L, R} = Some{R}(e.value)
-
 isleft(e::Either) = either_isleft(e)
 either_isleft(e::Left) = true
 either_isleft(e::Right) = false
@@ -81,11 +73,17 @@ getrightOption(e::Either) = either_getrightOption(e)
 either_getrightOption(e::Left{L, R}) where {L, R} = None{R}()
 either_getrightOption(e::Right{L, R}) where {L, R} = Some{R}(e.value)
 
-Base.convert(::Type{<:Option}, e::Either) = getrightOption(e)
+Base.get(e::Either) = getright(e)
+getOption(e::Either) = getrightOption(e)
 
 Base.eltype(::Type{<:Either{L, R}}) where {L, R} = R
 Base.eltype(::Type{<:Either}) = Any
 
+Base.iterate(e::Either, state...) = either_iterate(e, state...)
+either_iterate(e::Right) = e.value, nothing
+either_iterate(e::Right, state) = state
+either_iterate(e::Left) = nothing
+
 Base.foreach(f, x::Either) = either_foreach(f, x)
 either_foreach(f, x::Right) = f(x.value); nothing
 either_foreach(f, x::Left) = nothing
@@ -99,19 +97,6 @@ function either_map(f, x::Left{L, R}) where {L, R}
 end
 
 Iterators.flatten(e::Either) = either_flatten(e)
-either_flatten(x::Right{L, <:Either}) where {L} = x.value
-either_flatten(x::Right{L, Any}) where {L} = Base.Iterators.flatten(Right{L}(x.value))
+either_flatten(x::Right) = convert(Either, x.value)
 either_flatten(x::Left) = x
 either_flatten(x::Left{L, E}) where {L, R, E <: Either{L, R}} = Left{L, R}(x.value)  # just to have better type support
-
-
-# transform Option/Try to Either
-getEither(v::Option) = option_getEither(v)
-option_getEither(v::Some) = Right{Any}(v.value)
-option_getEither(v::None{T}) where T = Left{Nothing, T}(nothing)
-
-getEither(v::Try) = try_getEither(v)
-try_getEither(v::Success) = Right{Any}(v.value)
-try_getEither(v::Failure{T}) where T = Left{Failure, T}(v)
-
-getEither(v::Either) = v

src/Identity.jl

@@ -5,5 +5,9 @@ end
 Base.get(a::Identity) = a.value
 Base.eltype(::Type{<:Identity{T}}) where T = T
 Base.eltype(::Type{<:Identity}) = Any
+
+Base.iterate(a::Identity) = a.value, nothing
+Base.iterate(a::Identity, state) = state
+Base.foreach(f, a::Identity) = begin f(a); nothing; end
 Base.map(f, a::Identity) = Identity(f(a.value))
-Base.Iterators.flatten(a::Identity) = a.value
+Base.Iterators.flatten(a::Identity) = convert(Identity, a.value)

src/Option.jl

@@ -73,8 +73,4 @@ end
 
 Iterators.flatten(x::Option) = option_flatten(x)
 option_flatten(x::None) = x
-option_flatten(x::Some{<:Option}) = x.value
-option_flatten(x::Some{Any}) = Iterators.flatten(Some{typeof(x.value)}(x.value))  # this fixes the type-information which will never return Any
-
-# getOption tries to transform into Option
-getOption(v::Option) = v
+option_flatten(x::Some) = convert(Option, x.value)

src/Try.jl

@@ -117,8 +117,6 @@ getOption(t::Try) = try_getOption(t)
 try_getOption(t::Success) = Some(t.value)
 try_getOption(::Failure{T}) where T = None{T}()
 
-Base.convert(::Type{<:Option}, t::Try) = getOption(t)
-
 Base.eltype(::Type{<:Try{T}}) where T = T
 Base.eltype(::Type{<:Try}) = Any
 
@@ -141,8 +139,7 @@ end
 
 Iterators.flatten(t::Try) = try_flatten(t)
 try_flatten(x::Failure) = x
-try_flatten(x::Success{<:Try}) = x.value
-try_flatten(x::Success{Any}) = Iterators.flatten(Success(x.value))
+try_flatten(x::Success) = convert(Try, x.value)
 
 
 # support for combining exceptions

src/convert.jl

@@ -0,0 +1,32 @@
+# conversions among Identity, Option, Try, Either, Vector
+# =======================================================
+
+# Identity
+Base.convert(::Type{<:Option}, x::Identity) = Option(x.value)
+Base.convert(::Type{<:Try}, x::Identity) = Success(x.value)
+Base.convert(::Type{<:Either}, x::Identity) = Right(x.value)
+Base.convert(::Type{<:Vector}, x::Identity) = [x.value]
+
+# Option
+Base.convert(::Type{<:Vector}, x::Option) = option_asVector(x)
+option_asVector(x::Some) = [x.value]
+option_asVector(x::None) = []
+Base.convert(::Type{<:Either}, x::Option) = option_asEither(x)
+option_asEither(x::Some) = Right{Nothing}(x.value)
+option_asEither(x::None{T}) where T = Left{Nothing, T}(nothing)
+
+
+# Try
+Base.convert(::Type{<:Option}, x::Try) = getOption(x)
+Base.convert(::Type{<:Either}, x::Try) = try_asEither(x)
+try_asEither(x::Success) = Right{Failure}(x.value)
+try_asEither(x::Failure{T}) where T = Left{Failure, T}(x.value)
+Base.convert(::Type{<:Vector}, x::Try) = try_asVector(x)
+try_asVector(t::Success) = [t.value]
+try_asVector(t::Failure) = []
+
+# Either
+Base.convert(::Type{<:Option}, e::Either) = getOption(e)
+Base.convert(::Type{<:Vector}, e::Either) = either_asVector(e)
+either_asVector(e::Right) = [e.value]
+either_asVector(e::Left) = []