Module: T::Types::Union::Private::Pool

Defined in:
lib/types/types/union.rb

Class Method Summary collapse

Class Method Details

.union_of_types(type_a, type_b, types = EMPTY_ARRAY) ⇒ Object

Try to use ‘to_nilable` on a type to get memoization, or failing that try to at least use SimplePairUnion to get faster init and typechecking.

We aren’t guaranteed to detect a simple ‘T.nilable(<Module>)` type here in cases where there are duplicate types, nested unions, etc.

That’s ok, because returning is SimplePairUnion an optimization which isn’t necessary for correctness.

Parameters:



102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
 
# File 'lib/types/types/union.rb', line 102

def self.union_of_types(type_a, type_b, types=EMPTY_ARRAY)
  if !types.empty?
    # Slow path
    return Union.new([type_a, type_b] + types)
  elsif !type_a.is_a?(T::Types::Simple) || !type_b.is_a?(T::Types::Simple)
    # Slow path
    return Union.new([type_a, type_b])
  end

  begin
    if type_b == T::Utils::Nilable::NIL_TYPE
      type_a.to_nilable
    elsif type_a == T::Utils::Nilable::NIL_TYPE
      type_b.to_nilable
    else
      T::Private::Types::SimplePairUnion.new(type_a, type_b)
    end
  rescue T::Private::Types::SimplePairUnion::DuplicateType
    # Slow path
    #
    # This shouldn't normally be possible due to static checks,
    # but we can get here if we're constructing a type dynamically.
    #
    # Relying on the duplicate check in the constructor has the
    # advantage that we avoid it when we hit the memoized case
    # of `to_nilable`.
    type_a
  end
end