t_algebra 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 89594acf3cdd9218fe50f860b61da46dd2c5455acc7fa8164eaf7a2ff1a71235
+  data.tar.gz: d16301f3a688e0bceb6c83221fd8a8c33f9116a2e1cf9c68e9b2b6aa3b71347e
+SHA512:
+  metadata.gz: 61d5e80838234214bdb56c0a72b91e03a3fcf1679f8a7f8914f9731868f0dccab1c47cf2a8ba857d861b1634903cc5733874786604e5dc04708db351224e6c60
+  data.tar.gz: 422676bbe62f022fba90309180cfbb243f5197d9b1527aaa691e1b1646cd74178f2892bd1047fa347b53a83ca19b30d983e3377d4b07574ec098c4b9bf76e5c4

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.idea
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.7.4
+before_install: gem install bundler -v 2.1.4

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at afg419@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [https://contributor-covenant.org/version/1/4][version]
+
+[homepage]: https://contributor-covenant.org
+[version]: https://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in t_algebra.gemspec
+gemspec
+
+gem "rake", "~> 12.0"
+gem "rspec", "~> 3.0"

data/Gemfile.lock

@@ -0,0 +1,34 @@
+PATH
+  remote: .
+  specs:
+    t_algebra (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.4.4)
+    rake (12.3.3)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake (~> 12.0)
+  rspec (~> 3.0)
+  t_algebra!
+
+BUNDLED WITH
+   2.1.4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 aaron
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,151 @@
+# TAlgebra
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 't_algebra'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install t_algebra
+
+## Usage
+
+t_algebra brings the basic categorical concepts of Functor, Applicative, and Monad into ruby, along with a handful of common instances. 
+
+Let's walk through `TAlgebra::Monad::Maybe`, the monad representing optional results. Typically in ruby we have a method
+which may return a value or nil should some underlying data be absent. For example `user.city` may return `nil` should the
+user not have entered their city. Working with these possible `nil` values can be a source of bugs and a source of code
+complexity. The following code is illustrative:
+
+```
+# @return [String, nil]
+def get_address(user)
+    street = user.street
+    return unless street
+    
+    city = user.city
+    return unless city
+    
+    state = user.state
+    return unless state
+    state = state.upcase
+
+    "#{street}, #{city} #{state}" if street && city && state 
+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`)
+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) }
+        "#{street}, #{city} #{state.upcase}"
+    end
+end
+```
+
+This basic Maybe functionality extends neatly into the `Either` monad, the monad representing results or errors, and
+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|
+        # validate street is present with `#fetch!`
+        street = y.yield { fetch!(user, :street) }
+        
+        # validate that the city is a string with is `#is_a?`
+        city = y.yield { 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 
+            fetch!(user, :state)
+                .is_a?(String)
+                .validate("Is 2 letter code"){ |state| state.length == 2 }
+                .fmap(&:upcase)
+        end
+        "#{street}, #{city} #{state}"
+    end
+end
+```
+
+### Defining your own examples
+
+Say we had a class `ExtAPI` representing a an external api result or http error. (Similar to the Either monad.) We could implement this as a monad as 
+follows:
+
+```
+class ExtAPI
+    include TAlgebra::Monad
+    
+    class << self
+        def call(verb, path)
+            ... make api cal
+        rescue => e
+            new(http_error: {e.status, e.message})
+        end
+            
+        #Implement Applicative's `.pure` interface
+        def pure(a)
+            new(success: a)        
+        end
+    end
+    
+    #Implement Monad's `#bind` interface
+    def bind
+        return new(http_error: http_error) if http_error
+        yield(success)
+    end
+    
+    ...
+end
+```
+
+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}" } 
+        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.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/t_algebra. 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/[USERNAME]/t_algebra/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).
+
+## Code of Conduct
+
+Everyone interacting in the TAlgebra project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/afg419/t_algebra/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "t_algebra/algebra"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't_algebra forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/t_algebra/applicative.rb

@@ -0,0 +1,53 @@
+# @abstract
+module TAlgebra
+  module Applicative
+    module Static
+      def pure(_)
+        raise "Implement .pure in extending class"
+      end
+
+      def lift_a2(_fa, _fb, &_block)
+        raise "Implement .lift_a2 in extending class"
+      end
+
+      def seq_a(*array_of_parsers, **hash_of_parsers)
+        return sequence_array(array_of_parsers) unless array_of_parsers.empty?
+
+        sequence_hash(hash_of_parsers) unless hash_of_parsers.empty?
+      end
+
+      # @param [Array<Applicative>] fbs
+      # @return [Applicative<Array>]
+      def sequence_array(fbs)
+        return pure([]) if fbs.empty?
+
+        fbs.reduce(pure([])) do |prev, fb|
+          lift_a2(prev, fb) do |p, b|
+            p + [b]
+          end
+        end
+      end
+
+      # @param [Hash<Any, Applicative>] fbs
+      # @return [Applicative<Hash>]
+      def sequence_hash(fbs)
+        return pure({}) if fbs.empty?
+
+        fbs.reduce(pure({})) do |prev, (k, fb)|
+          lift_a2(prev, fb) do |p, b|
+            p.merge(k => b)
+          end
+        end
+      end
+    end
+
+    class << self
+      def included(base)
+        base.class_eval do
+          include TAlgebra::Functor
+        end
+        base.extend(Static)
+      end
+    end
+  end
+end

data/lib/t_algebra/functor.rb

@@ -0,0 +1,7 @@
+module TAlgebra
+  module Functor
+    def fmap(&block)
+      raise "implement #fmap in extending class"
+    end
+  end
+end

data/lib/t_algebra/monad/either.rb

@@ -0,0 +1,67 @@
+module TAlgebra
+  module Monad
+    class Either
+      include TAlgebra::Monad
+
+      LEFT = :left
+      RIGHT = :right
+
+      class << self
+        def pure(value)
+          new(is: RIGHT, value: value)
+        end
+        alias_method :right, :pure
+
+        def left(err)
+          new(is: LEFT, value: err)
+        end
+      end
+
+      def fmap(&block)
+        return dup if left? || !block
+
+        self.class.pure(yield(value))
+      end
+
+      def bind(&block)
+        return dup if left? || !block
+
+        self.class.instance_exec(value, &block)
+      end
+
+      def left?
+        is == LEFT
+      end
+
+      def right?
+        is == RIGHT
+      end
+
+      def from_either
+        return yield(value) if left?
+        value
+      end
+
+      def ==(other)
+        to_obj == other.to_obj
+      end
+
+      def to_obj
+        {is.to_s => value, :class => self.class.name}
+      end
+
+      private
+
+      attr_reader :is, :value
+
+      def initialize(is:, value:)
+        @is = is
+        @value = value
+      end
+
+      def dup
+        self.class.new(is: is, value: value)
+      end
+    end
+  end
+end

data/lib/t_algebra/monad/list.rb

@@ -0,0 +1,40 @@
+module TAlgebra
+  module Monad
+    class List
+      include TAlgebra::Monad
+
+      class << self
+        alias_method :pure, :new
+      end
+
+      def fmap(&block)
+        self.class.pure(
+          *values.map { |l| yield(l) }
+        )
+      end
+
+      def bind(&block)
+        self.class.pure(
+          *values.reduce([]) do |acc, l|
+            acc.concat(block.call(l).send(:values))
+          end
+        )
+      end
+
+      def from_list
+        values
+      end
+
+      def ==(other)
+        from_list == other.from_list
+      end
+
+      private
+
+      attr_reader :values
+      def initialize(*values)
+        @values = values || []
+      end
+    end
+  end
+end

data/lib/t_algebra/monad/maybe.rb

@@ -0,0 +1,68 @@
+module TAlgebra
+  module Monad
+    class Maybe
+      include TAlgebra::Monad
+
+      NOTHING = :nothing
+      JUST = :just
+
+      class << self
+        def pure(value)
+          new(is: JUST, value: value)
+        end
+        alias_method :just, :pure
+
+        def nothing
+          new(is: NOTHING)
+        end
+
+        def to_maybe(value_or_nil)
+          value_or_nil.nil? ? nothing : pure(value_or_nil)
+        end
+      end
+
+      def fmap(&block)
+        return dup if nothing? || !block
+        self.class.just(yield(value))
+      end
+
+      def bind(&block)
+        return dup if nothing? || !block
+        yield value
+      end
+
+      def nothing?
+        is == NOTHING
+      end
+
+      def just?
+        is == JUST
+      end
+
+      def from_maybe
+        return yield if nothing?
+        value
+      end
+
+      def ==(other)
+        to_obj == other.to_obj
+      end
+
+      def to_obj
+        {is.to_s => value, :class => self.class.name}
+      end
+
+      private
+
+      attr_reader :is, :value
+      def initialize(is:, value: nil)
+        @is = is
+        @value = value
+      end
+
+      def dup
+        self.class.new(is: is, value: value)
+      end
+    end
+  end
+end

data/lib/t_algebra/monad/parser.rb

@@ -0,0 +1,101 @@
+module TAlgebra
+  module Monad
+    class Parser < Either
+      include TAlgebra::Monad
+
+      def initialize(is:, value:, name: nil)
+        super(is: is, value: value)
+        @name = name
+      end
+
+      class << self
+        def failure(msg, name = nil)
+          left(msg).with_name(name)
+        end
+
+        def parse(val, name = nil)
+          right(val).with_name(name)
+        end
+
+        def fetch(o, key)
+          parser = parse(o.respond_to?(:[]) ? o[key] : o.send(key))
+          parser.with_name(key).optional
+        end
+
+        def fetch!(o, key)
+          parser = parse(o.respond_to?(:[]) ? o[key] : o.send(key))
+          parser.with_name(key).required
+        end
+      end
+
+      attr_reader :name
+      def with_name(name)
+        @name = name
+        self
+      end
+
+      alias_method :valid?, :right?
+      alias_method :failure?, :left?
+
+      def fmap
+        super.with_name(name)
+      rescue => e
+        self.class.failure("Unable to fmap: #{e}", name)
+      end
+
+      def bind
+        super
+      rescue => e
+        self.class.failure("Unable to bind: #{e}", name)
+      end
+
+      def is_a?(*klasses)
+        validate("Must be type #{klasses.join(", ")}") do |v|
+          klasses.any? { |k| v.is_a?(k) }
+        end
+      end
+
+      def validate(msg = "Invalid")
+        n = name
+        bind { |val| yield(val) ? parse(val, n) : failure(msg, n) }
+      end
+
+      def extract_parsed(&block)
+        return yield("#{name}: #{value}") if left? && !name.nil?
+        from_either(&block)
+      end
+
+      def required
+        validate("Is required") { |v| !v.nil? }
+      end
+
+      def optional
+        Optional.new(is: is, value: value, name: name)
+      end
+
+      class Optional < Parser
+        def bind(&block)
+          return dup if failure? || value.nil?
+
+          required.bind(&block).optional
+        end
+
+        def fmap(&block)
+          return dup if failure? || value.nil?
+
+          required.fmap(&block).optional
+        end
+
+        def required
+          Parser.new(is: is, value: value, name: name).required
+        end
+      end
+
+      private
+
+      def dup
+        self.class.new(is: is, value: value, name: name)
+      end
+    end
+  end
+end

data/lib/t_algebra/monad/reader.rb

@@ -0,0 +1,42 @@
+module TAlgebra
+  module Monad
+    class Reader
+      include TAlgebra::Monad
+
+      class << self
+        def pure(a)
+          new { a }
+        end
+
+        def ask
+          new { |r| r }
+        end
+      end
+
+      def fmap(&a_to_b)
+        Reader.new(&(r_to_a >> a_to_b))
+      end
+
+      def bind(&a_to_mb)
+        Reader.new do |r|
+          (r_to_a >> a_to_mb).call(r).run_reader(r)
+        end
+      end
+
+      def run_reader(r)
+        r_to_a.call(r)
+      end
+
+      private
+
+      attr_reader :r_to_a
+      def initialize(&r_to_a)
+        @r_to_a = r_to_a
+      end
+
+      def dup
+        self.class.new(&r_to_a)
+      end
+    end
+  end
+end

data/lib/t_algebra/monad.rb

@@ -0,0 +1,74 @@
+# @abstract
+module TAlgebra
+  module Monad
+    def bind(&block)
+      raise "Implement #bind in extending class"
+    end
+
+    module Static
+      class LazyYielder
+        def initialize(yielder)
+          @yielder = yielder
+        end
+
+        def yield(&block)
+          @yielder.yield(block)
+        end
+      end
+
+      def run(&block)
+        e = Enumerator.new { |y| instance_exec(LazyYielder.new(y), &block) }
+        run_recursive(e, [])
+      end
+
+      def lift_a2(ma, mb, &block)
+        ma.bind do |a|
+          mb.bind do |b|
+            pure(block.call(a, b))
+          end
+        end
+      end
+
+      private
+
+      def run_recursive(enum, historical_values)
+        enum.rewind
+
+        historical_values.each do |h|
+          enum.next
+          enum.feed(h)
+        end
+
+        if is_complete(enum)
+          pure(value(enum))
+        else
+          enum.next.call.bind do |a|
+            run_recursive(enum, historical_values + [a])
+          end
+        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
+      def included(base)
+        base.class_eval do
+          include TAlgebra::Applicative
+        end
+        base.extend(Static)
+      end
+    end
+  end
+end

data/lib/t_algebra/version.rb

@@ -0,0 +1,3 @@
+module TAlgebra
+  VERSION = "0.1.0"
+end

data/lib/t_algebra.rb

@@ -0,0 +1,13 @@
+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/maybe"
+require_relative "t_algebra/monad/either"
+require_relative "t_algebra/monad/list"
+require_relative "t_algebra/monad/reader"
+require_relative "t_algebra/monad/parser"
+
+module TAlgebra
+  class Error < StandardError; end
+end

data/t_algebra.gemspec

@@ -0,0 +1,28 @@
+require_relative "lib/t_algebra/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "t_algebra"
+  spec.version = TAlgebra::VERSION
+  spec.authors = ["aaron"]
+  spec.email = ["afg419@gmail.com"]
+
+  spec.summary = "Functor, Applicative, and Monad interfaces for Ruby"
+  spec.homepage = "https://github.com/afg419/t_algebra"
+  spec.license = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/afg419/t_algebra"
+  spec.metadata["changelog_uri"] = "https://example.com"
+
+  # 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
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: t_algebra
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- aaron
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-12-06 00:00:00.000000000 Z
+dependencies: []
+description:
+email:
+- afg419@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/t_algebra.rb
+- lib/t_algebra/applicative.rb
+- lib/t_algebra/functor.rb
+- lib/t_algebra/monad.rb
+- lib/t_algebra/monad/either.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/version.rb
+- t_algebra.gemspec
+homepage: https://github.com/afg419/t_algebra
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/afg419/t_algebra
+  source_code_uri: https://github.com/afg419/t_algebra
+  changelog_uri: https://example.com
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: Functor, Applicative, and Monad interfaces for Ruby
+test_files: []