eqq 0.0.2 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd093a7aa8c034327d463c56bfe120a8ecc48b52649ba7900491f05cc130cc38
-  data.tar.gz: 13f7ca2f2f40d9be41abd4408f5486b892f345347eb07eeb3f4d936c47cc92ab
+  metadata.gz: becfb749a93e73ea402265899e57d3deea45bf0eb457a29a66eafa03965b1572
+  data.tar.gz: 3f6578bd2f0b3334369834ff1f344b4b033318172586a9324496027a057507a0
 SHA512:
-  metadata.gz: 2e510f5313e0f890bf3c8277a413f937b0a26e2ba58e501591288556783bc5fffc944c23a1216ddf95308a111b06c6ac82557526d9f7de49ef9dbe7806f93bb6
-  data.tar.gz: 719905cbd2f71a388e13ca0427b7db49115513ce11395a436d8ef9fc43397c9c77cc408135862147bbfc3bac3fb36615332752f56ab28e4136bc74b8db3f97dd
+  metadata.gz: 3d76a45da1f1e181d77b6f9cbfc6f80d88af6abed0782b1da92f6562934bf551c2f55e5691be7108d0acf0521562a042bb5cba6f54f9846af78b7ba4031d35fb
+  data.tar.gz: 2ec4137407dfaf6b4189255532e59669798ac9ed57be8e6ecdb07c31525d132b9246da9d9fd6b98975e31b712e002e2693f523acf285d172df1b13c7c46617d5

data/README.md

