kind 3.0.0 → 5.0.0

data/lib/kind/maybe/typed.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Kind
+  module Maybe
+    class Typed
+      include Wrappable
+
+      def initialize(kind)
+        @kind = kind
+      end
+
+      def new(arg)
+        value = Result::Value.(arg)
+
+        @kind === value ? Maybe.some(value) : Maybe.none
+      end
+
+      alias_method :[], :new
+
+      private
+
+        def __call_before_expose_the_arg_in_a_block(arg)
+          value = Result::Value.(arg)
+
+          @kind === value ? value : Maybe.none
+        end
+    end
+  end
+end

data/lib/kind/maybe/wrappable.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Kind
+  module Maybe
+    module Wrappable
+      def wrap(arg = UNDEFINED)
+        if block_given?
+          begin
+            return new(yield) if UNDEFINED == arg
+
+            input = __call_before_expose_the_arg_in_a_block(arg)
+
+            input.kind_of?(Maybe::None) ? input : new(yield(input))
+          rescue StandardError => exception
+            Maybe.__none__(exception)
+          end
+        else
+          return new(arg) if UNDEFINED != arg
+
+          raise ArgumentError, 'wrong number of arguments (given 0, expected 1)'
+        end
+      end
+
+      private
+
+        def __call_before_expose_the_arg_in_a_block(input)
+          input
+        end
+    end
+
+    private_constant :Wrappable
+  end
+end

data/lib/kind/presence.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Kind
+  module Presence
+    extend self
+
+    def call(object)
+      return object.blank? ? nil : object if object.respond_to?(:blank?)
+
+      return object if TrueClass === object
+
+      return blank_str?(object) ? nil : object if String === object
+
+      return object.empty? ? nil : object if object.respond_to?(:empty?)
+
+      return object if object
+    end
+
+    def to_proc
+      -> object { call(object) }
+    end
+
+    private
+
+      BLANK_RE = /\A[[:space:]]*\z/
+
+      def blank_str?(object)
+        object.empty? || BLANK_RE === object
+      end
+
+      private_constant :BLANK_RE
+  end
+end

data/lib/kind/try.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Kind
+  module Try
+    extend self
+
+    def call(*args)
+      object = args.shift
+
+      call!(object, args.shift, args)
+    end
+
+    def self.[](*args)
+      method_name = args.shift
+
+      ->(object) { call!(object, method_name, args) }
+    end
+
+    def call!(object, method_name, args) # :nodoc
+      return if KIND.null?(object)
+
+      resolve(object, method_name, args)
+    end
+
+    private
+
+      def resolve(object, method_name, args = Empty::ARRAY)
+        return unless object.respond_to?(method_name)
+        return object.public_send(method_name) if args.empty?
+
+        object.public_send(method_name, *args)
+      end
+  end
+end

data/lib/kind/type_checker.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Kind
+  module TypeChecker
+    def name
+      kind.name
+    end
+
+    def ===(value)
+      kind === value
+    end
+
+    def [](value)
+      return value if self === value
+
+      KIND.error!(name, value)
+    end
+
+    def or_nil(value)
+      return value if self === value
+    end
+
+    def or_undefined(value)
+      or_nil(value) || Undefined
+    end
+
+    def or(fallback, value = UNDEFINED)
+      return __or_func.(fallback) if UNDEFINED === value
+
+      self === value ? value : fallback
+    end
+
+    def value?(value = UNDEFINED)
+      return self === value if UNDEFINED != value
+
+      @__is_value ||= ->(ck) { ->(value) { ck === value } }.(self)
+    end
+
+    def value(arg, default:)
+      KIND.value(self, arg, self[default])
+    end
+
+    def or_null(value) # :nodoc:
+      KIND.null?(value) ? value : self[value]
+    end
+
+    def maybe(value = UNDEFINED, &block)
+      return __maybe[value] if UNDEFINED != value && !block
+      return __maybe.wrap(&block) if UNDEFINED == value && block
+      return __maybe.wrap(value, &block) if UNDEFINED != value && block
+
+      __maybe
+    end
+
+    alias optional maybe
+
+    private
+
+      def __maybe
+        @__maybe ||= Maybe::Typed.new(self)
+      end
+
+      def __or_func
+        @__or_func ||= ->(tc, fb, value) { tc === value ? value : tc.or_null(fb) }.curry[self]
+      end
+  end
+
+  class TypeChecker::Object # :nodoc: all
+    include TypeChecker
+
+    ResolveKindName = ->(kind, opt) do
+      name = Try.(opt, :[], :name)
+      name || Try.(kind, :name)
+    end
+
+    attr_reader :kind, :name
+
+    def initialize(kind, opt)
+      name = ResolveKindName.(kind, opt)
+
+      @name = KIND.of!(::String, name)
+      @kind = KIND.respond_to!(:===, kind)
+    end
+
+    private_constant :ResolveKindName
+  end
+end

