class T::Types::Intersection

Takes a list of types. Validates that an object matches all of the types.

def build_type 

def build_type
  types
  nil
end

def initialize(types) 

def initialize(types)
  @inner_types = types
end

def name

overrides Base 
def name
  "T.all(#{types.map(&:name).compact.sort.join(', ')})"
end

def recursively_valid?(obj)

overrides Base 
def recursively_valid?(obj)
  types.all? {|type| type.recursively_valid?(obj)}
end

def subtype_of_single?(other)

overrides Base 
def subtype_of_single?(other)
"This should never be reached if you're going through `subtype_of?` (and you should be)"

def types 

def types
  @types ||= @inner_types.flat_map do |type|
    type = T::Utils.resolve_alias(type)
    if type.is_a?(Intersection)
      # Simplify nested intersections (mostly so `name` returns a nicer value)
      type.types
    else
      T::Utils.coerce(type)
    end
  end.uniq
end

def valid?(obj)

overrides Base 
def valid?(obj)
  types.all? {|type| type.valid?(obj)}
end