Unexpected error raised from Sum type about dry-types HOT 7 OPEN

class Union < Dry::Types::Union
  possible_types(
    Dry::Types::String,
    Dry::Types::Integer,
    # and etc
  )
end

class A < Dry::Struct
  attribute :value, Types::String
end

class B < Dry::Struct
  attribute :value, Types::String
end

Data = A | B

hash = { value: 'a' }
p Data[hash].class # => It is always going to be the first left type in a sum.

class Data < Dry::Types::Union
  possible_types A, B

  class << self
    def resolve(data)
      case data
      in { value: 'a' }
        A
      in { value: 'b' }
        B
      end
    end
  end
end

require 'bundler/inline'

gemfile do
  source 'https://rubygems.org'

  gem 'dry-types'
  gem 'dry-struct'
end

module Types
  include Dry.Types()
end

module Dry
  module Types
    class Union
      include Builder
      include Meta

      attr_reader :types

      Error = Class.new(StandardError)


      def initialize(*types)
        raise ArgumentError, 'a union should consist of at least 2 types' if types.size < 2

        @types = types
        @meta = {}
      end

      def try(input)
        type = resolve(input)
        return Dry::Types::Result::Success.new(input) if type

        error = Error.new("A value does not match any type of union")
        failure =  Dry::Types::Result::Failure.new(input, error)
        yield failure if block_given?

        failure
      end

      def [](input)
        call_unsafe(input)
      end

      def call_unsafe(input)
        type = resolve(input)
        raise Error, "value #{input} does not match any type of union" if type.nil?

        type.call_unsafe(input)
      end

      def constrained?
        false
      end

      private

      def resolve(input)
        find_type(input)
      end

      def find_type(input)
        types.find { |type| type.valid?(input) }
      end

      class << self
        def of(*types, &block)
          new(*types).tap do |instance|
            instance.instance_exec(&block) if block_given?
          end
        end
      end
    end
  end
end

class A < Dry::Struct
  attribute :value, Types::String
end

class B < Dry::Struct
  attribute :value, Types::String
end

Data = Dry::Types::Union.of(A, B) do
  def resolve(input)
    case input
    in { value: 'a' } if A.valid?(input)
      A
    in { value: 'b' } if B.valid?(input)
      B
    else
      find_type(input)
    end
  end
end

p Data[{ value: 'a' }].class
p Data[{ value: 'b' }].class
p Data[{ }] # => Error