rewrote everything to use Identity, Nothing and Stop

Author: S. Sahm

src/DataTypesBasic.jl

@@ -30,16 +30,17 @@ functions, we go with Approach 2. That applies to Option, Try and Either.
 module DataTypesBasic
 
 export Const,
-  Identity,
+  Identity, Stop,
   Option, issomething, iftrue, iffalse, getOption, # isnothing, Nothing, Some comes from Base
-  Either, Left, Right, either, isleft, isright, getleft, getright, getleftOption, getrightOption, getEither, flip_left_right,
-  Try, Success, Failure, @Try, @TryCatch, issuccess, isfailure, MultipleExceptions,
+  Either, either, isleft, isright, getleft, getright, getleftOption, getrightOption, flip_left_right,
+  Try, Failure, @Try, @TryCatch, issuccess, isfailure, MultipleExceptions,
   ContextManager, @ContextManager
 
 using IsDef
 
 include("Const.jl")
 include("Identity.jl")
+include("Stop.jl")
 include("Option.jl")
 include("Try.jl")
 include("Either.jl")

src/Either.jl

@@ -1,106 +1,68 @@
-struct Left{L}
-  value::L
-end
-
-struct Right{R}
-  value::R
-end
-
-const Either{L, R} = Union{Left{L}, Right{R}}
-Either{L, R}(x::L) where {L, R} = Left(x)
-Either{L, R}(x::R) where {L, R} = Right(x)
-Either{L}(x::R) where {L, R} = Right(x)
-Either{L}(x::L) where {L} = Left(x)
-
-
-# conversions/ promotions
-
-# typejoin Left & Left
-Base.typejoin(::Type{Left{L}}, ::Type{Left{L}}) where L = Left{L}
-Base.typejoin(::Type{<:Left}, ::Type{<:Left}) = Left
-# typejoin Right & Right
-Base.typejoin(::Type{Right{R}}, ::Type{Right{R}}) where R = Right{R}
-Base.typejoin(::Type{<:Right}, ::Type{<:Right}) = Right
-# typejoin Left & Right
-Base.typejoin(::Type{Left{L}}, ::Type{Right{R}}) where {L, R} = Either{L, R}
-Base.typejoin(::Type{Right{R}}, ::Type{Left{L}}) where {L, R} = Either{L, R}
-# typejoin Left & Either
-Base.typejoin(::Type{Left{L}}, ::Type{<:Either{L, R}}) where {L, R} = Either{L, R}
-Base.typejoin(::Type{<:Either{L, R}}, ::Type{Left{L}}) where {L, R} = Either{L, R}
-Base.typejoin(::Type{<:Left}, ::Type{<:Either{<:Any, R}}) where {R} = Either{<:Any, R}
-Base.typejoin(::Type{<:Either{<:Any, R}}, ::Type{<:Left}) where {R} = Either{<:Any, R}
-# typejoin Right & Either
-Base.typejoin(::Type{Right{R}}, ::Type{<:Either{L, R}}) where {L, R} = Either{L, R}
-Base.typejoin(::Type{<:Either{L, R}}, ::Type{Right{R}}) where {L, R} = Either{L, R}
-Base.typejoin(::Type{<:Right}, ::Type{<:Either{L}}) where {L} = Either{L}
-Base.typejoin(::Type{<:Either{L}}, ::Type{<:Right}) where {L} = Either{L}
+const Either{L, R} = Union{Stop{L}, Identity{R}}
+Either{L, R}(x::L) where {L, R} = Stop(x)
+Either{L, R}(x::R) where {L, R} = Identity(x)
+Either{L}(x::R) where {L, R} = Identity(x)
+Either{L}(x::L) where {L} = Stop(x)
+
+# Stop is covariate
+Base.convert(::Type{Stop{T}}, x::Stop) where {T} = Stop(Base.convert(T, x.value))
+promote_rule(::Type{Stop{T}}, ::Type{Stop{S}}) where {T, S<:T} = Stop{T}
+
+
+# TypeJoin should work with Identity and Either
+
+# typejoin Stop & Identity
+Base.typejoin(::Type{Stop{L}}, ::Type{Identity{R}}) where {L, R} = Either{L, R}
+Base.typejoin(::Type{Identity{R}}, ::Type{Stop{L}}) where {L, R} = Either{L, R}
+# typejoin Stop & Either
+Base.typejoin(::Type{Stop{L}}, ::Type{<:Either{L, R}}) where {L, R} = Either{L, R}
+Base.typejoin(::Type{<:Either{L, R}}, ::Type{Stop{L}}) where {L, R} = Either{L, R}
+Base.typejoin(::Type{<:Stop}, ::Type{<:Either{<:Any, R}}) where {R} = Either{<:Any, R}
+Base.typejoin(::Type{<:Either{<:Any, R}}, ::Type{<:Stop}) where {R} = Either{<:Any, R}
+# typejoin Identity & Either
+Base.typejoin(::Type{Identity{R}}, ::Type{<:Either{L, R}}) where {L, R} = Either{L, R}
+Base.typejoin(::Type{<:Either{L, R}}, ::Type{Identity{R}}) where {L, R} = Either{L, R}
+Base.typejoin(::Type{<:Identity}, ::Type{<:Either{L}}) where {L} = Either{L}
+Base.typejoin(::Type{<:Either{L}}, ::Type{<:Identity}) where {L} = Either{L}
 # typejoin Either & Either
 Base.typejoin(::Type{<:Either{L, R}}, ::Type{<:Either{L, R}}) where {L, R} = Either{L, R}
 Base.typejoin(::Type{<:Either{L}}, ::Type{<:Either{L}}) where {L} = Either{L}
 Base.typejoin(::Type{<:Either{<:Any, R}}, ::Type{<:Either{<:Any, R}}) where {R} = Either{<:Any, R}
 Base.typejoin(::Type{<:Either}, ::Type{<:Either}) = Either
 
-# Left/Right are covariate
-Base.convert(::Type{Right{T}}, x::Right{S}) where {S, T} = Right(Base.convert(T, x.value))
-Base.convert(::Type{Left{T}}, x::Left{S}) where {S, T} = Left(Base.convert(T, x.value))
-Base.convert(::Type{Either{L, R2}}, x::Right{R}) where {L, R, R2} = Right(Base.convert(R2, x.value))
-Base.convert(::Type{Either{L2, R}}, x::Left{L}) where {L, L2, R} = Left(Base.convert(L2, x.value))
-promote_rule(::Type{Left{T}}, ::Type{Left{S}}) where {T, S<:T} = Left{T}
-promote_rule(::Type{Right{T}}, ::Type{Right{S}}) where {T, S<:T} = Right{T}
+# Conversion should also work with Either
+Base.convert(::Type{Either{L, R}}, x::Identity) where {L, R} = Identity(Base.convert(R, x.value))
+Base.convert(::Type{Either{L, R}}, x::Stop) where {L, R} = Stop(Base.convert(L, x.value))
 
+Base.eltype(::Type{<:Either{L, R}}) where {L, R} = R
+Base.eltype(::Type{<:Either{<:Any, R}}) where {R} = R
+Base.eltype(::Type{<:Either}) = Any
 
-# == controversy https://github.com/JuliaLang/julia/issues/4648
-Base.:(==)(a::Right, b::Right) = a.value == b.value
-Base.:(==)(a::Left, b::Right) = false
-Base.:(==)(a::Right, b::Left) = false
-Base.:(==)(a::Left, b::Left) = a.value == b.value
-
-# TypeClasses.unionall_implementationdetails(::Type{<:Either{L, R}}) where {L, R} = Either{L, R}
-# Traits.leaftypes(::Type{Either}) = [Either{newtype(), newtype(), Left}, Either{newtype(), newtype(), Right}]
-# Traits.leaftypes(::Type{Either{T}}) where T = [Either{T, newtype(), Left}, Either{T, newtype(), Right}]
 
+# Helpers for Either
+# ------------------
 
 function either(left_false, comparison::Bool, right_true)
-  comparison ? Right(right_true) : Left(left_false)
+  comparison ? Identity(right_true) : Stop(left_false)
 end
 
-flip_left_right(x::Left) = Right(x.value)
-flip_left_right(x::Right) = Left(x.value)
-
-isleft(e::Left) = true
-isleft(e::Right) = false
+flip_left_right(x::Stop) = Identity(x.value)
+flip_left_right(x::Identity) = Stop(x.value)
 
-isright(e::Left) = false
-isright(e::Right) = true
+isleft(e::Stop) = true
+isleft(e::Identity) = false
 
-getleft(e::Left) = e.value
-getleft(e::Right) = nothing
-
-getright(e::Left) = nothing
-getright(e::Right) = e.value
-
-getleftOption(e::Left{L}) where {L} = Some{L}(e.value)
-getleftOption(e::Right) = nothing
-
-getrightOption(e::Left) = nothing
-getrightOption(e::Right{R}) where {R} = Some{R}(e.value)
-
-Base.get(e::Either) = getright(e)
-getOption(e::Either) = getrightOption(e)
-
-Base.eltype(::Type{<:Either{L, R}}) where {L, R} = R
-Base.eltype(::Type{<:Left{L}}) where L = Any  # we have to specify this clause as otherwise we get ERROR: UndefVarError: R not defined
-Base.eltype(::Type{<:Either}) = Any
+isright(e::Stop) = false
+isright(e::Identity) = true
 
-Base.iterate(e::Right) = e.value, nothing
-Base.iterate(e::Right, state) = state
-Base.iterate(e::Left) = nothing
+getleft(e::Stop) = e.value
+# getleft(e::Identity) = nothing  # throw an error if getleft is called on Identity
 
-Base.foreach(f, x::Right) = f(x.value); nothing
-Base.foreach(f, x::Left) = nothing
+# getright(e::Stop) = nothing  # throw an error if getright is called on Stop
+getright(e::Identity) = e.value
 
-Base.map(f, x::Right) = Right(f(x.value))
-Base.map(f, x::Left) = x
+getleftOption(e::Stop{L}) where {L} = Identity{L}(e.value)
+getleftOption(e::Identity) = nothing
 
