kind 1.7.0 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 273fcdcef40d8b61e552bb440f93a7b83adfd29621e1809201a66117babf9974
-  data.tar.gz: 84dac931b67ccc4ee895a8c2a4c3326ccfe0faf0540df09ba9fbcbfbe5034edc
+  metadata.gz: a0a88ddbce52eca41466b1c600f745b3c212e7833bbb178cabd86514e1011601
+  data.tar.gz: f96ab5843a3596a19863389dacda8e5865eff611163112f5092a3387ea6898a4
 SHA512:
-  metadata.gz: b3d702df70066307c7dac3058c41dab688de46c606d57455194d77570823d051dab5fd43b5c87c870dee58b9cef41a9e93a7d9d4639fe39489cc4b0e2d93d4bf
-  data.tar.gz: 4c02cd4e43a0407167f4284c6972feed925380a0d71a8c5dedcb474a24f458954175a929dac9d5b4509520cfea663e45692dba67269712bc6e8d83e53b80a8aa
+  metadata.gz: 06af14f778ea084ae699a0c00e67d6808cbdace68a838cff42782fb7150f51e3524eba060784fd0cb540d08c2ecaa4b8135f75813e7d4223b87c9d1326831c05
+  data.tar.gz: 16e1e11bce9f67237a3f306b526f1b1f6564fe10eafcd22c2c90f2f18fa22077155a4372a9149d24dac02d266895e36c256a147a625f3592e8686bca974ab94b

data/README.md

@@ -12,7 +12,7 @@ Basic type system for Ruby.
 
 As a creator of Ruby gems, I have a common need that I have to handle in many of my projects: type checking of method arguments.
 
