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, &block)
  raise NotImplementedError
end

def call_unsafe(input)
  raise NotImplementedError
end

def constrained?
  false
end

def default?
  false
end

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, right].map(&:name).join(" #{self.class.operator} ")
end

def optional?
  false
end

def primitive?(value)
  raise NotImplementedError
end

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) }
end

def try(input)
  raise NotImplementedError
end