class Dry::Types::Nominal

def self.[](primitive)
  if primitive == ::Array
    Types::Array
  elsif primitive == ::Hash
    Types::Hash
  else
    self
  end
end

def call_safe(input, &) = input

def call_unsafe(input) = input

def coerce(input, &)
  if primitive?(input)
    input
  elsif block_given?
    yield
  else
    raise CoercionError, "#{input.inspect} must be an instance of #{primitive}"
  end
end

def constrained? = false

def default? = false

def failure(input, error)
  raise ::ArgumentError, "error must be a CoercionError" unless error.is_a?(CoercionError)
  Result::Failure.new(input, error)
end

def initialize(primitive, **options)
  super
  @primitive = primitive
  freeze
end

def lax = self

def name = primitive.name

def optional? = false

def primitive?(value) = value.is_a?(primitive)

def success(input) = Result::Success.new(input)

def to_ast(meta: true)
  [:nominal, [primitive, meta ? self.meta : EMPTY_HASH]]
end

def to_proc = ALWAYS

def try(input, &) = success(input)

def try_coerce(input)
  result = success(input)
  coerce(input) do
    result = failure(
      input,
      CoercionError.new("#{input.inspect} must be an instance of #{primitive}")
    )
  end
  if block_given?
    yield(result)
  else
    result
  end
end