t_algebra 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 617977f1693f665231e2b42e517fc64a92de79bbe8824408501586b992308988
-  data.tar.gz: d953427b001daff3bbfab23e94ce46fcd61c8a386f891d14019312d0ae37ddca
+  metadata.gz: 2c3ba123bba6480b11a43629310dcf4caa7f3c1995a8ca54a3694cec83aeb868
+  data.tar.gz: 3c47a5a18b15088b2d82d05c0662bda9c68fc72ca60085d7a3d3557a22c760eb
 SHA512:
-  metadata.gz: 98fb648dfe43e767057bf50f1479ace8a777b01bf0803b46b9e29c8668aaea8f8464014a7282c74796d1d635b2c4afddec828fb5e85d07c0be44ff6fc85595f0
-  data.tar.gz: e9ac940c79d2906bf4f27c902474966e8175e1497b98579a0793400f374568c2022f7f804014ba3fd8bbc9f7ddfa84de46ff75dca0b42da9943a0a482d554f15
+  metadata.gz: 6850ff73905c72cd22587c2c19d93cf97bc7eebd6543c33e5094e996e2e6e416499a85db1f482ccc37363a4aaa100a2d8f7409480d1b2b0376451a8945d2877d
+  data.tar.gz: 863dc96cd733cec7966a58d21ce8d9c1c8123850743975983fb630d4b71d94ef1a9267c3d436e0800eabbe751c10532a95413e3b2a10184c213b3ec763b084bb

data/Gemfile.lock

@@ -1,12 +1,19 @@
 PATH
   remote: .
   specs:
-    t_algebra (0.1.5)
+    t_algebra (1.1.1)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    benchmark-ips (2.9.2)
+    concurrent-ruby (1.1.9)
     diff-lcs (1.4.4)
+    dry-core (0.7.1)
+      concurrent-ruby (~> 1.0)
+    dry-monads (1.4.0)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 0.7)
     rake (12.3.3)
     rspec (3.10.0)
       rspec-core (~> 3.10.0)
@@ -26,6 +33,8 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  benchmark-ips
+  dry-monads
   rake (~> 12.0)
   rspec (~> 3.0)
   t_algebra!

data/README.md

@@ -43,17 +43,18 @@ end
 ```
 
 The class `TAlgebra::Monad::Maybe` wraps a result which may or may not be nil, and uses the Monad tech of `bind` + `fmap` to 
-sensibly manipulate that result. The below example uses `run/yield` notation (analagous to Haskell `do` notation or js `async/await`)
+sensibly manipulate that result. The below example uses `chain/bound` notation (analagous to Haskell `do/<-` notation or js `async/await`)
 to reproduce the same functionality:
 
 ```
 # @return [TAlgebra::Monad::Maybe]
 def get_address(user)
-    TAlgebra::Monad::Maybe.run do |y|
+    TAlgebra::Monad::Maybe.chain do
         m_user = just(user)
-        street = y.yield { m_user.fetch(:street) }
-        city = y.yield { m_user.fetch(:city) }
-        state = y.yield { m_user.fetch(:state) }
+        
+        street = bound { m_user.fetch(:street) }
+        city = bound { m_user.fetch(:city) }
+        state = bound { m_user.fetch(:state) }
         "#{street}, #{city} #{state.upcase}"
     end
 end
@@ -65,16 +66,16 @@ subsequently `Parser` which can validate and map over complex data structure.
 ```
 # @return [TAlgebra::Monad::Parser]
 def get_address(user)
-    TAlgebra::Monad::Parser.run do |y|
+    TAlgebra::Monad::Parser.chain do
         # validate street is present with `#fetch!`
-        street = y.yield { fetch!(user, :street) }
+        street = bound { fetch!(user, :street) }
         
         # validate that the city is a string with is `#is_a?`
-        city = y.yield { fetch!(user, :city).is_a?(String) }
+        city = bound { fetch!(user, :city).is_a?(String) }
         
         # validate that the state is a 2 letter long string with `#validate` 
         # and transform to all caps with `#fmap`
-        state = y.yield do 
+        state = bound do 
             fetch!(user, :state)
                 .is_a?(String)
                 .validate("Is 2 letter code"){ |state| state.length == 2 }
@@ -97,7 +98,8 @@ class ExtAPI
     
     class << self
         def call(verb, path)
-            ... make api cal
+            result = ... make api cal
+            new(success: result)
         rescue => e
             new(http_error: {e.status, e.message})
         end
@@ -122,16 +124,16 @@ And it could be used like:
 
 ```
 def user_cities
-    ExtAPI.run do |y|
-        users = y.yield { call('GET', '/users') }
-        profiles = y.yield { call('GET', "/users/profile?id=#{users.map(&:id).to_json}" } 
+    ExtAPI.chain do
+        users = bound { call('GET', '/users') }
+        profiles = bound { call('GET', "/users/profile?id=#{users.map(&:id).to_json}" } 
         profiles.map(&:city).uniq
     end
 end
 ```
 
-(Note that while the concept of Promise is monadic, the above ExtAPI implementation is entirely synchronous.) Should
-either of the two calls fail, this method will return that error status and message to be handled by the client code.
+Should either of the two calls fail, this method will return that error status and message to be handled by the client code.
+(Note that while the concept of Promise is monadic, the above ExtAPI implementation is entirely synchronous.)
 
 ## Development
 

data/lib/t_algebra/monad/either.rb

@@ -1,7 +1,7 @@
 module TAlgebra
   module Monad
     class Either
-      include TAlgebra::Monad
+      include TAlgebra::Monad::SingleValued
 
       LEFT = :left
       RIGHT = :right

data/lib/t_algebra/monad/maybe.rb

@@ -1,7 +1,7 @@
 module TAlgebra
   module Monad
     class Maybe
-      include TAlgebra::Monad
+      include TAlgebra::Monad::SingleValued
 
       NOTHING = :nothing
       JUST = :just
@@ -19,12 +19,6 @@ module TAlgebra
         def to_maybe(value_or_nil)
           value_or_nil.nil? ? nothing : pure(value_or_nil)
         end
-
-        # def run_bind(ma, &block)
-        #   # raise "Yield blocks must return instances of #{self}. Got #{ma.class}" unless [Parser, Parser::Optional].include?(ma.class)
-        #
-        #   ma.bind(&block)
-        # end
       end
 
       def fmap(&block)

data/lib/t_algebra/monad/parser.rb

@@ -1,7 +1,7 @@
 module TAlgebra
   module Monad
     class Parser < Either
-      include TAlgebra::Monad
+      include TAlgebra::Monad::SingleValued
 
       def initialize(is:, value:, name: nil)
         super(is: is, value: value)
@@ -25,7 +25,7 @@ module TAlgebra
           parse(o).fetch!(key)
         end
 
-        def run_bind(ma, &block)
+        def chain_bind(ma, &block)
           raise "Yield blocks must return instances of #{self}. Got #{ma.class}" unless [Parser, Parser::Optional].include?(ma.class)
 
           ma.as_parser.bind(&block)

data/lib/t_algebra/monad/single_valued.rb

@@ -0,0 +1,36 @@
+require "fiber"
+# @abstract
+module TAlgebra
+  module Monad
+    module SingleValued
+      module Static
+        def chain(&block)
+          receiver = augmented_receiver(block)
+          fiber = Fiber.new { receiver.instance_exec(&block) }
+          chain_recursive(fiber, [])
+        end
+
+        private
+
+        def chain_recursive(fiber, current)
+          val = fiber.resume current
+
+          if fiber.alive?
+            chain_bind(val.call) { |subsequent| chain_recursive(fiber, subsequent) }
+          else
+            val.is_a?(self.class) ? val : pure(val)
+          end
+        end
+      end
+
+      class << self
+        def included(base)
+          base.class_eval do
+            include TAlgebra::Monad
+          end
+          base.extend(Static)
+        end
+      end
+    end
+  end
+end

data/lib/t_algebra/monad.rb

@@ -1,3 +1,4 @@
+require "fiber"
 # @abstract
 module TAlgebra
   module Monad
@@ -6,17 +7,19 @@ module TAlgebra
     end
 
     module Static
-      class LazyYielder
-        def initialize(yielder)
-          @yielder = yielder
-        end
+      def chain(&block)
+        receiver = augmented_receiver(block)
+        fiber_initializer = -> { Fiber.new { receiver.instance_exec(&block) } }
+        chain_recursive(fiber_initializer, [])
+      end
+      alias_method :run, :chain
 
-        def yield(&block)
-          @yielder.yield(block)
-        end
+      def bound(&block)
+        Fiber.yield(block)
       end
