kind 2.2.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3bb8430c79ca97835ebdf6604e0c5afc4301f912db778e5f930fb9e699ae08c1
-  data.tar.gz: 0557c3df900513e5ec7d45fec79fdf7502f0cb06a8e1538ff935e0228ef11136
+  metadata.gz: a234e4c63dea23906a65da0718515bff19ac7934a3e919535596042cfd605bba
+  data.tar.gz: 5bcb0f1f669a0e87de070c5095cf8f769ddf97dde4b2169060fb21769ffbd623
 SHA512:
-  metadata.gz: 0ad03f0d27484914f45607d9e1fd7cfdaf8000d700e31f069b274b5f977f42a8736a3d03d0cba1f3d06679f0f5a05b56d7c3b4acfd2a90cce20e524de6f9154a
-  data.tar.gz: 6f8e54590261939a43a52895921d80fb693a0e16361d011f53a80f1d7269aaade1e8871ae44374586ec488c026a02fced9057fdfcb300c532bd3a018498e954a
+  metadata.gz: 232d87a65618b51c3ec8756ad9d08bce53a49d50368d4629c8e694050502dddf12cdecd878193e40e09c8fcc13139b1a35383eedaa36a1660f7cf71f7e4d9810
+  data.tar.gz: 4cef62a76d8981fa7409e0d598448b35b4bb01794084ad2ab264741cbf0a78e6b9142352369892e124f130750847078f90297e5d1eda955881ebea0f13e96ec7

data/.travis.yml

@@ -3,7 +3,10 @@ language: ruby
 
 sudo: false
 
-cache: bundler
+cache:
+  bundler: true
+  directories:
+    - /home/travis/.rvm/
 
 rvm:
   - 2.2.0

data/README.md

@@ -39,13 +39,14 @@ One of the goals of this project is to do simple type checking like `"some strin
   - [Kind.of.\<Type\>.or_undefined()](#kindoftypeor_undefined)
 - [Kind::Maybe](#kindmaybe)
     - [Replacing blocks by lambdas](#replacing-blocks-by-lambdas)
-  - [Kind::Maybe[] and Kind::Maybe#then method aliases](#kindmaybe-and-kindmaybethen-method-aliases)
+  - [Kind::Maybe[], Kind::Maybe.wrap() and Kind::Maybe#then method aliases](#kindmaybe-kindmaybewrap-and-kindmaybethen-method-aliases)
     - [Replacing blocks by lambdas](#replacing-blocks-by-lambdas-1)
   - [Kind::None() and Kind::Some()](#kindnone-and-kindsome)
   - [Kind.of.Maybe()](#kindofmaybe)
   - [Kind::Optional](#kindoptional)
     - [Replacing blocks by lambdas](#replacing-blocks-by-lambdas-2)
   - [Kind.of.\<Type\>.as_optional](#kindoftypeas_optional)
+  - [Kind::Maybe(<Type>)](#kindmaybetype)
   - [Kind::Maybe#try](#kindmaybetry)
 - [Kind::Empty](#kindempty)
 - [Similar Projects](#similar-projects)
@@ -717,7 +718,7 @@ end
   Kind::Maybe.new(nil).map(&Add).value_or(0) # 0
 ```
 
-### Kind::Maybe[] and Kind::Maybe#then method aliases
+### Kind::Maybe[], Kind::Maybe.wrap() and Kind::Maybe#then method aliases
 
 You can use `Kind::Maybe[]` (brackets) instead of the `.new` to transform values in a `Kind::Maybe`. Another alias is `.then` to the `.map` method.
 
@@ -731,6 +732,19 @@ result =
 puts result # 42
 ```
 
+You can also use `Kind::Maybe.wrap()` instead of the `.new` method.
+
+```ruby
+result =
+  Kind::Maybe
+    .wrap(5)
+    .then { |value| value * 5 }
+    .then { |value| value + 17 }
+    .value_or(0)
+
+puts result # 42
+```
+
 #### Replacing blocks by lambdas
 
 ```ruby
