t_algebra 0.1.2 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c61dbc20ba8e3f3b37778601949560237c224902454ab26b935c5dc048c8511
-  data.tar.gz: 1a9f3e3b7dc17c500c7e827514cc332b1ac9d4c5da919d8de9c4cd16cb1fc6a8
+  metadata.gz: 2c3ba123bba6480b11a43629310dcf4caa7f3c1995a8ca54a3694cec83aeb868
+  data.tar.gz: 3c47a5a18b15088b2d82d05c0662bda9c68fc72ca60085d7a3d3557a22c760eb
 SHA512:
-  metadata.gz: 823c7c82e469fb68b44cb00dda7f796ce1d8c1717c9cb312e659d42a68d21a46b43c34b8af08792728fb13042302138b212c9ec93d1ccf1b338ba13036c6afb8
-  data.tar.gz: 0b6223275fa9dc3b21e31ad1a0975457e3214351aa4b008cd1e894ef51bd2fca60e60159a42f9c55f9d5ce49da8fd487502b7d4ce3991891ba6c452e6ecf5899
+  metadata.gz: 6850ff73905c72cd22587c2c19d93cf97bc7eebd6543c33e5094e996e2e6e416499a85db1f482ccc37363a4aaa100a2d8f7409480d1b2b0376451a8945d2877d
+  data.tar.gz: 863dc96cd733cec7966a58d21ce8d9c1c8123850743975983fb630d4b71d94ef1a9267c3d436e0800eabbe751c10532a95413e3b2a10184c213b3ec763b084bb

data/Gemfile.lock

@@ -1,12 +1,19 @@
 PATH
   remote: .
   specs:
-    t_algebra (0.1.1)
+    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,16 +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|
-        street = y.yield { to_maybe(user.street) }
-        city = y.yield { to_maybe(user.city) }
-        state = y.yield { to_maybe(user.state) }
+    TAlgebra::Monad::Maybe.chain do
+        m_user = just(user)
+        
+        street = bound { m_user.fetch(:street) }
+        city = bound { m_user.fetch(:city) }
+        state = bound { m_user.fetch(:state) }
         "#{street}, #{city} #{state.upcase}"
     end
 end
@@ -64,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 }
@@ -96,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
@@ -121,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
@@ -17,16 +17,18 @@ module TAlgebra
         end
       end
 
-      def fmap(&block)
-        return dup if left? || !block
+      def fmap
+        raise UseError.new("#fmap requires a block") unless block_given?
+        return dup if left?
 
         self.class.pure(yield(value))
       end
 
-      def bind(&block)
-        return dup if left? || !block
+      def bind
+        raise UseError.new("#bind requires a block") unless block_given?
+        return dup if left?
 
-        self.class.instance_exec(value, &block)
+        yield value
       end
 
       def left?
@@ -37,7 +39,12 @@ module TAlgebra
         is == RIGHT
       end
 
+      def from_either!
+        from_either { |e| raise UnsafeError.new("#from_either! exception. #{e}") }
+      end
+
       def from_either
+        raise UseError.new("#from_either called without block") unless block_given?
         return yield(value) if left?
         value
       end

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
@@ -39,11 +39,24 @@ module TAlgebra
         is == JUST
       end
 
+      def from_maybe!
+        from_maybe { |e| raise UnsafeError.new("#from_maybe! exception. #{e}") }
+      end
+
       def from_maybe
+        raise UseError.new("#from_maybe called without block") unless block_given?
         return yield if nothing?
         value
       end
 
+      def fetch(key)
+        bind do |o|
+          self.class.to_maybe(
+            o.respond_to?(:[]) ? o[key] : o.send(key)
+          )
+        end
+      end
+
       def ==(other)
         to_obj == other.to_obj
       end

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)
@@ -10,38 +10,44 @@ module TAlgebra
 
       class << self
         def failure(msg, name = nil)
-          left(msg).with_name(name)
+          new(is: Either::LEFT, value: msg, name: name)
         end
 
         def parse(val, name = nil)
-          right(val).with_name(name)
+          new(is: Either::RIGHT, value: val, name: name)
         end
 
         def fetch(o, key)
-          parser = parse(o.respond_to?(:[]) ? o[key] : o.send(key))
-          parser.with_name(key).optional
+          parse(o).fetch(key)
         end
 
         def fetch!(o, key)
-          parser = parse(o.respond_to?(:[]) ? o[key] : o.send(key))
-          parser.with_name(key).required
+          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)
         end
       end
 
+      alias_method :valid?, :right?
+      alias_method :failure?, :left?
+
       attr_reader :name
       def with_name(name)
         @name = name
         self
       end
 
-      alias_method :valid?, :right?
-      alias_method :failure?, :left?
+      def fetch(key)
+        with_name(key).fmap { |o| o.respond_to?(:[]) ? o[key] : o.send(key) }.optional
+      end
+
+      def fetch!(key)
+        with_name(key).fmap { |o| o.respond_to?(:[]) ? o[key] : o.send(key) }.required
+      end
 
       def fmap
         super.with_name(name)
@@ -63,7 +69,7 @@ module TAlgebra
 
       def validate(msg = "Invalid")
         n = name
-        bind { |val| yield(val) ? parse(val, n) : failure(msg, n) }
+        bind { |val| yield(val) ? Parser.parse(val, n) : Parser.failure(msg, n) }
       end
 
       def extract_parsed(&block)
@@ -71,6 +77,10 @@ module TAlgebra
         from_either(&block)
       end
 
+      def extract_parsed!
+        extract_parsed { |e| raise UnsafeError.new("#extract_parsed! exception. #{e}") }
+      end
+
       def required
         validate("Is required") { |v| !v.nil? }
       end

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,65 +7,58 @@ 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 augmented_receiver(block)
+        block_self = block.binding.receiver
+
+        self_class = self
+        block_self.define_singleton_method(:method_missing) do |m, *args, &block|
+          self_class.send(m, *args, &block)
+        end
 
-      def run(&block)
-        e = Enumerator.new { |y| instance_exec(LazyYielder.new(y), &block) }
-        run_recursive(e, [])
+        block_self
       end
 
-      def run_bind(ma)
+      def chain_bind(ma, &block)
         raise "Yield blocks must return instances of #{self}" unless ma.instance_of?(self)
-        ma.bind
+        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)
-          pure(value(enum))
+        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.2"
+  VERSION = "0.1.6"
 end

data/lib/t_algebra.rb

@@ -2,6 +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/single_valued"
 require_relative "t_algebra/monad/maybe"
 require_relative "t_algebra/monad/either"
 require_relative "t_algebra/monad/list"
@@ -9,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.2
+  version: 0.1.6
 platform: ruby
 authors:
 - aaron
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-12-06 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
@@ -37,6 +65,7 @@ files:
 - 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