Iterating over types in Union

screw_dog · March 5, 2024, 2:58am

Is there a way (that doesn’t involve reaching into private details of Base/Core) to iterate over the types in a Union? In my case I know that it’ll only ever be a small union of concrete types, if that helps.

I’m writing a library to do REST API interaction and I have a Dict holding information on each endpoint. This includes a return type (Julia type) for that endpoint. The server returns JSON which is parsed into a Dict and then converted into the expected return type.

Except that exactly one of 200 endpoints can return two different types of data. So I have the return type as Union{A, B} and want to convert the returned Dict into either A or B, as appropriate.

Is it possible to write code something like this?

for type in return_types
    can_convert_to(type, returned_data) && return type(returned_data)
end

Dan · March 5, 2024, 3:19am

julia> Base.uniontypes(Union{Int,Float64})
2-element Vector{Any}:
 Float64
 Int64

good enough? It does go into Base, but the function name doesn’t start with an _ which is a little better.

ndortega · March 5, 2024, 5:20am

I’d like to piggyback off of Dan’s answer - that’s exactly what I’d recommend as well. In my own package I’ve taken the same approach to parse & convert path parameters so I could pass them directly to a request handler.

Here’s the function with that union iteration:

github.com

OxygenFramework/Oxygen.jl/blob/v1.5.1/src/utilities/misc.jl#L120


      
          end
          
          function parseparam(type::Type{T}, rawvalue::String) where {T}
              return JSON3.read(HTTP.unescapeuri(rawvalue), T)
          end
          
          """
          Iterate over the union type and parse the value with the first type that 
          doesn't throw an erorr
          """
          function parseparam(type::Union, rawvalue::String)
              value::String = HTTP.unescapeuri(rawvalue)
              result = value 
              for current_type in Base.uniontypes(type)
                  try 
                      result = parseparam(current_type, value)
                      break 
                  catch 
                      continue
                  end
              end

Here’s an example of it in action:

github.com

OxygenFramework/Oxygen.jl/blob/v1.5.1/src/core.jl#L533


      
          if numfields <= 1
              handle = function (req)
                  func()
              end
          # case 2.) This route has path params, so we need to parse parameters and pass them to the request handler
          elseif hasPathParams && numfields > 2
              handle = function(req::HTTP.Request)
                  # get all path parameters
                  params = HTTP.getparams(req)
                  # convert params to their designated type (if applicable)
                  pathParams = [parseparam(func_map[name], params[name]) for name in func_param_names]   
                  # pass all parameters to handler in the correct order 
                  func(req, pathParams...)
              end
          # case 3.) This function should only get passed the request object
          else 
              handle = function (req) 
                  func(req)
              end
          end

nsajko · March 5, 2024, 8:02am

github.com/JuliaLang/julia

[FR] provide a public API for accessing/mapping over `Union` components

opened 05:44PM - 05 Feb 24 UTC

nsajko

types and dispatch feature

Useful functionality like `Base.typesplit` or `Base.promote_union` may be implem…ented by recursively mapping over the components of a `Union` object. I wonder if it would make sense to provide a public API so users could do that themselves. I guess either of these would be nice: 1. document and support the `a` and `b` fields of a `Union`, or 2. provide some higher level API similar to `mapreduce`, that would take a type instead of a collection, interpreting union components as collection elements

screw_dog · March 5, 2024, 1:07pm

I feel heartened that you are using this in a package like Oxygen. Not ideal to be using undocumented functions but it’s probably the best option for me.