toy_adt 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f45563ee2b678fd2d1ad8dd632d05fee56b16dbc46b5b4952082be20f48dea4
-  data.tar.gz: 56ea2b517926e966389b211ccc30d2d9c2113d916996b514146519c2646eef52
+  metadata.gz: e3d42d697ccf26c13802f9052755b8a2472ed96ed4fc51b1de0559fd77fc3c6f
+  data.tar.gz: 3fff27aff7e04fe74fb86ab350f6f768126f9c39c31f55f4c9146b159c276760
 SHA512:
-  metadata.gz: 90beb64a03734f4c5405a15165b939298b33cac5bf0acb1b3422083df919aa9d4ff10325c36d983f4254ce770dfbeae8792a7ea247ad6d92e8a779ed449f3f64
-  data.tar.gz: c0a93e38be8bdfa02b24599ed4a49cd6aafda170e1488a82426497d2a7d07e0ee1540a1167e7a34bd2bdd3c15a986d47d4ce38d034c143dc129e778a6cf2ab1d
+  metadata.gz: 40947f6a8f30381e893adaf8a6675832c53bc9a968b7d53a5c013bd815239ed12615cec0840007d37727caa08be9d8f3d92556c8411b7571d0c5703cf7b45a0a
+  data.tar.gz: 2c251dbe86f76e7f837969372c7078c869d9a008747206f8124d177facba235b85d073550ccd38313d9c36a8517c4b3d857d5484d891f7c904792029adba3636

data/lib/toy_adt/deconstructable_sorbet_struct.rb

@@ -16,7 +16,7 @@ module ToyAdt
       ).returns(T::Hash[Symbol, T.untyped])
     }
     def deconstruct_keys(keys)
-      return properties.to_h { |k| [k, send(k)] } if keys.empty? || keys.nil?
+      return properties.to_h { |k| [k, send(k)] } if keys.nil? || keys.empty?
 
       (properties & keys).to_h { |k| [k, send(k)] }
     end

data/lib/toy_adt/matcher.rb

@@ -0,0 +1,133 @@
+# typed: false
+# frozen_string_literal: true
+
+require "set"
+
+module ToyAdt
+  class Matcher
+    extend T::Sig
+
+    POSITIONAL_ARGS = Set[:req, :opt, :rest]
+    KEYWORD_ARGS    = Set[:keyreq, :key, :keyrest]
+    BLOCK_ARGS      = Set[:block]
+
+    def initialize(from:, &fn)
+      @from = from
+      @fields = from::FIELDS
+      @sub_classes = @fields.to_h { [_1, from.const_get(_1.capitalize)] }
+
+      create_branch_methods
+
+      instance_eval(&fn) if block_given?
+    end
+
+    def else(&fn)
+      @else_fn = fn
+    end
+
+    def call(input)
+      # Find the subclass the input matches to
+      branch_name, _ = @sub_classes.find do |_, klass|
+        matches_type?(klass, input)
+      end
+
+      # If there are none either hit the else or fail hard
+      if branch_name.nil?
+        return @else_fn.call(input) if @else_fn
+        T.absurd(input)
+      end
+
+      # All values to compare against conditions
+      values = input.deconstruct_keys(nil)
+
+      # Try to find the first matching branch function via
+      # conditions:
+      #
+      #     value.match do |m|
+      #       m.some(value: 0..5) {}
+      #       m.some {}
+      #       m.else {}
+      #     end
+      #
+      # In this case a "Some" type with a value matching will hit
+      # first. Granted less specific branches going first means
+      # those get hit first, so not recommended.
+      _, branch_fn = @branches.find do |branch_condition, _|
+        name, conditions = branch_condition
+
+        # First thing is the key is a tuple of subclass / branch
+        # name, the second part is the condition if there are any.
+        branch_name == name && conditions.all? { |k, condition|
+          matches_type?(condition, values[k])
+        }
+      end
+
+      return branch_fn.call(input) if branch_fn
+      return @else_fn.call(input) if @else_fn
+
+      T.absurd(input)
+    end
+
+    alias_method :===, :call
+
+    def to_proc
+      -> input { call(input) }
+    end
+
+    # Making this respond to both `===` and the sorbet type
+    # validation variants.
+    private def matches_type?(type, value)
+      type === value || sorbet_is_a?(type, value)
+    end
+
+    private def sorbet_is_a?(type, value)
+      T::Types::Base === type && type.valid?(value)
+    end
+
+    private def create_branch_methods
+      @branches = {}
+
+      @fields.each do |field|
+        define_singleton_method(field) do |**conditions, &fn|
+          param_type  = get_param_type(fn)
+          param_names = fn.parameters.map(&:last)
+
+          # Trying to make it play nicely with pattern matching
+          # semantics, hitting both positional and keywords but
+          # also no-args.
+          @branches[[field, conditions]] = -> input do
+            case param_type
+            when :keyword
+              fn.call(**input.deconstruct_keys(param_names))
+            when :positional
+              fn.call(*input.deconstruct) # Should probably disable this
+            when :none
+              fn.call
+            end
+          end
+        end
+      end
+    end
+
+    private def get_param_type(fn)
+      param_types = fn.parameters.map(&:first)
+
+      has_positional = param_types.any?(POSITIONAL_ARGS)
+      has_keywords   = param_types.any?(KEYWORD_ARGS)
+      has_block      = param_types.any?(BLOCK_ARGS)
+
+      if has_block
+        raise ArgumentError, "Cannot use function arguments"
+      end
+
+      if has_positional && has_keywords
+        raise ArgumentError, "Cannot have both positional and keyword arguments"
+      end
+
+      return :keyword if has_keywords
+      return :positional if has_positional
+
+      :none
+    end
+  end
+end

data/lib/toy_adt/public_api.rb

@@ -1,5 +1,6 @@
 # typed: false
 require "sorbet-runtime"
+require "set"
 
 module ToyAdt
   module PublicApi
@@ -34,7 +35,12 @@ module ToyAdt
         extend T::Helpers
         sealed!
 
+        const_set(:FIELDS, types.keys)
+
         module_eval(&fn) if block_given?
+
+        def self.match(&fn) = Matcher.new(from: self, &fn)
+        def self.match_call(input, &fn) = match(&fn).call(input)
       end
 
       types.each do |type, config|
@@ -42,12 +48,19 @@ module ToyAdt
           include container_module
           include DeconstructableSorbetStruct
 
+          const_set(:CONTAINER, container_module)
+
           config.each do |field, type|
             const field, type
           end
+
+          def match(&fn) = self.class::CONTAINER.match(&fn).call(self)
         end
 
         container_module.const_set(type.capitalize, klass)
+        container_module.define_method(type) do
+          klass
+        end
       end
 
       container_module

data/lib/toy_adt/version.rb

@@ -1,6 +1,6 @@
-# typed: strict
+# typed: false
 # frozen_string_literal: true
 
 module ToyAdt
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/toy_adt.rb

@@ -3,6 +3,7 @@
 
 require_relative "toy_adt/version"
 require_relative "toy_adt/deconstructable_sorbet_struct"
+require_relative "toy_adt/matcher"
 require_relative "toy_adt/public_api"
 
 module ToyAdt

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: toy_adt
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Brandon Weaver
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-05-26 00:00:00.000000000 Z
+date: 2022-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -84,6 +84,7 @@ files:
 - Rakefile
 - lib/toy_adt.rb
 - lib/toy_adt/deconstructable_sorbet_struct.rb
+- lib/toy_adt/matcher.rb
 - lib/toy_adt/public_api.rb
 - lib/toy_adt/version.rb
 - sorbet/config