switched to use Const(nothing) instead of nothing for better consistency and to avoid type-piracy

Author: Stephan Sahm

Project.toml

@@ -22,6 +22,7 @@ julia = "1.3"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+Suppressor = "fd094767-a336-5f1f-9728-57cf17d0bbfb"
 
 [targets]
-test = ["Test"]
+test = ["Test", "Suppressor"]

src/Const.jl

@@ -1,3 +1,9 @@
+"""
+    Const("anything")
+
+DataType which behaves constant among `map`, `foreach` and the like. Just like an empty container,
+however with additional information about which kind of empty.
+"""
 struct Const{T}
   value::T
 end
@@ -9,9 +15,16 @@ function Base.show(io::IO, x::Const)
   print(io, "Const($(repr(x.value)))")
 end
 
-isconst(::Const) = true
-isconst(other) = false
+"""
+    isconst(Const(3)) -> true
+    isconst("anythingelse") -> false
+
+returns true only if given an instance of  [`DataTypesBasic.Const`](@ref)
+"""
+Base.isconst(::Const) = true
+Base.isconst(other) = false
 
+Base.length(::Const) = 0
 
 # const just does nothing, i.e. leaves everything constant
 Base.iterate(c::Const) = nothing

src/DataTypesBasic.jl

@@ -33,24 +33,21 @@ higher code-reuse and datatype-reuse.
 """
 module DataTypesBasic
 
-export Const, Identity,
-  Option, issomething, iftrue, iffalse, getOption, # isnothing, Nothing, Some comes from Base
-  Either, either, @either, isleft, isright, getleft, getright, getleftOption, getrightOption, flip_left_right,
-  OptionEither,
+export Identity, isidentity, Const,
+  Option, isoption, iftrue, iffalse, getOption, # isnothing, Nothing, Some comes from Base
+  Either, either, @either, iseither, isleft, isright, getleft, getright, getleftOption, getrightOption, flip_left_right,
   Try, Thrown, @Try, @TryCatch, issuccess, isexception, MultipleExceptions,
   ContextManager, @ContextManager
 
 using Compat
 
 # type definitions
-include("Nothing.jl")
-include("Const.jl")
 include("Identity.jl")
+include("Const.jl")
 include("Option.jl")
 include("Try.jl")
 include("Either.jl")
 include("ContextManager.jl")
-include("OptionEither.jl")
 
 # interoperability between types
 include("promote_type.jl")

src/Either.jl

@@ -39,20 +39,24 @@ end
 flip_left_right(x::Const) = Identity(x.value)
 flip_left_right(x::Identity) = Const(x.value)
 
-isleft(e::Const) = true
-isleft(e::Identity) = false
+iseither(::Const) = true
+iseither(::Identity) = true
+iseither(other) = false
 
-isright(e::Const) = false
-isright(e::Identity) = true
+isleft(::Const) = true
+isleft(::Identity) = false
+
+isright(::Const) = false
+isright(::Identity) = true
 
 getleft(e::Const) = e.value
 # getleft(e::Identity) = nothing  # throw an error if getleft is called on Identity
 
 # getright(e::Const) = nothing  # throw an error if getright is called on Const
 getright(e::Identity) = e.value
 
-getleftOption(e::Const{L}) where {L} = Identity{L}(e.value)
-getleftOption(e::Identity) = nothing
+getleftOption(e::Const) = Option(e.value)
+getleftOption(e::Identity) = Option()
 
-getrightOption(e::Const) = nothing
-getrightOption(e::Identity{R}) where {R} = e
+getrightOption(e::Const) = Option()
+getrightOption(e::Identity) = e

src/Identity.jl

@@ -11,6 +11,7 @@ end
 isidentity(::Identity) = true
 isidentity(other) = false
 
+Base.length(::Identity) = 1
 
 Base.get(a::Identity) = a.value
 Base.eltype(::Type{<:Identity{T}}) where T = T

src/Nothing.jl

@@ -1,30 +1,34 @@
 # 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}}
+const Option{T} = Union{Const{Nothing}, Identity{T}}
 
-Option{T}(a::Nothing) where T = nothing
+Option{T}(::Const{Nothing}) where T = Const(nothing)
+Option{T}(::Nothing) where T = Const(nothing)
 Option{T}(a::T) where T = Identity{T}(a)
-Option(a::Nothing) = nothing
+Option(::Const{Nothing}) = Const(nothing)
+Option(::Nothing) = Const(nothing)
 Option(a::T) where T = Identity{T}(a)
-Option{T}() where T = nothing
-Option() = nothing
+Option{T}() where T = Const(nothing)
+Option() = Const(nothing)
 
 
 function iftrue(func::Function, b::Bool)
-  b ? Identity(func()) : nothing
+  b ? Identity(func()) : Const(nothing)
 end
 function iftrue(b::Bool, t)
-  b ? Identity(t) : nothing
+  b ? Identity(t) : Const(nothing)
 end
 function iffalse(func::Function, b::Bool)
-  !b ? Identity(func()) : nothing
+  !b ? Identity(func()) : Const(nothing)
 end
 function iffalse(b::Bool, t)
-  !b ? Identity(t) : nothing
+  !b ? Identity(t) : Const(nothing)
 end
 
-issomething(m::Nothing) = false
-issomething(m::Identity) = true
+isoption(::Const{Nothing}) = true
+isoption(::Identity) = true
+isoption(other) = false
+
 
 Base.eltype(::Type{Option{T}}) where {T} = T
 Base.eltype(::Type{Option}) = Any

src/Option.jl

@@ -13,38 +13,29 @@ 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
+# Const are just passed through when asked to convert to identity
+# this is intended special behaviour in order for Identity + Const to work together as Option/Either
+Base.convert(::Type{Identity}, x::Const) = x
 # ContextManager is executed
-Base.convert(::Type{<:Identity}, x::ContextManager) = Identity(x(identity))
+Base.convert(::Type{<:Identity}, x::ContextManager) = Identity(run(x))
 
 
 # ContextManager
 # --------------
 
 Base.convert(::Type{<:ContextManager}, x::Identity) = @ContextManager cont -> cont(x.value)
 
-# Note that we do not support convert from Nothing/Const to ContextManager.
+# Note that we do not support convert from 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.
+# however, unlike Identity, we cannot simply pass-through 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.
 
@@ -69,8 +60,8 @@ 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{T}}, x::Const{Nothing}) where T = x  # nothing to convert
+Base.convert(::Type{Option}, x::Const{Nothing}) = x  # nothing to convert
 Base.convert(::Type{Option}, x::Identity) = x  # nothing to convert
 
 
@@ -86,21 +77,3 @@ Base.convert(::Type{Either{<:Any, R}}, x::Identity) where {R} = Identity(Base.co
 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