data/lib/kind/type_checkers.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'kind/type_checkers/core/array'
+require 'kind/type_checkers/core/class'
+require 'kind/type_checkers/core/comparable'
+require 'kind/type_checkers/core/enumerable'
+require 'kind/type_checkers/core/enumerator'
+require 'kind/type_checkers/core/file'
+require 'kind/type_checkers/core/float'
+require 'kind/type_checkers/core/hash'
+require 'kind/type_checkers/core/integer'
+require 'kind/type_checkers/core/io'
+require 'kind/type_checkers/core/module'
+require 'kind/type_checkers/core/method'
+require 'kind/type_checkers/core/numeric'
+require 'kind/type_checkers/core/proc'
+require 'kind/type_checkers/core/queue'
+require 'kind/type_checkers/core/range'
+require 'kind/type_checkers/core/regexp'
+require 'kind/type_checkers/core/string'
+require 'kind/type_checkers/core/struct'
+require 'kind/type_checkers/core/symbol'
+require 'kind/type_checkers/core/time'
+
+require 'kind/type_checkers/stdlib/open_struct'
+require 'kind/type_checkers/stdlib/set'
+
+require 'kind/type_checkers/custom/boolean'
+require 'kind/type_checkers/custom/callable'
+require 'kind/type_checkers/custom/lambda'

data/lib/kind/type_checkers/core/array.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Kind
+  module Array
+    extend self, TypeChecker
+
+    def kind; ::Array; end
+
+    def value_or_empty(arg)
+      KIND.value(self, arg, Empty::ARRAY)
+    end
+  end
+
+  def self.Array?(*values)
+    KIND.of?(::Array, values)
+  end
+end

data/lib/kind/type_checkers/core/class.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Kind
+  module Class
+    extend self, TypeChecker
+
+    def kind; ::Class; end
+  end
+
+  def self.Class?(*values)
+    KIND.of?(::Class, values)
+  end
+end

data/lib/kind/type_checkers/core/comparable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Kind
+  module Comparable
+    extend self, TypeChecker
+
+    def kind; ::Comparable; end
+  end
+
+  def self.Comparable?(*values)
+    KIND.of?(::Comparable, values)
+  end
+end

data/lib/kind/type_checkers/core/enumerable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Kind
+  module Enumerable
+    extend self, TypeChecker
+
+    def kind; ::Enumerable; end
+  end
+
+  def self.Enumerable?(*values)
+    KIND.of?(::Enumerable, values)
+  end
+end

data/lib/kind/type_checkers/core/enumerator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Kind
+  module Enumerator
+    extend self, TypeChecker
+
+    def kind; ::Enumerator; end
+  end
+
+  def self.Enumerator?(*values)
+    KIND.of?(::Enumerator, values)
+  end
+end

data/lib/kind/type_checkers/core/file.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Kind
+  module File
+    extend self, TypeChecker
+
+    def kind; ::File; end
+  end
+
+  def self.File?(*values)
+    KIND.of?(::File, values)
+  end
+end

data/lib/kind/type_checkers/core/float.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Kind
+  module Float
+    extend self, TypeChecker
+
+    def kind; ::Float; end
+  end
+
+  def self.Float?(*values)
+    KIND.of?(::Float, values)
+  end
+end

data/lib/kind/type_checkers/core/hash.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Kind
+  module Hash
+    extend self, TypeChecker
+
+    def kind; ::Hash; end
+
+    def value_or_empty(arg)
+      KIND.value(self, arg, Empty::HASH)
+    end
+  end
+
+  def self.Hash?(*values)
+    KIND.of?(::Hash, values)
+  end
+end

data/lib/kind/type_checkers/core/integer.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Kind
+  module Integer
+    extend self, TypeChecker
+
+    def kind; ::Integer; end
+  end
+
+  def self.Integer?(*values)
+    KIND.of?(::Integer, values)
+  end
+end

data/lib/kind/type_checkers/core/io.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Kind
+  module IO
+    extend self, TypeChecker
+
+    def kind; ::IO; end
+  end
+
+  def self.IO?(*values)
+    KIND.of?(::IO, values)
+  end
+end

data/lib/kind/type_checkers/core/method.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Kind
+  module Method
+    extend self, TypeChecker
+
+    def kind; ::Method; end
+  end
+
+  def self.Method?(*values)
+    KIND.of?(::Method, values)
+  end
+end

data/lib/kind/type_checkers/core/module.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Kind
+  module Module
+    extend self, TypeChecker
+
+    def kind; ::Module; end
+
+    def ===(value)
+      Kind.of_module?(value)
+    end
+  end
+
+  def self.Module?(*values)
+    KIND.of?(::Kind::Module, values)
+  end
+end