Allow custom types to get narrow Union type with map (like `promote_typejoin` for `Missing`/`Nothing`)

[oxinabox]

Consider this code:

julia> bar(::Nothing) = missing
bar (generic function with 1 method)

julia> bar(x) = x;

julia> xs = [1, 2, nothing, 4]
4-element Vector{Union{Nothing, Int64}}:
 1
 2
  nothing
 4

julia> ys = map(bar, xs)
4-element Vector{Union{Missing, Int64}}:
 1
 2
  missing
 4

We can see we get a nice array of small unions in the output.

But if I make my own similar singleton type, then the output is a Array{Any}.

julia> struct Null end

julia> foo(::Nothing) = Null();

julia> foo(x) = x;

julia> xs = [1, 2, nothing, 4]
4-element Vector{Union{Nothing, Int64}}:
 1
 2
  nothing
 4

julia> ys = map(foo, xs)
4-element Vector{Any}:
 1
 2
  Null()
 4

Is there something extra i need to do, or is the compiler cheating for Missing and Nothing?

[KristofferC]

Is there something extra i need to do, or is the compiler cheating for Missing and Nothing?

There's a lot of cheating with those two (but not really by the compiler):

julia/base/missing.jl

Lines 41 to 70 in a80f903

	function nonmissingtype_checked(T::Type)
	R = nonmissingtype(T)
	R >: T && error("could not compute non-missing type")
	return R
	end
	promote_rule(T::Type{Missing}, S::Type) = Union{S, Missing}
	promote_rule(T::Type{Union{Nothing, Missing}}, S::Type) = Union{S, Nothing, Missing}
	function promote_rule(T::Type{>:Union{Nothing, Missing}}, S::Type)
	R = nonnothingtype(T)
	R >: T && return Any
	T = R
	R = nonmissingtype(T)
	R >: T && return Any
	T = R
	R = promote_type(T, S)
	return Union{R, Nothing, Missing}
	end
	function promote_rule(T::Type{>:Missing}, S::Type)
	R = nonmissingtype(T)
	R >: T && return Any
	T = R
	R = promote_type(T, S)
	return Union{R, Missing}
	end
	convert(::Type{T}, x::T) where {T>:Missing} = x
	convert(::Type{T}, x::T) where {T>:Union{Missing, Nothing}} = x
	convert(::Type{T}, x) where {T>:Missing} = convert(nonmissingtype_checked(T), x)
	convert(::Type{T}, x) where {T>:Union{Missing, Nothing}} = convert(nonmissingtype_checked(nonnothingtype_checked(T)), x)

Here is another example:

julia> struct Foo
          x::Ref{Union{Nothing, Float64}}
       end

julia> Foo(1)
Foo(Base.RefValue{Union{Nothing, Float64}}(1.0))

julia> struct MyMissing end

julia> struct Bar
          x::Ref{Union{MyMissing, Float64}}
       end

julia> Bar(1)
ERROR: MethodError: Cannot `convert` an object of type 
  Int64 to an object of type 
  Union{MyMissing, Float64}
Closest candidates are:
  convert(::Type{T}, ::T) where T at essentials.jl:171

[oxinabox]

Nice.
Just adding
Base.promote_rule(T::Type{Null}, S::Type) = Union{S, Null}
doesn't seem to make it work.
It would be good to workout exactly what is needed and document it.

[KristofferC]

https://github.com/KristofferC/LazilyInitializedFields.jl/pull/1/files#diff-0abed87289859febd0e9c73389d5bb7fae46aa675acf8f1a468de7a3b9dcf0a1R95-R124 got me most of the way there. I still think there was something that was not perfect but don't really recall it.

[nalimilan]

Being extensible wasn't the priority when we implemented this, but maybe it could be made easier and documented. There's also promote_typejoin which isn't part of the public API.

[vtjnash]

This is based on the explicit promote_typejoin rule, and not inferred by the compiler. It's also not extensible, sorry.

[oxinabox]

Doesn't this issue remain open to document how to use promote_typejoin for this?

Or to make it extensible?

[oxinabox]

Doesn't this issue remain open to document how to use promote_typejoin for this?

Or to make it extensible?

bump

[vtjnash]

There's no "cheating" or uncertainty: it's the explicit implementation, and can't be extended, so there's not much to document?

[oxinabox]

can't be extended

but just because it can't be extended now doesn't mean that it is impossible for making it extendable in the future.
Which would resolve this issue.
Not saying it is easy, but we have done non-easy enhancements to the language before.
Feature requests that are are hard are not normally closed, they are normally left open and untouched.
Feature requests that make no-sense, or that are a bad idea are normally closed.
Maybe this makes no sense or is a bad idea, but i don't understand why it is.