+      alias_method :_pick, :bound
 
-      def run(&block)
+      def augmented_receiver(block)
         block_self = block.binding.receiver
 
         self_class = self
@@ -24,56 +27,38 @@ module TAlgebra
           self_class.send(m, *args, &block)
         end
 
-        e = Enumerator.new { |y| block_self.instance_exec(LazyYielder.new(y), &block) }
-
-        run_recursive(e, [])
+        block_self
       end
 
-      def run_bind(ma, &block)
+      def chain_bind(ma, &block)
         raise "Yield blocks must return instances of #{self}" unless ma.instance_of?(self)
         ma.bind(&block)
       end
 
-      def lift_a2(ma, mb, &block)
+      def lift_a2(ma, mb)
         ma.bind do |a|
           mb.bind do |b|
-            pure(block.call(a, b))
+            pure(yield(a, b))
           end
         end
       end
 
       private
 
-      def run_recursive(enum, historical_values)
-        enum.rewind
+      def chain_recursive(fiber_initializer, historical_values)
+        fiber = fiber_initializer.call
 
+        val = fiber.resume
         historical_values.each do |h|
-          enum.next
-          enum.feed(h)
+          val = fiber.resume h
         end
 
-        if is_complete(enum)
-          val = value(enum)
-          val.is_a?(self.class) ? val : pure(val)
+        if fiber.alive?
+          chain_bind(val.call) { |a| chain_recursive(fiber_initializer, historical_values + [a]) }
         else
-          run_bind(enum.next.call) do |a|
-            run_recursive(enum, historical_values + [a])
-          end
+          val.is_a?(self.class) ? val : pure(val)
         end
       end
-
-      def is_complete(enumerator)
-        enumerator.peek
-        false
-      rescue StopIteration
-        true
-      end
-
-      def value(enumerator)
-        enumerator.peek
-      rescue StopIteration
-        $!.result
-      end
     end
 
     class << self

data/lib/t_algebra/version.rb

@@ -1,3 +1,3 @@
 module TAlgebra
-  VERSION = "0.1.5"
+  VERSION = "0.1.6"
 end

data/lib/t_algebra.rb

@@ -2,7 +2,7 @@ require_relative "t_algebra/version"
 require_relative "t_algebra/functor"
 require_relative "t_algebra/applicative"
 require_relative "t_algebra/monad"
-require_relative "t_algebra/monad/errors"
+require_relative "t_algebra/monad/single_valued"
 require_relative "t_algebra/monad/maybe"
 require_relative "t_algebra/monad/either"
 require_relative "t_algebra/monad/list"
@@ -10,5 +10,9 @@ require_relative "t_algebra/monad/reader"
 require_relative "t_algebra/monad/parser"
 
 module TAlgebra
-  class Error < StandardError; end
+  class UseError < StandardError
+  end
+
+  class UnsafeError < StandardError
+  end
 end

data/t_algebra.gemspec

@@ -17,6 +17,9 @@ Gem::Specification.new do |spec|
   spec.metadata["source_code_uri"] = "https://github.com/afg419/t_algebra"
   spec.metadata["changelog_uri"] = "https://example.com"
 
+  spec.add_development_dependency("dry-monads")
+  spec.add_development_dependency("benchmark-ips")
+
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files = Dir.chdir(File.expand_path("..", __FILE__)) do

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: t_algebra
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - aaron
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-12-08 00:00:00.000000000 Z
-dependencies: []
+date: 2021-12-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-monads
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description:
 email:
 - afg419@gmail.com
@@ -33,11 +61,11 @@ files:
 - lib/t_algebra/functor.rb
 - lib/t_algebra/monad.rb
 - lib/t_algebra/monad/either.rb
-- lib/t_algebra/monad/errors.rb
 - lib/t_algebra/monad/list.rb
 - lib/t_algebra/monad/maybe.rb
 - lib/t_algebra/monad/parser.rb
 - lib/t_algebra/monad/reader.rb
+- lib/t_algebra/monad/single_valued.rb
 - lib/t_algebra/version.rb
 - t_algebra.gemspec
 homepage: https://github.com/afg419/t_algebra

data/lib/t_algebra/monad/errors.rb

@@ -1,9 +0,0 @@
-module TAlgebra
-  module Monad
-    class UseError < StandardError
-    end
-
-    class UnsafeError < StandardError
-    end
-  end
-end