-One of the goals of this project is to do simple type checking like `"some string".is_a?(String)`, but using a bunch of basic abstractions. So, after reading this README and realizing that you need something more robust, I recommend you check out the [dry-types gem](https://dry-rb.org/gems/dry-types).
+One of the goals of this project is to do simple type checking like `"some string".is_a?(String)`, but, exposing useful abstractions to do it.
 
 ## Table of Contents <!-- omit in toc -->
 - [Required Ruby version](#required-ruby-version)
@@ -35,7 +35,9 @@ One of the goals of this project is to do simple type checking like `"some strin
   - [Kind::Maybe#try](#kindmaybetry)
   - [Kind.of.Maybe()](#kindofmaybe)
   - [Kind::Optional](#kindoptional)
+  - [Kind.of.<Type>.as_optional](#kindoftypeas_optional)
 - [Kind::Empty](#kindempty)
+- [Similar Projects](#similar-projects)
 - [Development](#development)
 - [Contributing](#contributing)
 - [License](#license)
@@ -131,6 +133,21 @@ Kind.of.Boolean.instance?(true)  # true
 Kind.of.Boolean.instance?(false) # true
 ```
 
+**Note:** When `.instance?` is called without an argument, it will return a lambda which will perform the kind verification.
+
+```ruby
+collection = [
+  {number: 1},
+  'number 0',
+  {number: 2},
+  [0],
+]
+
+collection
+  .select(&Kind.of.Hash.instance?)
+  .reduce(0) { |total, item| total + item.fetch(:number, 0) } # 3
+```
+
 Also, there are aliases to perform the strict type verification. e.g:
 
 ```ruby
@@ -205,6 +222,15 @@ kind_of_user.instance?(User) # true
 kind_of_user.class?(Hash)  # false
 kind_of_user.class?(User)  # true
 
+# ------------------------------------ #
+# Using methods which returns a lambda #
+# ------------------------------------ #
+collection = [User.new, User.new, 0, {} nil, User.new]
+
+collection.select(&Kind.of(User).instance?).size == 3 # true
+
+collection.map(&Kind.of(User).as_optional).select(&:some?).size == 3 # true
+
 # Creating type checkers dynamically is cheap
 # because a singleton object is created to be available for use.
 
@@ -343,7 +369,7 @@ The list of types (classes and modules) available to use with `Kind.of.*` or `Ki
 - `Kind.of.Callable()`: verifies if the given value `respond_to?(:call)` or if it's a class/module and if its `public_instance_methods.include?(:call)`.
 - `Kind.of.Maybe()` or its alias `Kind.of.Optional()`
 
-PS: Remember, you can use the `Kind.is.*` method to check if some given value is a class/module with all type checkers above.
+**Note:** Remember, you can use the `Kind.is.*` method to check if some given value is a class/module with all type checkers above.
 
 [⬆️ Back to Top](#table-of-contents-)
 
@@ -434,6 +460,10 @@ object = 'foo'
 
 p Kind::Maybe[object].try(:upcase) # "FOO"
 
+p Kind::Maybe[{}].try(:fetch, :number, 0) # 0
+
+p Kind::Maybe[{number: 1}].try(:fetch, :number) # 1
+
 p Kind::Maybe[object].try { |value| value.upcase } # "FOO"
 
 #############
@@ -514,7 +544,119 @@ result2 =
 puts result2 # 35
 ```
 
-PS: The `Kind.of.Optional` is available to check if some value is a `Kind::Optional`.
+**Note:** The `Kind.of.Optional` is available to check if some value is a `Kind::Optional`.
+
+[⬆️ Back to Top](#table-of-contents-)
+
+### Kind.of.<Type>.as_optional
+
+It is very common the need to avoid some computing when a method receives a wrong input.
+In these scenarios, you could check the given input type as optional and avoid unexpected behavior. e.g:
+
+```ruby
+def person_name(params)
+  Kind::Of::Hash.as_optional(params)
+                .map { |data| data if data.values_at(:first_name, :last_name).compact.size == 2 }
+                .map { |data| "#{data[:first_name]} #{data[:last_name]}" }
+                .value_or { 'John Doe' }
+end
+
+person_name('')   # "John Doe"
+person_name(nil)  # "John Doe"
+
+person_name(first_name: 'Rodrigo')   # "John Doe"
+person_name(last_name: 'Serradura')  # "John Doe"
+
+person_name(first_name: 'Rodrigo', last_name: 'Serradura') # "Rodrigo Serradura"
+
+#
+# See below the previous implementation without using an optional.
+#
+def person_name(params)
+  if params.is_a?(Hash) && params.values_at(:first_name, :last_name).compact.size == 2
+    "#{params[:first_name]} #{params[:last_name]}"
+  else
+    'John Doe'
+  end
+end
+```
+
+> Note: You could use the `.as_optional` method (or it alias `as_maybe`) with any [type checker](https://github.com/serradura/kind/blob/b177fed9cc2b3347d63963a2a2fd99f989c51a9a/README.md#type-checkers).
+
+Let's see another example using a collection and how the method `.as_optional` works when it receives no argument.
+
+```ruby
+collection = [
+  {number: 1},
+  'number 0',
+  {number: 2},
+  [0],
+]
+
+collection
+  .select(&Kind.of.Hash.as_optional)
+  .reduce(0) do |total, item|
+    item.try { |data| data[:number] + total } || total
+  end
+
+collection
+  .map(&Kind.of.Hash.as_optional).select(&:some?)
+  .reduce(0) { |total, item| total + item.value[:number] }
+
+# Note: All the examples above return 3 as the sum of all hashes with numbers.
+```
+
+To finish follows an example of how to use optionals to handle arguments in coupled methods.
+
+```ruby
+module PersonIntroduction
+  extend self
+
+  def call(params)
+    optional_params = Kind::Of::Hash.as_optional(params)
+
+    "Hi my name is #{full_name(optional_params)}, I'm #{age(optional_params)} years old."
+  end
+
+  private
+
+    def full_name(optional)
+      optional.map { |data| "#{data[:first_name]} #{data[:last_name]}" }
+              .value_or { 'John Doe' }
+    end
+
+    def age(optional)
+      optional.map { |data| data[:age] }.value_or(0)
+    end
+end
+
+#
+# See below the previous implementation without using an optional.
+#
+module PersonIntroduction
+  extend self
+
+  def call(params)
+    "Hi my name is #{full_name(params)}, I'm #{age(params)}"
+  end
+
+  private
+
+    def full_name(params)
+      case params
+      when Hash then "#{params[:first_name]} #{params[:last_name]}"
+      else 'John Doe'
+      end
+    end
+
+    def age(params)
+      case params
+      when Hash then params.fetch(:age, 0)
+      else 0
+      end
+    end
+end
+```
 
 [⬆️ Back to Top](#table-of-contents-)
 
@@ -565,6 +707,10 @@ Follows the list of constants, if the alias is available to be created:
 
 [⬆️ Back to Top](#table-of-contents-)
 
+## Similar Projects
+
+- [dry-types](https://dry-rb.org/gems/dry-types)
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
@@ -575,7 +721,6 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/serradura/kind. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/serradura/kind/blob/master/CODE_OF_CONDUCT.md).
 
-
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/kind.rb

@@ -88,7 +88,7 @@ module Kind
 
       def self.class?(value); Kind::Is.Class(value); end
 
-      def self.instance?(value); class?(value); end
+      def self.__is_instance__(value); class?(value); end
     end)
 
     # -- Module
@@ -128,13 +128,13 @@ module Kind
         if ::Kind::Maybe::Value.none?(default)
           __kind_undefined(value) { __kind_of(value) }
         else
-          return value if instance?(value)
+          return value if value != Kind::Undefined && instance?(value)
 
           __kind_undefined(default) { __kind_of(default) }
         end
       end
 
-      def self.instance?(value); class?(value); end
+      def self.__is_instance__(value); class?(value); end
     end)
 
     # -- Boolean
@@ -164,7 +164,7 @@ module Kind
         if ::Kind::Maybe::Value.none?(default)
           __kind_undefined(value) { Kind::Of::Boolean(value) }
         else
-          return value if instance?(value)
+          return value if value != Kind::Undefined && instance?(value)
 
           __kind_undefined(default) { Kind::Of::Boolean(default) }
         end
@@ -178,7 +178,7 @@ module Kind
         end
       end
 
-      def self.instance?(value);
+      def self.__is_instance__(value);
         value.is_a?(TrueClass) || value.is_a?(FalseClass)
       end
 
@@ -213,7 +213,7 @@ module Kind
         if ::Kind::Maybe::Value.none?(default)
           __kind_undefined(value) { Kind::Of::Lambda(value) }
         else
-          return value if instance?(value)
+          return value if value != Kind::Undefined && instance?(value)
 
           __kind_undefined(default) { Kind::Of::Lambda(default) }
         end
@@ -227,7 +227,7 @@ module Kind
         end
       end
 
-      def self.instance?(value)
+      def self.__is_instance__(value)
         value.is_a?(__kind) && value.lambda?
       end
     end)
@@ -261,7 +261,7 @@ module Kind
         if ::Kind::Maybe::Value.none?(default)
           __kind_undefined(value) { Kind::Of::Callable(value) }
         else
-          return value if instance?(value)
+          return value if value != Kind::Undefined && instance?(value)
 
           __kind_undefined(default) { Kind::Of::Callable(default) }
         end
@@ -275,7 +275,7 @@ module Kind
         end
       end
 
-      def self.instance?(value);
+      def self.__is_instance__(value);
         value.respond_to?(:call)
       end
     end)

data/lib/kind/checker.rb

@@ -11,17 +11,28 @@ module Kind
 
       return Kind::Of.(__kind, value) if ::Kind::Maybe::Value.none?(default)
 
-      instance?(value) ? value : Kind::Of.(__kind, default)
+      value != Kind::Undefined && instance?(value) ? value : Kind::Of.(__kind, default)
     end
 
     def [](value, options = options = Empty::HASH)
       instance(value, options)
     end
 
-    def instance?(value)
+    def instance?(value = Kind::Undefined)
+      return __is_instance__(value) if value != Kind::Undefined
+
+      is_instance_to_proc
+    end
+
+    def __is_instance__(value)
       value.is_a?(__kind)
     end
 
+    def is_instance_to_proc
+      @is_instance_to_proc ||=
+        -> checker { -> value { checker.__is_instance__(value) } }.call(self)
+    end
+
     def or_nil(value)
       return value if instance?(value)
     end
@@ -29,6 +40,25 @@ module Kind
     def or_undefined(value)
       or_nil(value) || Kind::Undefined
     end
+
+    def as_maybe(value = Kind::Undefined)
+      return __as_maybe__(value) if value != Kind::Undefined
+
+      as_maybe_to_proc
+    end
+
+    def as_optional(value = Kind::Undefined)
+      as_maybe(value)
+    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
   end
 
   private_constant :Checkable

data/lib/kind/maybe.rb

@@ -87,10 +87,10 @@ module Kind
 
       alias_method :then, :map
 
-      def try(method_name = Undefined, &block)
+      def try(method_name = Undefined, *args, &block)
         fn = method_name == Undefined ? block : Kind.of.Symbol(method_name).to_proc
 
-        result = fn.call(value)
+        result = args.empty? ? fn.call(value) : fn.call(*args.unshift(value))
 
         return result if Maybe::Value.some?(result)
       end

data/lib/kind/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kind
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.8.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-03 00:00:00.000000000 Z
+date: 2020-05-04 00:00:00.000000000 Z
 dependencies: []
 description: Basic type system for Ruby (free of dependencies).
 email: