fixed promote_type and added tests for it

also changed double quotes `` to single `

Author: Stephan Sahm

src/Const.jl

@@ -21,10 +21,14 @@ Iterators.flatten(c::Const) = c
 
 Base.eltype(::Type{<:Const}) = Any
 
-# Const is covariate
 Base.convert(::Type{Const{T}}, x::Const) where {T} = Const(Base.convert(T, x.value))
+# Const is covariate
+# promote_rule only works on concrete types, more general checks Type{<:Const} may overwrite
+# unintentionally more specific promote_rule types
 promote_rule(::Type{Const{T}}, ::Type{Const{S}}) where {T, S<:T} = Const{T}
+promote_rule(::Type{Const{T}}, ::Type{Const}) where T = Const
+promote_rule(::Type{Const}, ::Type{Const}) = Const
 
-# we need this for safety, if someone overwrites typejoin for Unions with Const
-Base.typejoin(::Type{Const{T}}, ::Type{Const{T}}) where T = Const{T}
-Base.typejoin(::Type{<:Const}, ::Type{<:Const}) = Const
+# we need this for safety, if someone overwrites promote_typejoin for Unions with Const
+Base.promote_typejoin(::Type{Const{T}}, ::Type{Const{T}}) where T = Const{T}
+Base.promote_typejoin(::Type{<:Const}, ::Type{<:Const}) = Const

src/ContextManager.jl

@@ -9,7 +9,7 @@ function which expects one argument, which itself is a function. Think of it lik
 function contextmanagerready(cont)
   # ... do something before
   value = ... # create some value to work on later
-  result = cont(value)  # pass the value to the continuation function (think like ``yield``)
+  result = cont(value)  # pass the value to the continuation function (think like `yield`)
   # ... do something before exiting, e.g. cleaning up
   result # IMPORTANT: always return the result of the `cont` function
 end
@@ -31,6 +31,8 @@ end
 # ContextManager is just a wrapper
 # pass through function call syntax
 (c::ContextManager)(cont) = c.f(cont)
+Base.run(cont, c::ContextManager) = c(cont)
+Base.run(c::ContextManager) = c(identity)
 
 
 function Base.eltype(::Type{<:ContextManager{F}}) where F

src/DataTypesBasic.jl

@@ -9,8 +9,8 @@ Approach 1.
 ===========
 
 Advantages: Providing definitions for the concrete is actually enough for typeinference
-Disadvantages: The typeinference like for ``Dict(:a => Some(1), :b => None())`` would infer
-  ``Dict{Symbol, Any}`` instead of `Dict{Symbol, Union{Some, None}}`.
+Disadvantages: The typeinference like for `Dict(:a => Some(1), :b => None())` would infer
+  `Dict{Symbol, Any}` instead of `Dict{Symbol, Union{Some, None}}`.
 
   The internal details for this is that in many cases `Base.promote_typejoin(type1, type2)` is used to come up
   with a common type.
@@ -20,7 +20,7 @@ Disadvantages: The typeinference like for ``Dict(:a => Some(1), :b => None())``
 Approach 2.
 ===========
 
-Advantages: ``Dict(:a => Some(1), :b => None())`` would indeed infer ``Dict{Symbol, Option}``
+Advantages: `Dict(:a => Some(1), :b => None())` would indeed infer `Dict{Symbol, Option}`
 Disadvantages: you need to be careful to always implement functionalities first on separate functions unique to the
   sealed type, and then point generic functions to the specific one via `genericfunction(o::Option) = optionfunction(o)`
 
@@ -32,19 +32,25 @@ module DataTypesBasic
 export Const, Identity,
   Option, issomething, iftrue, iffalse, getOption, # isnothing, Nothing, Some comes from Base
   Either, either, isleft, isright, getleft, getright, getleftOption, getrightOption, flip_left_right,
+  OptionEither,
   Try, Thrown, @Try, @TryCatch, issuccess, isexception, MultipleExceptions,
   ContextManager, @ContextManager
 
+using Compat
 using IsDef
 
+# type definitions
 include("Nothing.jl")
 include("Const.jl")
 include("Identity.jl")
 include("Option.jl")
 include("Try.jl")
 include("Either.jl")
 include("ContextManager.jl")
-include("convert.jl")
+include("OptionEither.jl")
 
+# interoperability between types
+include("promote_type.jl")
+include("convert.jl")
 
 end # module

src/Either.jl

@@ -4,32 +4,6 @@ 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} = Const(x)
 
-
-# TypeJoin should work with Identity and Either
-
-# typejoin Const & Identity
-Base.typejoin(::Type{Const{L}}, ::Type{Identity{R}}) where {L, R} = Either{L, R}
-Base.typejoin(::Type{Identity{R}}, ::Type{Const{L}}) where {L, R} = Either{L, R}
-# typejoin Const & Either
-Base.typejoin(::Type{Const{L}}, ::Type{<:Either{L, R}}) where {L, R} = Either{L, R}
-Base.typejoin(::Type{<:Either{L, R}}, ::Type{Const{L}}) where {L, R} = Either{L, R}
-Base.typejoin(::Type{<:Const}, ::Type{<:Either{<:Any, R}}) where {R} = Either{<:Any, R}
-Base.typejoin(::Type{<:Either{<:Any, R}}, ::Type{<:Const}) 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
-
-# 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::Const) where {L, R} = Const(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

src/Identity.jl

@@ -22,10 +22,14 @@ 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))
+# Identity is covariate
+# promote_rule only works on concrete types, more general checks Type{<:Const} may overwrite
+# unintentionally more specific promote_rule types
 promote_rule(::Type{Identity{T}}, ::Type{Identity{S}}) where {T, S<:T} = Identity{T}
+promote_rule(::Type{Identity{T}}, ::Type{Identity}) where T = Identity
+promote_rule(::Type{Identity}, ::Type{Identity}) = Identity
 
 # 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
+Base.promote_typejoin(::Type{Identity{T}}, ::Type{Identity{T}}) where T = Identity{T}
+Base.promote_typejoin(::Type{<:Identity}, ::Type{<:Identity}) = Identity

src/Option.jl

@@ -24,16 +24,6 @@ For further discussion see https://discourse.julialang.org/t/is-this-a-bug-some-
 Base.:(==)(a::Some, b::Some) = a.value == b.value
 Base.hash(a::Some) = hash(a.value)
 
-# we need to overwrite convert, because in the case that no conversion is possible, we currently get the super uninformative error
-# ERROR: could not compute non-nothing type
-# Stacktrace:
-#  [1] nonnothingtype_checked(::Type) at ./some.jl:29
-#  [2] convert(::Type{Union{Nothing, Some{T}} where T}, ::Int64) at ./some.jl:34
-#  [3] top-level scope at none:0
-# importantly, we should only add clauses for Type{Option} and not Type{<:Option} to not interfere with existing code
-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 ? Identity(func()) : nothing
 end

src/OptionEither.jl

@@ -0,0 +1,3 @@
+const OptionEither{L, R} = Union{Nothing, Const{L}, Identity{R}}
+
+# TODO anything more todo here?

src/convert.jl

@@ -1,24 +1,106 @@
-# conversions among Identity, Option, Try, Either, Vector
-# =======================================================
+# conversions among concrete types
+# ================================
 
 # Vector
+# ------
+
 Base.convert(::Type{<:Vector}, x::Identity) = [x.value]
 Base.convert(::Type{<:Vector}, x::Nothing) = []
 Base.convert(::Type{<:Vector}, x::Const) = []
+# ContextManager is executed if someone asks for a Vector from ContextManager
+Base.convert(::Type{<:Vector}, x::ContextManager) = [x(identity)]
 
 # Const
+# -----
+
 Base.convert(::Type{<:Const}, x::Nothing) = Const(nothing)
 function Base.convert(::Type{Const}, x::Vector)
   @assert !isempty(x) "can only convert empty Vector to Nothing, got $(x)"
   Const([])
 end
 
 # Nothing
+# -------
+
 function Base.convert(::Type{Nothing}, x::Vector)
   @assert !isempty(x) "can only convert empty Vector to Nothing, got $(x)"
   nothing
 end
 
 # Identity
+# --------
+
 # Nothing and Const are just passed through when asked to convert to identity
+# this is intended special behaviour in order for Identity + Nothing/Const to work together as Option/Either
 Base.convert(::Type{Identity}, x::Union{Nothing, Const}) = x
+# ContextManager is executed
+Base.convert(::Type{<:Identity}, x::ContextManager) = Identity(x(identity))
+
+
+# ContextManager
+# --------------
+
+Base.convert(::Type{<:ContextManager}, x::Identity) = @ContextManager cont -> cont(x.value)
+
+# Note that we do not support convert from Nothing/Const to ContextManager.
+# ContextManager is similar to Identity a Container which always contains a single element,
+# however, unlike Identity, we cannot simply pass-through Nothing/Const and preserve the empty container by this trick.
+# To map over ContextManager, you NEED to create a new ContextManager, if you don't want to run the contextmanager
+# immediately. Hence, also flatmap needs to create another ContextManager, i.e. single element container.
+
+# Vector is neither supported, as it rather corresponds to Continuable which can have several calls to `cont`
+# while ContextManager should only have one call to `cont`.
+
+
+# conversions among Union Types
+# =============================
+
+# Option
+# ------
+
+# we need to overwrite convert, because in the case that no conversion is possible, we currently get the super uninformative error
+# ERROR: could not compute non-nothing type
+# Stacktrace:
+#  [1] nonnothingtype_checked(::Type) at ./some.jl:29
+#  [2] convert(::Type{Union{Nothing, Some{T}} where T}, ::Int64) at ./some.jl:34
+#  [3] top-level scope at none:0
+# importantly, we should only add clauses for Type{Option} and not Type{<:Option} to not interfere with existing code
+Base.convert(::Type{Option}, x::Option) = x
+
+Base.convert(::Type{Option{T}}, x::Identity) where T = Identity(Base.convert(T, x))
+Base.convert(::Type{Option{T}}, x::Identity{T}) where T = x  # nothing to convert
+Base.convert(::Type{Option{T}}, x::Nothing) where T = x  # nothing to convert
+Base.convert(::Type{Option}, x::Nothing) = x  # nothing to convert
+Base.convert(::Type{Option}, x::Identity) = x  # nothing to convert
+
+
+# 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::Identity{R}) where {L, R} = x  # nothing to convert
+Base.convert(::Type{Either{L, R}}, x::Const) where {L, R} = Const(Base.convert(L, x.value))
+Base.convert(::Type{Either{L, R}}, x::Const{L}) where {L, R} = x  # nothing to convert
+
+Base.convert(::Type{Either{<:Any, R}}, x::Identity) where {R} = Identity(Base.convert(R, x.value))
+Base.convert(::Type{Either{<:Any, R}}, x::Identity{R}) where {R} = x  # nothing to convert
+Base.convert(::Type{Either{L, <:Any}}, x::Const) where {L} = Const(Base.convert(L, x.value))
+Base.convert(::Type{Either{L, <:Any}}, x::Const{L}) where {L} = x  # nothing to convert
+
+
+# OptionEither
+# ------------
+
+Base.convert(::Type{OptionEither{L, R}}, x::Identity) where {L, R} = Identity(Base.convert(R, x.value))
+Base.convert(::Type{OptionEither{L, R}}, x::Identity{R}) where {L, R} = x  # nothing to convert
+Base.convert(::Type{OptionEither{L, R}}, x::Const) where {L, R} = Const(Base.convert(L, x.value))
+Base.convert(::Type{OptionEither{L, R}}, x::Const{L}) where {L, R} = x  # nothing to convert
+
+Base.convert(::Type{OptionEither{<:Any, R}}, x::Identity) where {R} = Identity(Base.convert(R, x.value))
+Base.convert(::Type{OptionEither{<:Any, R}}, x::Identity{R}) where {R} = x  # nothing to convert
+Base.convert(::Type{OptionEither{L, <:Any}}, x::Const) where {L} = Const(Base.convert(L, x.value))
+Base.convert(::Type{OptionEither{L, <:Any}}, x::Const{L}) where {L} = x  # nothing to convert
+
+Base.convert(::Type{OptionEither{L, R}}, x::Nothing) where {L, R} = x  # nothing to convert
+Base.convert(::Type{OptionEither}, x::Nothing) = x  # nothing to convert
+Base.convert(::Type{OptionEither}, x::Identity) = x  # nothing to convert

src/promote_type.jl

@@ -0,0 +1,87 @@
+# promote_type/promote_typejoin already works for Identity and Nothing (aka Options)
+# ==========================================================================
+
+# nothing todo, as `Nothing` is already super well supported for promote_type and promote_typejoin
+
+
+# promote_type/promote_typejoin should work with Identity and Const (aka Either)
+# ==========================================================================
+
+# promote_type only has to deal with concrete types, including Unions in our case
+
+# promote_type Const & Identity
+# -----------------------------
+
+Base.promote_rule(::Type{C}, ::Type{I}) where {C<:Const, I<:Identity} = Union{C, I}
+
+
+# promote_type Const & Either
+# -----------------------------
+
+Base.promote_rule(::Type{Const}, ::Type{Either{L, R}}) where {L, R} = Either{<:Any, R}
+Base.promote_rule(::Type{Const{L}}, ::Type{Either{L, R}}) where {L, R} = Either{L, R}
+Base.promote_rule(::Type{Const{L1}}, ::Type{Either{L2, R}}) where {L1, R, L2 <: L1} = Either{L1, R}
+Base.promote_rule(::Type{Const{L2}}, ::Type{Either{L1, R}}) where {L1, R, L2 <: L1} = Either{L1, R}
+
+Base.promote_rule(::Type{Const}, ::Type{Either{L, <:Any}}) where {L} = Either
+Base.promote_rule(::Type{Const{L}}, ::Type{Either{L, <:Any}}) where {L} = Either{L, <:Any}
+Base.promote_rule(::Type{Const{L1}}, ::Type{Either{L2, <:Any}}) where {L1, L2 <: L1} = Either{L1, <:Any}
+Base.promote_rule(::Type{Const{L2}}, ::Type{Either{L1, <:Any}}) where {L1, L2 <: L1} = Either{L1, <:Any}
+
+Base.promote_rule(::Type{Const}, ::Type{Either}) = Either
+
+
+# promote_type Identity & Either
+# -----------------------------
+
+Base.promote_rule(::Type{Identity}, ::Type{Either{L, R}}) where {L, R} = Either{L, <:Any}
+Base.promote_rule(::Type{Identity{R}}, ::Type{Either{L, R}}) where {L, R} = Either{L, R}
+Base.promote_rule(::Type{Identity{R1}}, ::Type{Either{L, R2}}) where {L, R1, R2 <: R1} = Either{L, R1}
+Base.promote_rule(::Type{Identity{R2}}, ::Type{Either{L, R1}}) where {L, R1, R2 <: R1} = Either{L, R1}
+
+Base.promote_rule(::Type{Identity}, ::Type{Either{<:Any, R}}) where {R} = Either
+Base.promote_rule(::Type{Identity{R}}, ::Type{Either{<:Any, R}}) where {R} = Either{<:Any, R}
+Base.promote_rule(::Type{Identity{R1}}, ::Type{Either{<:Any, R2}}) where {R1, R2 <: R1} = Either{<:Any, R1}
+Base.promote_rule(::Type{Identity{R2}}, ::Type{Either{<:Any, R1}}) where {R1, R2 <: R1} = Either{<:Any, R1}
+
+Base.promote_rule(::Type{Identity}, ::Type{Either}) = Either
+
+
+# promote_type Either & Either
+# -----------------------------
+
+# we need to be cautious here, as we cannot dispatch on Type{<:Either{<:Any, R}} or similar, because R might not be defined
+Base.promote_rule(::Type{Either{L, R}}, ::Type{Either{L, R}}) where {L, R} = Either{L, R}
+Base.promote_rule(::Type{Either{L1, R}}, ::Type{Either{L2, R}}) where {L1, R, L2 <: L1} = Either{L1, R}
+Base.promote_rule(::Type{Either{L, R1}}, ::Type{Either{L, R2}}) where {L, R1, R2 <: R1} = Either{L, R1}
+Base.promote_rule(::Type{Either{L1, R1}}, ::Type{Either{L2, R2}}) where {L1, R1, L2 <: L1, R2 <: R1} = Either{L1, R1}
+Base.promote_rule(::Type{Either{L2, R1}}, ::Type{Either{L1, R2}}) where {L1, R1, L2 <: L1, R2 <: R1} = Either{L1, R1}
+
+Base.promote_rule(::Type{Either{L, <:Any}}, ::Type{Either{L, <:Any}}) where {L} = Either{L, <:Any}
+Base.promote_rule(::Type{Either{L1, <:Any}}, ::Type{Either{L2, <:Any}}) where {L1, L2 <: L1} = Either{L1, <:Any}
+
+Base.promote_rule(::Type{Either{<:Any, R}}, ::Type{Either{<:Any, R}}) where {L, R} = Either{<:Any, R}
+Base.promote_rule(::Type{Either{<:Any, R1}}, ::Type{Either{<:Any, R2}}) where {L, R1, R2 <: R1} = Either{<:Any, R1}
+
+# NOTE we cannot use `Base.promote_rule(::Type{<:Either}, ::Type{<:Either}) = Either` as apparently this interferes
+# with more concrete implementations of promote_rule
+# promote_type seem to assume, that you really only define promote_rule for concrete types
+Base.promote_rule(::Type{Either}, ::Type{Either}) = Either
+
+
+# promote_typejoin
+# -----------------------------
+
+# We also support `promote_typejoin`, as the semantics between promote_typejoin and promote_type overlap
+# in our case of Unions (similar to how they are already defined for Nothing and Missing in Base).
+# In addition note that `promote_typejoin` has to be defined for both flipped and non-flipped versions.
+# We solve this by referring to the symmetric `promote_type` instead of the asymmtric `promote_rule`.
+Base.promote_typejoin(::Type{E1}, ::Type{E2}) where {E1<:OptionEither, E2<:OptionEither} = promote_type(E1, E2)
+# TODO typejoin should actually not combine Identity{AbstractString} and Identity{String} to Identity{AbstractString}
+# hence we really need to redefine everything alike to be safe.
+
+
+# promote_type/promote_typejoin should work with all three Identity, Nothing and Const (aka OptionEither)
+# ==========================================================================
+
+# nothing todo, as `Nothing` is already super well supported for promote_type and promote_typejoin

test/convert.jl

@@ -0,0 +1,17 @@
+using Test
+using DataTypesBasic
+
+@test convert(Vector, Identity("hello")) == ["hello"]
+@test convert(Vector, nothing) == []
+@test convert(Vector, Const(43)) == []
+@test convert(Vector, @ContextManager cont -> cont(2)) == [2]
+
+@test convert(Identity, nothing) == nothing
+@test convert(Identity, Const(:error)) == Const(:error)
+@test convert(Identity, @ContextManager cont -> cont(2)) == Identity(2)
+@test_throws MethodError convert(Identity, [1,2,3])
+
+@test run(convert(ContextManager, Identity(4))) == 4
+@test_throws MethodError convert(ContextManager, nothing)
+@test_throws MethodError convert(ContextManager, Const(:error))
+@test_throws MethodError convert(ContextManager, [1,2,3])