-Iterators.flatten(x::Right) = convert(Either, x.value)
-Iterators.flatten(x::Left) = x
+getrightOption(e::Stop) = nothing
+getrightOption(e::Identity{R}) where {R} = e

src/Identity.jl

@@ -1,6 +1,12 @@
 struct Identity{T}
   value::T
 end
+# == controversy https://github.com/JuliaLang/julia/issues/4648
+Base.:(==)(a::Identity, b::Identity) = a.value == b.value
+
+function Base.show(io::IO, x::Identity)
+  print(io, "Identity($(repr(x.value)))")
+end
 
 Base.get(a::Identity) = a.value
 Base.eltype(::Type{<:Identity{T}}) where T = T
@@ -11,3 +17,11 @@ 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) = convert(Identity, a.value)
+
+# Identity is covariate
+Base.convert(::Type{Identity{T}}, x::Identity) where {T} = Identity(Base.convert(T, x.value))
+promote_rule(::Type{Identity{T}}, ::Type{Identity{S}}) where {T, S<:T} = Identity{T}
+
+# we need this for safety, if someone overwrites typejoin for Unions with Identiy
+Base.typejoin(::Type{Identity{T}}, ::Type{Identity{T}}) where T = Identity{T}
+Base.typejoin(::Type{<:Identity}, ::Type{<:Identity}) = Identity

src/Option.jl

@@ -1,9 +1,11 @@
-const Option{T} = Union{Nothing, Some{T}}
+# we don't use Some because it does not behave like a container, but more like `Ref`
+# for details/update see https://github.com/JuliaLang/julia/issues/35911
+const Option{T} = Union{Nothing, Identity{T}}
 
 Option{T}(a::Nothing) where T = nothing
-Option{T}(a::T) where T = Some{T}(a)
+Option{T}(a::T) where T = Identity{T}(a)
 Option(a::Nothing) = nothing
-Option(a::T) where T = Some{T}(a)
+Option(a::T) where T = Identity{T}(a)
 Option{T}() where T = nothing
 Option() = nothing
 
@@ -34,38 +36,21 @@ Base.convert(::Type{Option}, x::Option) = x
 # Option{T} seems to be already covered by normal Union, Some, Nothing conversions, no need to provide them
 
 function iftrue(func::Function, b::Bool)
-  b ? Some(func()) : nothing
+  b ? Identity(func()) : nothing
 end
 function iftrue(b::Bool, t)
-  b ? Some(t) : nothing
+  b ? Identity(t) : nothing
 end
 function iffalse(func::Function, b::Bool)
-  !b ? Some(func()) : nothing
+  !b ? Identity(func()) : nothing
 end
 function iffalse(b::Bool, t)
-  !b ? Some(t) : nothing
+  !b ? Identity(t) : nothing
 end
 
 issomething(m::Nothing) = false
-issomething(m::Some) = true
-
-Base.get(m::Some) = m.value
-Base.get(m::Nothing) = nothing
+issomething(m::Identity) = true
 
 # Base.eltype is not well defined for Some, and always returns Any
 Base.eltype(::Type{<:Option{T}}) where {T} = T
 Base.eltype(::Type{Nothing}) = Any  # if we don't provide this clause, we get ERROR: UndefVarError: T not defined, as the above clause matches, but no T can be infered from Nothing
-
-
-Base.iterate(o::Some) = o.value, nothing
-Base.iterate(o::Some, state) = state
-Base.iterate(o::Nothing) = nothing
-
-Base.foreach(f, o::Some) = f(o.value); nothing
-Base.foreach(f, o::Nothing) = nothing
-
-Base.map(f, o::Some) = Some(f(o.value))
-Base.map(f, ::Nothing) = nothing
-
-Iterators.flatten(x::Nothing) = x
-Iterators.flatten(x::Some) = convert(Option, x.value)

src/Stop.jl

@@ -0,0 +1,28 @@
+"""
+wrapper to indicate that a computation should stop, including information about the stop
+"""
+struct Stop{T}
+  value::T
+end
+# Stop with no args is just nothing
+Stop() = nothing
+
+# == controversy https://github.com/JuliaLang/julia/issues/4648
+Base.:(==)(a::Stop, b::Stop) = a.value == b.value
+# Stop is a non-container, hence has always eltype Any
+Base.eltype(::Type{<:Stop}) = Any
+
+isstop(::Stop) = true
+isstop(other) = false
+Base.iterate(e::Stop) = nothing
+Base.foreach(f, x::Stop) = nothing
+Base.map(f, x::Stop) = x
+Iterators.flatten(x::Stop) = x
+
+# Stop is covariate
+Base.convert(::Type{Stop{T}}, x::Stop) where {T} = Stop(Base.convert(T, x.value))
+promote_rule(::Type{Stop{T}}, ::Type{Stop{S}}) where {T, S<:T} = Stop{T}
+
+# we need this for safety, if someone overwrites typejoin for Unions with Stop
+Base.typejoin(::Type{Stop{T}}, ::Type{Stop{T}}) where T = Stop{T}
+Base.typejoin(::Type{<:Stop}, ::Type{<:Stop}) = Stop