fix some convert corner cases (#22)

* fix some convert corner cases

* fix earlier julia versions

* fixes

* accomodate julia 1.1

Author: MasonProtter

Project.toml

@@ -1,7 +1,7 @@
 name = "SumTypes"
 uuid = "8e1ec7a9-0e02-4297-b0fe-6433085c89f2"
 authors = ["MasonProtter <[email protected]>"]
-version = "0.4.0"
+version = "0.4.1"
 
 [deps]
 MacroTools = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09"

src/SumTypes.jl

@@ -45,17 +45,28 @@ show_sumtype(io::IO, m::MIME, x) = show_sumtype(io, x)
 function show_sumtype(io::IO, x::T) where {T}
     tag = get_tag(x)
     sym = flag_to_symbol(T, tag)
-    T_stripped = if length(T.parameters) == 2
-        String(T.name.name)
-    else
-        string(String(T.name.name), "{", join(repr.(T.parameters[1:end-2]), ", "), "}")
-    end 
+    T_stripped = T_string_stripped(T)
     if unwrap(x) isa Variant{(), Tuple{}}
         print(io, String(sym), "::", T_stripped)
     else
         print(io, String(sym), '(', join((repr(data) for data ∈ unwrap(x)), ", "), ")::", T_stripped)
     end
 end
+function T_string_stripped(::Type{_T}) where {_T}
+    @assert is_sumtype(_T)
+    T = full_type(_T)
+    T_stripped = if length(T.parameters) == 2
+        String(T.name.name)
+    else
+        string(String(T.name.name), "{", join(repr.(T.parameters[1:end-2]), ", "), "}")
+    end 
+end
+
+
+struct Converter{T, U} end
+(::Converter{T, U})(x) where {T, U} = convert(T, U(x))
+Base.show(io::IO, x::Converter{T, U}) where {T, U} = print(io, "$(T_string_stripped(T))'.$U")
+
 
 include("compute_storage.jl")
 include("sum_type.jl") # @sum_type defined here

src/sum_type.jl

@@ -137,7 +137,7 @@ end
 function generate_constructor_exprs(T_name, T_params, T_params_constrained, T_nameparam, constructors)
     out = Expr(:toplevel)
     converts = []
-    foreach(constructors) do nt
+    for nt ∈ constructors
         name = nt.name
         gname = nt.gname 
         params = nt.params
@@ -190,16 +190,27 @@ function generate_constructor_exprs(T_name, T_params, T_params_constrained, T_na
         enumerate_constructors = collect(enumerate(constructors))
 
         if true
+            @gensym N M _tag _T x
+
+            if_nest_conv = mapfoldr(((cond, data), old) -> Expr(:if, cond, data, old),  enumerate_constructors, init=:(error("invalid tag"))) do (i, nt)
+                :($_tag == $(i-1) ), :($make($T_init, $unwrap(x, $(nt.store_type)) , $_tag))
+            end
+            
             push!(converts, T_uninit => quote
-                      $Base.convert(::Type{$T_init}, x::$T_uninit) where {$(T_params...)} =
-                          $make($T_init, $unwrap(x), $getfield(x, $(QuoteNode(tag)) ))
-                      $T_init(x::$T_uninit) where {$(T_params...)} = $convert($T_init, x)
+                      $Base.convert(::$Type{$_T}, $x::$_T) where {$_T <: $T_name} = $x
+                      $Base.convert(::$Type{<:$T_init}, x::$T_uninit) where {$(T_params...)} = let $_tag = $get_tag(x)
+                          $if_nest_conv
+                      end 
+                      (::$Type{<:$T_init})(x::$T_uninit) where {$(T_params...)} = $convert($T_init, x)
+                      $Base.convert(::$Type{<:$T_init}, x::$T_uninit{$N, $M}) where {$(T_params...), $N, $M} = let $_tag = $get_tag(x)
+                          $if_nest_conv
+                      end 
+                      (::$Type{<:$_T})(x::$T_name) where {$_T <: $T_name} = $convert($_T, x)
                   end)
         end
     end
     unique!(x -> x[1], converts)
     append!(out.args, map(x -> x[2], converts))
-
     out
 end
 
@@ -228,11 +239,12 @@ function generate_sum_struct_expr(T, T_name, T_params, T_params_constrained, T_p
     end
 
     only_define_with_params = if !isempty(T_params)
+        @gensym x
         quote
             $SumTypes.constructors(::Type{<:$T_nameparam}) where {$(T_params...)} =
                 $NamedTuple{$tags($T_name)}($(Expr(:tuple, (nt.store_type for nt ∈ constructors)...)))
             $Base.adjoint(::Type{<:$T_nameparam}) where {$(T_params...)} =
-                $NamedTuple{$tags($T_name)}($(Expr(:tuple, (nt.value ? :($T_nameparam($(nt.gname))) : nt.gouter_type for nt ∈ constructors)...)))
+                $NamedTuple{$tags($T_name)}($(Expr(:tuple, (nt.value ? :($T_nameparam($(nt.gname))) : :($Converter{$T_nameparam, $(nt.gouter_type)}()) for nt ∈ constructors)...)))
             $SumTypes.variants_Tuple(::Type{<:$T_nameparam}) where {$(T_params...)} =
                 $Tuple{$((nt.store_type for nt ∈ constructors)...)}
             $SumTypes.full_type(::Type{$T_name}) = $full_type($T_name{$(T_param_bounds...)}, $variants_Tuple($T_nameparam{$(T_param_bounds...)}))
@@ -269,6 +281,7 @@ function generate_sum_struct_expr(T, T_name, T_params, T_params_constrained, T_p
             $NamedTuple{$tags($T_name)}($(Expr(:tuple, (nt.gname  for nt ∈ constructors)...)))
 
         $SumTypes.full_type(::Type{$T_nameparam}) where {$(T_params...)} = $full_type($T_nameparam, $variants_Tuple($T_nameparam))
+        $SumTypes.full_type(::Type{$T_nameparam{$N, $M}}) where {$(T_params...), $N, $M} = $T_nameparam{$N, $M}
 
         $Base.show(io::IO, x::$T_name) = $show_sumtype(io, x)
         $Base.show(io::IO, m::MIME"text/plain", x::$T_name) = $show_sumtype(io, m, x)

test/runtests.jl

@@ -82,6 +82,12 @@ end
         @test x != z
     end
     @test SumTypes.get_tag_sym(Left([1])) == :Left
+
+    @test convert(full_type(Either{Int, Int}), Left(1))  == Left(1)
+    @test convert(full_type(Either{Int, Int}), Left(1)) !== Left(1)
+    @test convert(full_type(Either{Int, Int}), Left(1)) === Either{Int, Int}'.Left(1)
+    @test Either{Int, Int, 15, 0}(Left(1)) isa Either{Int, Int, 15, 0}
+    @test Either{Int, Int, 15, 0}(Either{Int, Int}(Left(1))) isa Either{Int, Int, 15, 0}
 
     @test_throws MethodError Left{Int}("hi")
     @test_throws MethodError Right{String}(1)
@@ -254,5 +260,6 @@ end
         @test repr(Right(3)) == "R(3)"
     end
     @test repr(apple) == "apple::Fruit"
+    @test repr(Either{Int, Int}'.Left) ∈ ("Either{Int64, Int64}'.Left{Int64}", "Either{Int64,Int64}'.Left{Int64}")
 end