a few fixes, and added Nothing

Author: S. Sahm

src/DataTypesBasic.jl

@@ -37,6 +37,7 @@ export Const, Identity,
 
 using IsDef
 
+include("Nothing.jl")
 include("Const.jl")
 include("Identity.jl")
 include("Option.jl")

src/Either.jl

@@ -30,9 +30,9 @@ Base.typejoin(::Type{<:Either}, ::Type{<:Either}) = 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
+Base.eltype(::Type{Either{L, R}}) where {L, R} = R
+Base.eltype(::Type{Either{<:Any, R}}) where {R} = R
+Base.eltype(::Type{Either}) = Any
 
 
 # Helpers for Either

src/Nothing.jl

@@ -0,0 +1,8 @@
+Base.iterate(::Nothing) = nothing
+Base.foreach(f, ::Nothing) = nothing
+Base.map(f, ::Nothing) = nothing
+Iterators.flatten(::Nothing) = nothing
+
+
+# we need this for safety, if someone overwrites typejoin for Unions with Const
+Base.typejoin(::Type{Nothing}, ::Type{Nothing}) = Nothing

src/Option.jl

@@ -31,7 +31,6 @@ Base.hash(a::Some) = hash(a.value)
 #  [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) = throw(MethodError(Base.convert, (Option, x)))
 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
 
@@ -51,6 +50,5 @@ end
 issomething(m::Nothing) = false
 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.eltype(::Type{Option{T}}) where {T} = T
+Base.eltype(::Type{Option}) = Any

src/Try.jl

@@ -81,35 +81,6 @@ Base.convert(::Type{Try{T}}, x::Identity{S}) where {S, T} = Identity(Base.conver
 promote_rule(::Type{Try{T}}, ::Type{Try{S}}) where {T, S<:T} = Try{T}
 
 
-
-# typejoin Thrown & Thrown
-# Base.typejoin(::Type{Thrown{E}}, ::Type{Thrown{E}}) where E = Thrown{E}
-# Base.typejoin(::Type{<:Thrown}, ::Type{<:Thrown}) = Thrown
-# # typejoin Identity & Identity
-# Base.typejoin(::Type{Identity{T}}, ::Type{Identity{T}}) where T = Identity{E}
-# Base.typejoin(::Type{<:Identity}, ::Type{<:Identity}) = Identity
-# # typejoin Thrown & Identity
-# Base.typejoin(::Type{Thrown{E}}, ::Type{Identity{T}}) where {T, E} = Try{T, E}
-# Base.typejoin(::Type{Identity{T}}, ::Type{Thrown{E}}) where {T, E} = Try{T, E}
-# # typejoin Thrown & Try
-# Base.typejoin(::Type{Thrown{E}}, ::Type{<:Try{T, E}}) where {T, E} = Try{T, E}
-# Base.typejoin(::Type{<:Try{T, E}}, ::Type{Thrown{E}}) where {T, E} = Try{T, E}
-# Base.typejoin(::Type{<:Thrown}, ::Type{<:Try{T}}) where T = Try{T}
-# Base.typejoin(::Type{<:Try{T}}, ::Type{<:Thrown}) where T = Try{T}
-# # typejoin Identity & Try
-# Base.typejoin(::Type{Identity{T}}, ::Type{<:Try{T, E}}) where {T, E} = Try{T, E}
-# Base.typejoin(::Type{<:Try{T, E}}, ::Type{Identity{T}}) where {T, E} = Try{T, E}
-# Base.typejoin(::Type{<:Identity}, ::Type{<:Try{<:Any, E}}) where E = Try{<:Any, E}
-# Base.typejoin(::Type{<:Try{<:Any, E}}, ::Type{<:Identity}) where E = Try{<:Any, E}
-# # typejoin Try & Try
-# Base.typejoin(::Type{<:Try{T, E}}, ::Type{<:Try{T, E}}) where {T, E} = Try{T, E}
-# Base.typejoin(::Type{<:Try{T}}, ::Type{<:Try{T}}) where {T} = Try{T}
-# Base.typejoin(::Type{<:Try{<:Any, E}}, ::Type{<:Try{<:Any, E}}) where {E} = Try{<:Any, E}
-# Base.typejoin(::Type{<:Try}, ::Type{<:Try}) = Try
-
-
-
-
 # we use a macro instead of dispatching on Try(f::Function) as this interferes e.g. with mapn
 # (in mapn anonymous functions are passed through, which should not get executed automatically)
 macro Try(expr)
@@ -145,7 +116,5 @@ issuccess(::Const{<:Exception}) = false
 isexception(::Identity) = false
 isexception(::Const{<:Exception}) = true
 
-Base.eltype(::Type{<:Try{T}}) where T = T
-Base.eltype(::Type{<:Try}) = Any
-# somehow the normal Const eltype got broken
-Base.eltype(::Type{<:Const{<:Exception}}) = Any
+Base.eltype(::Type{Try{T}}) where T = T
+Base.eltype(::Type{Try}) = Any