module Dry::Types::Composition

def self.included(base)
  composition_name = Inflector.demodulize(base)
  ast_type = Inflector.underscore(composition_name).to_sym
  base.define_singleton_method(:ast_type) { ast_type }
  base.define_singleton_method(:composition_name) { composition_name }
  base.const_set("Constrained", ::Class.new(base) { include Constrained })
end

def call_safe(input, &) = raise ::NotImplementedError

def call_unsafe(input) = raise ::NotImplementedError

def constrained? = false

def default? = false

def failure(input, _error = nil)
  result = try(input)
  if result.failure?
    result
  else
    raise ::ArgumentError, "Invalid failure value '#{input}' for #{inspect}"
  end
end

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

def name = "#{left.name} #{self.class.operator} #{right.name}"

def optional? = false

def primitive?(value) = raise ::NotImplementedError

def success(input)
  result = try(input)
  if result.success?
    result
  else
    raise ::ArgumentError, "Invalid success value '#{input}' for #{inspect}"
  end
end

def to_ast(meta: true)
  [self.class.ast_type,
   [left.to_ast(meta: meta), right.to_ast(meta: meta), meta ? self.meta : EMPTY_HASH]]
end

def to_proc = proc { |value| self.(value) }

def try(input, &) = raise ::NotImplementedError