module Kind

# File lib/kind/objects/modules/core/array.rb, line 16
def self.Array?(*values)
  KIND.of?(::Array, values)
end

# File lib/kind/objects/modules/custom/boolean.rb, line 16
def self.Boolean?(*values)
  KIND.of?(Boolean, values)
end

# File lib/kind/objects/modules/custom/callable.rb, line 16
def self.Callable?(*values)
  KIND.of?(Callable, values)
end

# File lib/kind/objects/modules/core/class.rb, line 10
def self.Class?(*values)
  KIND.of?(::Class, values)
end

# File lib/kind/objects/modules/core/comparable.rb, line 10
def self.Comparable?(*values)
  KIND.of?(::Comparable, values)
end

# File lib/kind/objects/modules/core/enumerable.rb, line 10
def self.Enumerable?(*values)
  KIND.of?(::Enumerable, values)
end

# File lib/kind/objects/modules/core/enumerator.rb, line 10
def self.Enumerator?(*values)
  KIND.of?(::Enumerator, values)
end

# File lib/kind/objects/modules/core/file.rb, line 10
def self.File?(*values)
  KIND.of?(::File, values)
end

# File lib/kind/objects/modules/core/float.rb, line 10
def self.Float?(*values)
  KIND.of?(::Float, values)
end

# File lib/kind/objects/modules/core/hash.rb, line 16
def self.Hash?(*values)
  KIND.of?(::Hash, values)
end

# File lib/kind/objects/modules/core/io.rb, line 10
def self.IO?(*values)
  KIND.of?(::IO, values)
end

# File lib/kind/objects/modules/core/integer.rb, line 10
def self.Integer?(*values)
  KIND.of?(::Integer, values)
end

# File lib/kind/objects/modules/custom/lambda.rb, line 16
def self.Lambda?(*values)
  KIND.of?(Lambda, values)
end

# File lib/kind/maybe.rb, line 56
def self.Maybe(kind)
  warn '[DEPRECATION] Kind::Maybe() is deprecated; use Kind::Maybe::Typed[] instead. ' \
      'It will be removed on next major release.'

  Maybe::Typed[kind]
end

# File lib/kind/objects/modules/core/method.rb, line 10
def self.Method?(*values)
  KIND.of?(::Method, values)
end

# File lib/kind/objects/modules/core/module.rb, line 14
def self.Module?(*values)
  KIND.of?(::Kind::Module, values)
end

# File lib/kind/maybe.rb, line 48
def self.None
  Maybe::NONE_INSTANCE
end

# File lib/kind/objects/modules/core/numeric.rb, line 10
def self.Numeric?(*values)
  KIND.of?(::Numeric, values)
end

# File lib/kind/objects/object.rb, line 50
def self.Of(*args)
  warn '[DEPRECATION] Kind::Of() is deprecated; use Kind[] instead. ' \
      'It will be removed on next major release.'

  self[*args]
end

# File lib/kind/objects/modules/stdlib/open_struct.rb, line 12
def self.OpenStruct?(*values)
  KIND.of?(::OpenStruct, values)
end

# File lib/kind/maybe.rb, line 63
def self.Optional(kind)
  warn '[DEPRECATION] Kind::Optional() is deprecated; use Kind::Optional::Typed[] instead. ' \
      'It will be removed on next major release.'

  Optional::Typed[kind]
end

# File lib/kind/objects/modules/core/proc.rb, line 10
def self.Proc?(*values)
  KIND.of?(::Proc, values)
end

# File lib/kind/objects/modules/core/queue.rb, line 11
def self.Queue?(*values)
  KIND.of?(::Queue, values)
end

# File lib/kind/objects/modules/core/range.rb, line 10
def self.Range?(*values)
  KIND.of?(::Range, values)
end

# File lib/kind/objects/modules/core/regexp.rb, line 10
def self.Regexp?(*values)
  KIND.of?(::Regexp, values)
end

# File lib/kind/objects/modules/stdlib/set.rb, line 16
def self.Set?(*values)
  KIND.of?(::Set, values)
end

# File lib/kind/maybe.rb, line 52
def self.Some(value)
  Maybe::Some[value]
end

# File lib/kind/objects/modules/core/string.rb, line 16
def self.String?(*values)
  KIND.of?(::String, values)
end

# File lib/kind/objects/modules/core/struct.rb, line 10
def self.Struct?(*values)
  KIND.of?(::Struct, values)
end

# File lib/kind/objects/modules/core/symbol.rb, line 10
def self.Symbol?(*values)
  KIND.of?(::Symbol, values)
end

# File lib/kind/objects/modules/core/time.rb, line 10
def self.Time?(*values)
  KIND.of?(::Time, values)
end

# File lib/kind/objects/object.rb, line 45
def self.[](kind, opt = Empty::HASH)
  Object::Instance.new(kind, opt)
end

# File lib/kind/basic.rb, line 92
def assert_hash!(hash, **kargs)
  STRICT.assert_hash!(hash, kargs)
end

# File lib/kind/basic.rb, line 84
def in!(list, value)
  STRICT.in!(list, value)
end

# File lib/kind/basic.rb, line 88
def include!(value, list)
  STRICT.in!(list, value)
end

# File lib/kind/basic.rb, line 18
def is(*args)
  warn '[DEPRECATION] Kind.is will behave like Kind.is! in the next major release; ' \
      'use Kind.is? instead.'

  is?(*args)
end

# File lib/kind/basic.rb, line 25
def is!(kind, arg, label: nil)
  return arg if KIND.is?(kind, arg)

  label_text = label ? "#{label}: " : ''

  raise Kind::Error.new("#{label_text}#{arg} expected to be a #{kind}")
end

# File lib/kind/basic.rb, line 14
def is?(kind, arg)
  KIND.is?(kind, arg)
end

# File lib/kind/basic.rb, line 51
def of(kind, value, label: nil)
  STRICT.object_is_a(kind, value, label)
end

# File lib/kind/basic.rb, line 33
def of?(kind, *args)
  KIND.of?(kind, args)
end

# File lib/kind/basic.rb, line 57
def of_class(value)
  STRICT.class!(value)
end

# File lib/kind/basic.rb, line 37
def of_class?(value)
  OF.class?(value)
end

# File lib/kind/basic.rb, line 61
def of_module(value)
  STRICT.module!(value)
end

# File lib/kind/basic.rb, line 41
def of_module?(value)
  OF.module?(value)
end

# File lib/kind/basic.rb, line 65
def of_module_or_class(value)
  STRICT.module_or_class(value)
end

# File lib/kind/basic.rb, line 80
def or_nil(kind, value)
  return value if kind === value
end

# File lib/kind/basic.rb, line 69
def respond_to(value, *method_names)
  method_names.each { |method_name| KIND.respond_to!(method_name, value) }

  value
end

# File lib/kind/basic.rb, line 45
def respond_to?(value, *method_names)
  return super(value) if method_names.empty?

  KIND.interface?(method_names, value)
end

# File lib/kind/basic.rb, line 76
def value(kind, value, default:)
  KIND.value(kind, value, of(kind, default))
end