@@ -969,6 +983,46 @@ end
 
 [⬆️ Back to Top](#table-of-contents-)
 
+### Kind::Maybe(<Type>)
+
+There is an alternative to `Kind.of.\<Type\>.as_optional`, you can use `Kind::Optional(<Type>)` to create a maybe monad which will return None if the given input hasn't the expected type. e.g:
+
+```ruby
+result1 =
+  Kind::Maybe(Numeric)
+    .wrap(5)
+    .then { |value| value * 5 }
+    .value_or { 0 }
+
+puts result1 # 25
+
+# ---
+
+result2 =
+  Kind::Optional(Numeric)
+    .wrap('5')
+    .then { |value| value * 5 }
+    .value_or { 0 }
+
+puts result2 # 0
+```
+
+This typed maybe has the same methods of `Kind::Maybe` class. e.g:
+
+```ruby
+Kind::Maybe(Numeric)[5]
+Kind::Maybe(Numeric).new(5)
+Kind::Maybe(Numeric).wrap(5)
+
+# ---
+
+Kind::Optional(Numeric)[5]
+Kind::Optional(Numeric).new(5)
+Kind::Optional(Numeric).wrap(5)
+```
+
+[⬆️ Back to Top](#table-of-contents-)
+
 ### Kind::Maybe#try
 
 If you don't want to use a map to access the value, you could use the `#try` method to access it. So, if the value wasn't `nil` or `Kind::Undefined`, it will be returned.

data/lib/kind.rb

@@ -4,12 +4,12 @@ require 'kind/version'
 
 require 'kind/empty'
 require 'kind/undefined'
+require 'kind/checker'
 require 'kind/maybe'
 
 require 'kind/error'
 require 'kind/of'
 require 'kind/is'
-require 'kind/checker'
 require 'kind/types'
 
 module Kind
@@ -25,30 +25,12 @@ module Kind
     raise ArgumentError, WRONG_NUMBER_OF_ARGUMENTS
   end
 
-  MODULE_OR_CLASS = 'Module/Class'.freeze
-
-  private_constant :MODULE_OR_CLASS
-
-  private_class_method def self.__checkers__
-    @__checkers__ ||= {}
-  end
-
-  __checkers__
-
   def self.of(kind = Undefined, object = Undefined)
     return Of if Undefined == kind && Undefined == object
 
     return Kind::Of.(kind, object) if Undefined != object
 
-    __checkers__[kind] ||= begin
-      kind_name = kind.name
-
-      if Kind::Of.const_defined?(kind_name, false)
-        Kind::Of.const_get(kind_name)
-      else
-        Checker.new(Kind::Of.(Module, kind, MODULE_OR_CLASS))
-      end
-    end
+    Kind::Checker::Factory.create(kind)
   end
 
   def self.of?(kind, *args)
@@ -87,7 +69,7 @@ module Kind
     end
 
     const_set(:Class, ::Module.new do
-      extend Checkable
+      extend Checker::Protocol
 
       def self.__kind; ::Class; end
 
@@ -109,7 +91,7 @@ module Kind
     end
 
     const_set(:Module, ::Module.new do
-      extend Checkable
+      extend Checker::Protocol
 
       def self.__kind_undefined(value)
         __kind_error(Kind::Undefined) if Kind::Undefined == value
@@ -165,7 +147,7 @@ module Kind
     end
 
     const_set(:Boolean, ::Module.new do
-      extend Checkable
+      extend Checker::Protocol
 
       def self.__kind; [TrueClass, FalseClass].freeze; end
 
@@ -220,7 +202,7 @@ module Kind
     end
 
     const_set(:Lambda, ::Module.new do
-      extend Checkable
+      extend Checker::Protocol
 
       def self.__kind; ::Proc; end
 
@@ -268,7 +250,7 @@ module Kind
     end
 
     const_set(:Callable, ::Module.new do
-      extend Checkable
+      extend Checker::Protocol
 
       def self.__kind; Object; end
 

data/lib/kind/checker.rb

@@ -1,78 +1,10 @@
 # frozen_string_literal: true
 
+require 'kind/checker/factory'
+require 'kind/checker/protocol'
 module Kind
-  module Checkable
-    def class?(value)
-      Kind::Is.__call__(__kind, value)
-    end
-
-    def instance(value, options = Empty::HASH)
-      default = options[:or]
-
-      return Kind::Of.(__kind, value) if ::Kind::Maybe::Value.none?(default)
-
-      Kind::Undefined != value && instance?(value) ? value : Kind::Of.(__kind, default)
-    end
-
-    def [](value, options = options = Empty::HASH)
-      instance(value, options)
-    end
-
-    def to_proc
-      @to_proc ||=
-        -> checker { -> value { checker.instance(value) } }.call(self)
-    end
-
-    def __is_instance__(value)
-      value.kind_of?(__kind)
-    end
-
-    def is_instance_to_proc
-      @is_instance_to_proc ||=
-        -> checker { -> value { checker.__is_instance__(value) } }.call(self)
-    end
-
-    def instance?(*args)
-      return is_instance_to_proc if args.empty?
-
-      return args.all? { |object| __is_instance__(object) } if args.size > 1
-
-      arg = args[0]
-      Kind::Undefined == arg ? is_instance_to_proc : __is_instance__(arg)
-    end
-
-    def or_nil(value)
-      return value if instance?(value)
-    end
-
-    def or_undefined(value)
-      or_nil(value) || Kind::Undefined
-    end
-
-    def __as_maybe__(value)
-      Kind::Maybe.new(or_nil(value))
-    end
-
-    def as_maybe_to_proc
-      @as_maybe_to_proc ||=
-        -> checker { -> value { checker.__as_maybe__(value) } }.call(self)
-    end
-
-    def as_maybe(value = Kind::Undefined)
-      return __as_maybe__(value) if Kind::Undefined != value
-
-      as_maybe_to_proc
-    end
-
-    def as_optional(value = Kind::Undefined)
-      as_maybe(value)
-    end
-  end
-
-  private_constant :Checkable
-
   class Checker
-    include Checkable
+    include Protocol
 
     attr_reader :__kind
 

data/lib/kind/checker/factory.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module Kind
+  class Checker
+    class Factory
+      include Singleton
+
+      def self.create(kind)
+        instance.create(kind)
+      end
+
+      def initialize
+        @__checkers__ = {}
+      end
+
+      MODULE_OR_CLASS = 'Module/Class'.freeze
+
+      private_constant :MODULE_OR_CLASS
+
+      def create(kind)
+        @__checkers__[kind] ||= begin
+          kind_name = kind.name
+
+          if Kind::Of.const_defined?(kind_name, false)
+            Kind::Of.const_get(kind_name)
+          else
+            Kind::Checker.new(Kind::Of.(Module, kind, MODULE_OR_CLASS))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kind/checker/protocol.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Kind
+  class Checker
+    module Protocol
+      def class?(value)
+        Kind::Is.__call__(__kind, value)
+      end
+
+      def instance(value, options = Empty::HASH)
+        default = options[:or]
+
+        return Kind::Of.(__kind, value) if ::Kind::Maybe::Value.none?(default)
+
+        Kind::Undefined != value && instance?(value) ? value : Kind::Of.(__kind, default)
+      end
+
+      def [](value, options = options = Empty::HASH)
+        instance(value, options)
+      end
+
+      def to_proc
+        @to_proc ||=
+          -> checker { -> value { checker.instance(value) } }.call(self)
+      end
+
+      def __is_instance__(value)
+        value.kind_of?(__kind)
+      end
+
+      def is_instance_to_proc
+        @is_instance_to_proc ||=
+          -> checker { -> value { checker.__is_instance__(value) } }.call(self)
+      end
+
+      def instance?(*args)
+        return is_instance_to_proc if args.empty?
+
+        return args.all? { |object| __is_instance__(object) } if args.size > 1
+
+        arg = args[0]
+        Kind::Undefined == arg ? is_instance_to_proc : __is_instance__(arg)
+      end
+
+      def or_nil(value)
+        return value if instance?(value)
+      end
+
+      def or_undefined(value)
+        or_nil(value) || Kind::Undefined
+      end
+
+      def __as_maybe__(value)
+        Kind::Maybe.new(or_nil(value))
+      end
+
+      def as_maybe_to_proc
+        @as_maybe_to_proc ||=
+          -> checker { -> value { checker.__as_maybe__(value) } }.call(self)
+      end
+
+      def as_maybe(value = Kind::Undefined)
+        return __as_maybe__(value) if Kind::Undefined != value
+
+        as_maybe_to_proc
+      end
+
+      def as_optional(value = Kind::Undefined)
+        as_maybe(value)
+      end
+    end
+  end
+end

data/lib/kind/maybe.rb

@@ -2,6 +2,19 @@
 
 module Kind
   module Maybe
+    class Typed
+      def initialize(kind)
+        @kind_checker = Kind::Checker::Factory.create(kind)
+      end
+
+      def wrap(value)
+        @kind_checker.as_maybe(value)
+      end
+
+      alias_method :new, :wrap
+      alias_method :[], :wrap
+    end
+
     module Value
       def self.none?(value)
         value.nil? || Undefined == value
@@ -102,7 +115,11 @@ module Kind
       result_type.new(value)
     end
 
-    def self.[](value);
+    def self.[](value)
+      new(value)
+    end
+
+    def self.wrap(value)
       new(value)
     end
 
@@ -132,4 +149,12 @@ module Kind
   def self.Some(value)
     Maybe.some(value)
   end
+
+  def self.Maybe(kind)
+    Maybe::Typed.new(kind)
+  end
+
+  def self.Optional(kind)
+    Maybe::Typed.new(kind)
+  end
 end

data/lib/kind/types.rb

@@ -98,7 +98,7 @@ module Kind
           kind_name = params[:kind_name]
           params[:kind_name_to_check] ||= kind_name
 
-          kind_checker = ::Module.new { extend Checkable }
+          kind_checker = ::Module.new { extend Checker::Protocol }
           kind_checker.module_eval("def self.__kind; #{params[:kind_name_to_check]}; end")
 
           kind_of_mod.instance_eval(KIND_OF % params)

data/lib/kind/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kind
-  VERSION = '2.2.0'
+  VERSION = '2.3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kind
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-23 00:00:00.000000000 Z
+date: 2020-06-25 00:00:00.000000000 Z
 dependencies: []
 description: A simple type system (at runtime) for Ruby - free of dependencies.
 email:
@@ -32,6 +32,8 @@ files:
 - lib/kind/active_model/kind_validator.rb
 - lib/kind/active_model/validation.rb
 - lib/kind/checker.rb
+- lib/kind/checker/factory.rb
+- lib/kind/checker/protocol.rb
 - lib/kind/empty.rb
 - lib/kind/error.rb
 - lib/kind/is.rb