@@ -3,9 +3,7 @@
 ![Build Status](https://github.com/kachick/eqq/actions/workflows/test_behaviors.yml/badge.svg?branch=main)
 [![Gem Version](https://badge.fury.io/rb/eqq.png)](http://badge.fury.io/rb/eqq)
 
-Pattern objects builder.
-
-`eqq` means `#===`
+Pattern objects builder
 
 ## Usage
 
@@ -14,7 +12,7 @@ Require Ruby 2.6 or later
 Add below code into your Gemfile
 
 ```ruby
-gem 'eqq', '0.0.2'
+gem 'eqq', '>= 0.0.7', '< 0.1.0'
 ```
 
 ### Overview
@@ -26,13 +24,133 @@ require 'eqq'
 [42, nil, true, false, '', 0].grep(Eqq.BOOLEAN) #=> [true, false]
 [42, [], {}, 'string', Object.new, nil].grep(Eqq.CAN(:to_h)) #=> [[], {}, nil]
 
-pattern = Eqq.define do
+pattern = Eqq.build do
   OR(AND(Float, 20..50), Integer)
 end
+
+p pattern #=> "OR(AND(Float, 20..50), Integer)"
 [4.2, 42, 42.0, 420].grep(pattern) #=> [42, 42.0, 420]
+
+inverted = Eqq.NOT(pattern)
+p inverted #=> "NOT(OR(AND(Float, 20..50), Integer))"
+[4.2, 42, 42.0, 420].grep(inverted) #=> [4.2]
+
+Eqq.SEND(:all?, pattern) === [4.2, 42, 42.0, 420] #=> false
+Eqq.SEND(:any?, pattern) === [4.2, 42, 42.0, 420] #=> true
+
+ret_in_case = (
+  case 42
+  when pattern
+    'Should be matched here! :)'
+  when inverted
+    'Should not be matched here! :<'
+  else
+    'Should not be matched here too! :<'
+  end
+)
+
+p ret_in_case #=> Should be matched here! :)
+
+ret_in_case = (
+  case 4.2
+  when pattern
+    'Should not be matched here! :<'
+  when inverted
+    'Should be matched here! :)'
+  else
+    'Should not be matched here too! :<'
+  end
+)
+
+p ret_in_case #=> Should be matched here! :)
+
+class MyClass
+  include Eqq::Buildable
+
+  def example
+    [4.2, 42, 42.0, 420].grep(OR(AND(Float, 20..50), Integer))
+  end
+end
+MyClass.new.example #=> [42, 42.0, 420]
 ```
 
+### Explanation
+
+All products can be called as `pattern === other`.
+
+This signature will fit in most Ruby code.
+
+* `case ~ when` syntax
+* Enumerable#grep
+* Enumerable#grep_v
+* Enumerable#all?
+* Enumerable#any?
+* Enumerable#none?
+* Enumerable#one?
+* Enumerable#slice_after
+* Enumerable#slice_before
+
+They can take this interface as the `pattern`.
+
+And you already saw. All of patterns can be mixed with other patterns as a parts.
+Reuse as you wish!
+
+### Builders
+
+* OR(*patterns) - Product returns `true` when matched even one pattern
+* AND(*patterns) - Product returns `true` when matched all patterns
+* NOT(pattern) - Product returns `true` when not matched the pattern
+* CAN(*method_names) - Product returns `true` when it has all of the methods (checked with `respond_to?`)
+* RESCUE(exception_class/module, pattern) - Product returns `true` when the pattern raises the exception
+* QUIET(*patterns) - Product returns `true` when all patterns did not raise any exception
+* EQ(object) - Product returns `true` when matched with `#==`
+* SAME(object) - Product returns `true` when matched with `#equal?`
+* SEND(name, pattern) - Basically provided for Enumerable
+* BOOLEAN() - Product returns `true` when matched to `true` or `false`
+* NIL() - Product returns `true` when matched to `nil` (Not consider `nil?`)
+* ANYTHING() - Product returns `true`, always `true`
+* NEVER() - Product returns `false`, always `false`
+* XOR(pattern1, pattern2) - Product returns `true` when matched one of the pattern, when matched both returns `false`
+* NAND(*patterns) - Product is an inverted `AND`
+* NOR(*patterns) - Product is an inverted `OR`
+
+### Best fit for RSpec's `satisfy` matcher too
+
+All builders actually generate a `Proc (lambda)` instance.
+The signature will fit for RSpec's built-in [`satisfy` matcher](https://relishapp.com/rspec/rspec-expectations/v/3-10/docs/built-in-matchers/satisfy-matcher) too.
+
+```ruby
+RSpec.describe RSpec::Matchers::BuiltIn::Satisfy do
+  let(:product) { Eqq.AND(Integer, 24..42) }
+
+  it 'perfectly works' do
+    expect(23).not_to satisfy(&product)
+    expect(24).to satisfy(&product)
+    expect(24.0).not_to satisfy(&product)
+    expect(42).to satisfy(&product)
+    expect(42.0).not_to satisfy(&product)
+    expect(43).not_to satisfy(&product)
+  end
+end
+```
+
+### Use builders without receiver specifying
+
+When you felt annoy to write `Eqq` in many place, some ways exist.
+
+* `Eqq.build(&block)` - In the block scope, all builder methods can be used without receiver
+* `extend Eqq::Buildable` - In the class/module, all builders can be used as class methods
+* `include Eqq::Buildable` - In the class/module, all builders can be used as instance methods
+
+### Signature
+
+* This gem provides [ruby/rbs](https://github.com/ruby/rbs) signature file
+
 ## Links
 
 * [Repository](https://github.com/kachick/eqq)
 * [API documents](https://kachick.github.io/eqq)
+
+## NOTE
+
+* [`eqq` is the implementation name of `#===` in CRuby](https://github.com/ruby/ruby/blob/2a685da1fcd928530509e99f5edb4117bc377994/range.c#L1859)

data/lib/eqq.rb

@@ -4,21 +4,18 @@
 # Copyright (c) 2011 Kenichi Kamiya
 # Forked from https://github.com/kachick/validation at 2021
 
-require_relative 'eqq/buildable'
 require_relative 'eqq/version'
 
+# Pattern objects builder
 module Eqq
-  extend Buildable
-
+  # Base error of this library
   class Error < StandardError; end
-  class InvalidProductError < Error; end
 
-  class DSLScope
-    include Buildable
-  end
+  # Raised when found some products are invalid as a pattern object
+  class InvalidProductError < Error; end
 
   class << self
-    def valid?(object)
+    def pattern?(object)
       case object
       when Proc, Method
         object.arity == 1
@@ -31,11 +28,41 @@ module Eqq
       end
     end
 
-    def define(&block)
+    # @deprecated Use {pattern?} instead. This will be dropped since `0.1.0`
+    def valid?(object)
+      pattern?(object)
+    end
+
+    # @api private
+    def satisfy?(object)
+      (Proc === object) && object.lambda? && (object.arity == 1) && object.respond_to?(:inspect)
+    end
+
+    # @return [Proc]
+    # @raise [InvalidProductError] if the return value is not looks to be built with builders
+    def build(&block)
+      raise ArgumentError, 'might be mis used the `Eqq.build` in your code' unless block
+
       pattern = DSLScope.new.instance_exec(&block)
-      raise InvalidProductError unless valid?(pattern)
+      raise InvalidProductError, 'might be mis used the `Eqq.build` in your code' unless satisfy?(pattern)
 
       pattern
     end
+
+    # @deprecated Use {build} instead. This will be dropped since `0.1.0`
+    def define(&block)
+      build(&block)
+    end
+  end
+end
+
+require_relative 'eqq/buildable'
+
+module Eqq
+  extend Buildable
+
+  class DSLScope
+    include Buildable
   end
+  private_constant(:DSLScope)
 end

data/lib/eqq/buildable.rb

@@ -2,20 +2,69 @@
 # frozen_string_literal: true
 
 module Eqq
+  # Actually having definitions for the pattern builders
   module Buildable
-    extend self
+    class << self
+      # When the inspection is failed some unexpected reasons, it will fallback to this value
+      # This value is not fixed as a spec, might be changed in future
+      INSPECTION_FALLBACK = 'UninspectableObject'
 
+      # @api private
+      # @return [String]
+      def safe_inspect_for(object)
+        String.try_convert(object.inspect) || INSPECTION_FALLBACK
+      rescue Exception
+        # This implementation used `RSpec::Support::ObjectFormatter::UninspectableObjectInspector` as a reference, thank you!
+        # ref: https://github.com/kachick/times_kachick/issues/97
+        singleton_class = class << object; self; end
+        begin
+          klass = singleton_class.ancestors.detect { |ancestor| !ancestor.equal?(singleton_class) }
+          native_object_id = '%#016x' % (object.__id__ << 1)
+          "#<#{klass}:#{native_object_id}>"
+        rescue Exception
+          INSPECTION_FALLBACK
+        end
+      end
+
+      # @api private
+      # @return [void]
+      def define_inspect_on(product, name:, arguments:)
+        inspect = "#{name}(#{arguments.map { |argument| safe_inspect_for(argument) }.join(', ')})".freeze
+        product.define_singleton_method(:inspect) do
+          inspect
+        end
+      end
+
+      # @api private
+      # @return [void]
+      def validate_patterns(*patterns)
+        invalids = patterns.reject { |pattern| Eqq.pattern?(pattern) }
+        invalid_inspections = invalids.map { |invalid| safe_inspect_for(invalid) }.join(', ')
+        raise ArgumentError, "given `#{invalid_inspections}` are invalid as pattern objects" unless invalids.empty?
+      end
+    end
+
+    # Product returns `true` when matched all patterns
+    #
     # @param pattern1 [Proc, Method, #===]
     # @param pattern2 [Proc, Method, #===]
     # @param patterns [Array<Proc, Method, #===>]
     # @return [Proc]
-    #   this lambda return true if match all patterns
     def AND(pattern1, pattern2, *patterns)
-      ->v {
-        [pattern1, pattern2, *patterns].all? { |pattern| pattern === v }
+      patterns = [pattern1, pattern2, *patterns].freeze
+      Buildable.validate_patterns(*patterns)
+
+      product = ->v {
+        patterns.all? { |pattern| pattern === v }
       }
+
+      Buildable.define_inspect_on(product, name: 'AND', arguments: patterns)
+
+      product
     end
 
+    # Product is an inverted {#AND}
+    #
     # @param pattern1 [Proc, Method, #===]
     # @param pattern2 [Proc, Method, #===]
     # @param patterns [Array<Proc, Method, #===>]
@@ -24,17 +73,26 @@ module Eqq
       NOT(AND(pattern1, pattern2, *patterns))
     end
 
+    # Product returns `true` when matched even one pattern
+    #
     # @param pattern1 [Proc, Method, #===]
     # @param pattern2 [Proc, Method, #===]
     # @param patterns [Array<Proc, Method, #===>]
     # @return [Proc]
-    #   this lambda return true if match a any pattern
     def OR(pattern1, pattern2, *patterns)
-      ->v {
-        [pattern1, pattern2, *patterns].any? { |pattern| pattern === v }
+      patterns = [pattern1, pattern2, *patterns].freeze
+      Buildable.validate_patterns(*patterns)
+
+      product = ->v {
+        patterns.any? { |pattern| pattern === v }
       }
+      Buildable.define_inspect_on(product, name: 'OR', arguments: patterns)
+
+      product
     end
 
+    # Product is an inverted {#OR}
+    #
     # @param pattern1 [Proc, Method, #===]
     # @param pattern2 [Proc, Method, #===]
     # @param patterns [Array<Proc, Method, #===>]
@@ -43,56 +101,72 @@ module Eqq
       NOT(OR(pattern1, pattern2, *patterns))
     end
 
+    # Product returns `true` when matched one of the pattern, when matched both returns `false`
+    #
     # @param pattern1 [Proc, Method, #===]
     # @param pattern2 [Proc, Method, #===]
-    # @param patterns [Array<Proc, Method, #===>]
     # @return [Proc]
-    def XOR(pattern1, pattern2, *patterns)
-      ->v {
-        [pattern1, pattern2, *patterns].one? { |pattern| pattern === v }
+    def XOR(pattern1, pattern2)
+      patterns = [pattern1, pattern2].freeze
+      Buildable.validate_patterns(*patterns)
+
+      product = ->v {
+        patterns.one? { |pattern| pattern === v }
       }
-    end
+      Buildable.define_inspect_on(product, name: 'XOR', arguments: patterns)
 
-    # @param pattern1 [Proc, Method, #===]
-    # @param pattern2 [Proc, Method, #===]
-    # @param patterns [Array<Proc, Method, #===>]
-    # @return [Proc]
-    def XNOR(pattern1, pattern2, *patterns)
-      NOT(XOR(pattern1, pattern2, *patterns))
+      product
     end
 
+    # Product returns `true` when not matched the pattern
+    #
     # @param pattern [Proc, Method, #===]
     # @return [Proc]
     def NOT(pattern)
-      raise ArgumentError, 'wrong object for pattern' unless Eqq.valid?(pattern)
+      Buildable.validate_patterns(pattern)
 
-      ->v { !(pattern === v) }
+      product = ->v { !(pattern === v) }
+
+      Buildable.define_inspect_on(product, name: 'NOT', arguments: [pattern])
+
+      product
     end
 
-    # A pattern builder.
+    # Product returns `true` when matched with `#==`
+    #
     # @param obj [#==]
     # @return [Proc]
     def EQ(obj)
-      ->v { obj == v }
+      product = ->v { obj == v }
+      Buildable.define_inspect_on(product, name: 'EQ', arguments: [obj])
+      product
     end
 
+    # Product returns `true` when matched with `#equal?`
+    #
     # @param obj [#equal?]
     # @return [Proc]
     def SAME(obj)
-      ->v { obj.equal?(v) }
+      product = ->v { obj.equal?(v) }
+      Buildable.define_inspect_on(product, name: 'SAME', arguments: [obj])
+      product
     end
 
-    # @param message1 [Symbol, String]
-    # @param messages [Array<Symbol, String>]
+    # Product returns `true` when it has all of the methods (checked with `respond_to?`)
+    #
+    # @param message1 [Symbol, String, #to_sym]
+    # @param messages [Array<Symbol, String, #to_sym>]
     # @return [Proc]
     def CAN(message1, *messages)
-      messages = begin
-        [message1, *messages].map(&:to_sym)
-      rescue NoMethodError
-        raise ArgumentError
-      end
+      messages = (
+        begin
+          [message1, *messages].map(&:to_sym).freeze
+        rescue NoMethodError
+          raise ArgumentError
+        end
+      )
 
-      ->v {
+      product = ->v {
         messages.all? { |message|
           begin
             v.respond_to?(message)
@@ -101,18 +175,22 @@ module Eqq
           end
         }
       }
+
+      Buildable.define_inspect_on(product, name: 'CAN', arguments: messages)
+
+      product
     end
 
+    # Product returns `true` when all patterns did not raise any exception
+    #
     # @param pattern1 [Proc, Method, #===]
     # @param patterns [Array<Proc, Method, #===>]
     # @return [Proc]
     def QUIET(pattern1, *patterns)
-      patterns = [pattern1, *patterns]
-      unless patterns.all? { |pattern| Eqq.valid?(pattern) }
-        raise ArgumentError, 'wrong object for pattern'
-      end
+      patterns = [pattern1, *patterns].freeze
+      Buildable.validate_patterns(*patterns)
 
-      ->v {
+      product = ->v {
         patterns.all? { |pattern|
           begin
             pattern === v
@@ -123,16 +201,22 @@ module Eqq
           end
         }
       }
+
+      Buildable.define_inspect_on(product, name: 'QUIET', arguments: patterns)
+
+      product
     end
 
+    # Product returns `true` when the pattern raises the exception
+    #
     # @param mod [Module]
     # @param pattern [Proc, Method, #===]
     # @return [Proc]
     def RESCUE(mod, pattern)
-      raise ArgumentError unless Eqq.valid?(pattern)
+      Buildable.validate_patterns(pattern)
       raise ArgumentError unless Module === mod
 
-      ->v {
+      product = ->v {
         begin
           pattern === v
           false
@@ -142,31 +226,76 @@ module Eqq
           false
         end
       }
+
+      Buildable.define_inspect_on(product, name: 'RESCUE', arguments: [mod, pattern])
+
+      product
     end
 
-    # @param name [Symbol, #to_sym]
+    # Basically provided for Enumerable
+    #
+    # @param name [Symbol, String, #to_sym]
     # @param pattern [Proc, Method, #===]
     # @return [Proc]
     def SEND(name, pattern)
-      raise InvalidProductError unless Eqq.valid?(pattern)
+      name = (
+        begin
+          name.to_sym
+        rescue NoMethodError
+          raise ArgumentError
+        end
+      )
+      Buildable.validate_patterns(pattern)
 
-      ->v {
+      product = ->v {
         v.__send__(name, pattern)
       }
+
+      Buildable.define_inspect_on(product, name: 'SEND', arguments: [name, pattern])
+
+      product
     end
 
-    # @return [BasicObject]
+    EQQ_BUILTIN_ANYTHING = ->_v { true }
+    define_inspect_on(EQQ_BUILTIN_ANYTHING, name: 'ANYTHING', arguments: [])
+
+    # Product returns `true`, always `true`
+    #
+    # @return [Proc]
     def ANYTHING
-      # BasicObject.=== always passing
-      BasicObject
+      EQQ_BUILTIN_ANYTHING
+    end
+
+    EQQ_BUILTIN_NEVER = ->_v { false }
+    define_inspect_on(EQQ_BUILTIN_NEVER, name: 'NEVER', arguments: [])
+
+    # Product returns `false`, always `false`
+    #
+    # @return [Proc]
+    def NEVER
+      EQQ_BUILTIN_NEVER
     end
 
-    BOOLEAN = OR(SAME(true), SAME(false))
-    private_constant :BOOLEAN
+    EQQ_BUILTIN_BOOLEAN = ->v { true.equal?(v) || false.equal?(v) }
+    define_inspect_on(EQQ_BUILTIN_BOOLEAN, name: 'BOOLEAN', arguments: [])
 
-    # @return [BOOLEAN]
+    # Product returns `true` when matched to `true` or `false`
+    #
+    # @return [Proc]
     def BOOLEAN
-      BOOLEAN
+      EQQ_BUILTIN_BOOLEAN
+    end
+
+    EQQ_BUILTIN_NIL = ->v { nil.equal?(v) }
+    define_inspect_on(EQQ_BUILTIN_NIL, name: 'NIL', arguments: [])
+
+    # Product returns `true` when matched to `nil` (Not consider `nil?`)
+    #
+    # @return [Proc]
+    def NIL
+      EQQ_BUILTIN_NIL
     end
+
+    private_constant(:EQQ_BUILTIN_ANYTHING, :EQQ_BUILTIN_NEVER, :EQQ_BUILTIN_BOOLEAN, :EQQ_BUILTIN_NIL)
   end
 end

data/lib/eqq/version.rb

@@ -2,5 +2,6 @@
 # frozen_string_literal: true
 
 module Eqq
-  VERSION = '0.0.2'
+  # This will be same as latest published gem version
+  VERSION = '0.0.7'
 end

data/sig/eqq.rbs

@@ -1,3 +1,4 @@
+# Pattern objects builder
 module Eqq
   interface _Patternable
     def ===: (untyped object) -> bool
@@ -7,43 +8,114 @@ module Eqq
     def to_sym: -> Symbol
   end
 
+  interface _Inspectable
+    def inspect: () -> String
+  end
+
   module Buildable
-    # A pribate constant. Should not be used in your code.
-    BOOLEAN: ^(untyped object) -> bool
-
-    extend Buildable
-    def OR: (_Patternable, _Patternable, *_Patternable) -> ^(untyped object) -> bool
-    def AND: (_Patternable, _Patternable, *_Patternable) -> ^(untyped object) -> bool
-    def NAND: (_Patternable, _Patternable, *_Patternable) -> ^(untyped object) -> bool
-    def NOR: (_Patternable, _Patternable, *_Patternable) -> ^(untyped object) -> bool
-    def XOR: (_Patternable, _Patternable, *_Patternable) -> ^(untyped object) -> bool
-    def XNOR: (_Patternable, _Patternable, *_Patternable) -> ^(untyped object) -> bool
-    def NOT: (_Patternable) -> ^(untyped object) -> bool
-    def EQ: (untyped object) -> ^(untyped object) -> bool
-    def SAME: (untyped object) -> ^(untyped object) -> bool
-    def CAN: (_ToSym, *_ToSym) -> ^(untyped object) -> bool
-    def RESCUE: (Module, _Patternable) -> ^(untyped object) -> bool
-    def QUIET: (_Patternable, *_Patternable) -> ^(untyped object) -> bool
-    def SEND: (Symbol | String name, _Patternable) -> ^(untyped object) -> bool
-    def ANYTHING: () -> BasicObject
-    def BOOLEAN: () -> ^(untyped object) -> bool
+    type patternable_lambda = ^(untyped object) -> bool
+    type product = patternable_lambda & _Inspectable
+
+    # A private constant. Should not be used in your code.
+    EQQ_BUILTIN_ANYTHING: product
+
+    # A private constant. Should not be used in your code.
+    EQQ_BUILTIN_NEVER: product
+
+    # A private constant. Should not be used in your code.
+    EQQ_BUILTIN_BOOLEAN: product
+
+    # A private constant. Should not be used in your code.
+    EQQ_BUILTIN_NIL: product
+
+    # A private API. Should not be used in your code.
+    def self.safe_inspect_for: (untyped object)-> String
+
+    # A private API. Should not be used in your code.
+    def self.define_inspect_on: (patternable_lambda product, name: String, arguments: Array[untyped])-> void
+
+    # A private API. Should not be used in your code.
+    def self.validate_patterns: (*untyped) -> void
+
+    # Product returns `true` when matched even one pattern
+    def OR: (_Patternable, _Patternable, *_Patternable) -> product
+
+    # Product returns `true` when matched all patterns
+    def AND: (_Patternable, _Patternable, *_Patternable) -> product
+
+    # Product is an inverted `AND`
+    def NAND: (_Patternable, _Patternable, *_Patternable) -> product
+
+    # Product is an inverted `OR`
+    def NOR: (_Patternable, _Patternable, *_Patternable) -> product
+
+    # Product returns `true` when matched one of the pattern, when matched both returns `false`
+    def XOR: (_Patternable, _Patternable) -> product
+
+    # Product returns `true` when not matched the pattern
+    def NOT: (_Patternable) -> product
+
+    # Product returns `true` when matched with `#==`
+    def EQ: (untyped object) -> product
+
+    # Product returns `true` when matched with `#equal?`
+    def SAME: (untyped object) -> product
+
+    # Product returns `true` when it has all of the methods (checked with `respond_to?`)
+    def CAN: (_ToSym, *_ToSym) -> product
+
+    # Product returns `true` when the pattern raises the exception
+    def RESCUE: (Module, _Patternable) -> product
+
+    # Product returns `true` when all patterns did not raise any exception
+    def QUIET: (_Patternable, *_Patternable) -> product
+
+    # Basically provided for Enumerable
+    def SEND: (Symbol | String name, _Patternable) -> product
+
+    # Product returns `true`, always `true`
+    def ANYTHING: () -> product
+
+    # Product returns `false`, always `false`
+    def NEVER: () -> product
+
+    # Product returns `true` when matched to `true` or `false`
+    def BOOLEAN: () -> product
+
+    # Product returns `true` when matched to `nil` (Not consider `nil?`)
+    def NIL: () -> product
   end
 
   extend Buildable
 
+  # Base error of this library
   class Error < StandardError
   end
 
+  # Raised when found some products are invalid as a pattern object
   class InvalidProductError < Error
   end
 
-  # A pribate API. Should not be used in your code.
+  # A private API. Should not be used in your code.
   class DSLScope
     include Buildable
   end
 
   VERSION: String
 
+  # Returns `true` when given object has patternable signature
+  def self.pattern?: (untyped object) -> bool
+
+  # Alias of `pattern?`. But deperecated. Do not use in your code anymore.
   def self.valid?: (untyped object) -> bool
+
+  # Returns `true` when given object has correct signature as a product of builders
+  # Basically this is a private API. Should not be used in your code.
+  def self.satisfy?: (untyped object) -> bool
+
+  # In the block scope, all builder methods can be used without receiver
+  def self.build:  { () -> _Patternable } -> _Patternable
+
+  # Alias of `build`. But deperecated. Do not use in your code anymore.
   def self.define:  { () -> _Patternable } -> _Patternable
 end

metadata

@@ -1,16 +1,23 @@
 --- !ruby/object:Gem::Specification
 name: eqq
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.7
 platform: ruby
 authors:
 - Kenichi Kamiya
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-06-01 00:00:00.000000000 Z
+date: 2021-06-06 00:00:00.000000000 Z
 dependencies: []
-description: "    [4.2, 42, 42.0, 420].grep(Eqq.AND(Integer, 20..50)) #=> [42]\n"
+description: |2
+      Pattern objects builder.
+
+      All products can be used as `pattern === something`.
+
+      All products can be mixed with other products as a parts.
+
+      Reuse as you wish!
 email:
 - kachick1+ruby@gmail.com
 executables: []
@@ -49,5 +56,5 @@ requirements: []
 rubygems_version: 3.2.15
 signing_key:
 specification_version: 4
-summary: Pattern objects builder. `eqq` means `#===`
+summary: Pattern objects builder
 test_files: []