kleisli 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3542c8f4abc331bb9a9d47170b22392146489666
+  data.tar.gz: 4381c9631f3205faffc3a3764340d3ce2c623041
+SHA512:
+  metadata.gz: 52389420ffa39afd4fcb73731e95301d9258374e26f85afd1e467330cc61764d5b7c9989d0ef7309948cbc2134237ee5a8970325028f2fea67281b56ac8eb584
+  data.tar.gz: bf55220e96e5649b079588c661d2e7ff430197c8964bfa75971d78b7937fd29a29ae3b6a6e98c1b235d82b5490bd9eb97e4ff0baa4f4f17dffd91e360be66364

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in kleisli.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Josep M. Bach
+
+MIT License
+
+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,275 @@
+# Kleisli
+
+An idiomatic, clean implementation of a few common useful monads in Ruby, written by [Ryan Levick][rylev] and me.
+
+It aims to be idiomatic Ruby to use in real app, not a proof of concept.
+
+In your Gemfile:
+
+```ruby
+gem 'kleisli'
+```
+
+We would like to thank Curry and Howard for their correspondence.
+
+## Notation
+
+For all its monads, Kleisli implements `return` (we call it `lift` instead, as `return` is a reserved keyword in Ruby) with convenience global methods (see which for each monad below).
+
+Kleisli uses a clever Ruby syntax trick to implement the `bind` operator, which looks like this: `>->`. We will probably burn in hell for this.
+
+## Maybe monad
+
+The Maybe monad is useful to express a pipeline of computations that might
+return nil at any point. `user.address.street` anyone?
+
+### `>->` (bind)
+
+```ruby
+require "kleisli"
+
+maybe_user = Maybe(user) >-> user {
+  Maybe(user.address) } >-> address {
+    Maybe(address.street) }
+
+# If user exists
+# => Some("Monad Street")
+# If user is nil
+# => None()
+
+# You can also use Some and None as type constructors yourself.
+x = Some(10)
+y = None()
+```
+
+### `fmap`
+
+```ruby
+require "kleisli"
+
+# If we know that a user always has an address with a street
+Maybe(user).fmap(&:address).fmap(&:street)
+
+# If the user exists
+# => Some("Monad Street")
+# If the user is nil
+# => None()
+```
+
+## Try
+
+The Try monad is useful to express a pipeline of computations that might throw
+an exception at any point.
+
+### `>->` (bind)
+
+```ruby
+require "kleisli"
+
+json_string = get_json_from_somewhere
+
+result = Try { JSON.parse(json_string) } >-> json {
+  Try { json["dividend"].to_i / json["divisor"].to_i }
+}
+
+# If no exception was thrown:
+
+result       # => #<Try::Success @value=123>
+result.value # => 123
+
+# If there was a ZeroDivisionError exception for example:
+
+result           # => #<Try::Failure @exception=#<ZeroDivisionError ...>>
+result.exception # => #<ZeroDivisionError ...>
+```
+
+### `fmap`
+
+```ruby
+require "kleisli"
+
+Try { JSON.parse(json_string) }.fmap(&:symbolize_keys).value
+
+# If everything went well:
+# => { :my => "json", :with => "symbolized keys" }
+# If an exception was thrown:
+# => nil
+```
+
+### `to_maybe`
+
+Sometimes it's useful to interleave both `Try` and `Maybe`. To convert a `Try`
+into a `Maybe` you can use `to_maybe`:
+
+```ruby
+require "kleisli"
+
+Try { JSON.parse(json_string) }.fmap(&:symbolize_keys).to_maybe
+
+# If everything went well:
+# => Some({ :my => "json", :with => "symbolized keys" })
+# If an exception was thrown:
+# => None()
+```
+
+## Either
+
+The Either monad is useful to express a pipeline of computations that might return an error object with some information.
+
+It has two type constructors: `Right` and `Left`. As a useful mnemonic, `Right` is for when everything went "right" and `Left` is used for errors.
+
+Think of it as exceptions without messing with the call stack.
+
+### `>->` (bind)
+
+```ruby
+require "kleisli"
+
+result = Right(3) >-> value {
+  if value > 1
+    Right(value + 3)
+  else
+    Left("value was less or equal than 1")
+  end
+} >-> value {
+  if value % 2 == 0
+    Right(value * 2)
+  else
+    Left("value was not even")
+  end
+}
+
+# If everything went well
+result # => Right(12)
+result.value # => 12
+
+# If it failed in the first block
+result # => Left("value was less or equal than 1")
+result.value # => "value was less or equal than 1"
+
+# If it failed in the second block
+result # => Left("value was not even")
+result.value # => "value was not even"
+```
+
+### `fmap`
+
+```ruby
+require "kleisli"
+
+result = if foo > bar
+  Right(10)
+else
+  Left("wrong")
+end.fmap { |x| x * 2 }
+
+# If everything went well
+result # => Right(20)
+# If it didn't
+result # => Left("wrong")
+```
+
+### `to_maybe`
+
+Sometimes it's useful to turn an `Either` into a `Maybe`. You can use
+`to_maybe` for that:
+
+```ruby
+require "kleisli"
+
+result = if foo > bar
+  Right(10)
+else
+  Left("wrong")
+end.to_maybe
+
+# If everything went well:
+result # => Some(10)
+# If it didn't
+result # => None()
+```
+
+## Writer
+
+The Writer monad is arguably the least useful monad in Ruby (as side effects
+are uncontrolled), but let's take a look at it anyway.
+
+It is used to model computations that *append* to some kind of state (which
+needs to be a Monoid, expressed in the `Kleisli::Monoid` mixin) at each step.
+
+(We've already implemented the Monoid interface for `String`, `Array`, `Hash`,
+`Fixnum` and `Float` for you.)
+
+An example would be a pipeline of computations that append to a log, for
+example a list of strings.
+
+### `>->` (bind)
+
+```ruby
+require "kleisli"
+
+writer = Writer([], 100) >-> value {
+  Writer(["added 100"], value + 100)
+} >-> value {
+  Writer(["added 140 more"], value + 140)
+} # => Writer(["added 100", "added 140 more"], 340)
+
+log, value = writer.unwrap
+log # => ["added 100", "added 140 more"]
+value # => 340
+```
+
+### `fmap`
+
+```ruby
+require "kleisli"
+
+writer = Writer([], 100).fmap { |value|
+  value + 100
+} # => Writer([], 200)
+```
+
+## Future
+
+The Future monad models a pipeline of computations that will happen in the future, as soon as the value needed for each step is available. It is useful to model, for example, a sequential chain of HTTP calls.
+
+### `>->` (bind)
+
+```ruby
+require "kleisli"
+
+f = Future("myendpoint.com") >-> url {
+  Future { HTTP.get(url.call) }
+} >-> response {
+  Future {
+    other_url = JSON.parse(response.call.body)[:other_url]
+    HTTP.get(other_url)
+  }
+} >-> other_response {
+  Future { JSON.parse(other_response.call.body) }
+}
+
+# Do some other stuff...
+
+f.await # => block until the whole pipeline is realized
+# => { "my" => "response body" }
+```
+
+### `fmap`
+
+```ruby
+require "kleisli"
+
+Future { expensive_operation }.fmap { |x| x * 2 }.await
+# => result of expensive_operation * 2
+```
+
+## Who's this
+
+This was made by [Josep M. Bach (Txus)](http://blog.txus.io) and [Ryan
+Levick][rylev] under the MIT license. We are [@txustice][twitter] and
+[@itchyankles][itchyankles] on twitter (where you should probably follow us!).
+
+[twitter]: https://twitter.com/txustice
+[itchyankles]: https://twitter.com/itchyankles
+[rylev]: https://github.com/rylev

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/*.rb']
+  t.verbose = true
+end
+
+task :default => :test

data/kleisli.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kleisli/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "kleisli"
+  spec.version       = Kleisli::VERSION
+  spec.authors       = ["Josep M. Bach", "Ryan Levick"]
+  spec.email         = ["josep.m.bach@gmail.com", "ryan.levick@gmail.com"]
+  spec.summary       = %q{Usable, idiomatic common monads in Ruby}
+  spec.description   = %q{Usable, idiomatic common monads in Ruby}
+  spec.homepage      = "https://github.com/txus/kleisli"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/kleisli.rb

@@ -0,0 +1,9 @@
+require "kleisli/version"
+require "kleisli/maybe"
+require "kleisli/try"
+require "kleisli/writer"
+require "kleisli/future"
+require "kleisli/either"
+
+module Kleisli
+end

data/lib/kleisli/either.rb

@@ -0,0 +1,60 @@
+require 'kleisli/monad'
+require 'kleisli/maybe'
+
+module Kleisli
+  class Either < Monad
+    attr_reader :right, :left
+
+    def ==(other)
+      right == other.right && left == other.left
+    end
+
+    class Right < Either
+      alias value right
+
+      def initialize(right)
+        @right = right
+      end
+
+      def >(f)
+        f.call(@right)
+      end
+
+      def fmap(&f)
+        Right.new(f.call(@right))
+      end
+
+      def to_maybe
+        Maybe::Some.new(@right)
+      end
+    end
+
+    class Left < Either
+      alias value left
+
+      def initialize(left)
+        @left = left
+      end
+
+      def >(f)
+        self
+      end
+
+      def fmap(&f)
+        self
+      end
+
+      def to_maybe
+        Maybe::None.new
+      end
+    end
+  end
+end
+
+def Right(v)
+  Kleisli::Either::Right.new(v)
+end
+
+def Left(v)
+  Kleisli::Either::Left.new(v)
+end

data/lib/kleisli/functor.rb

@@ -0,0 +1,7 @@
+module Kleisli
+  class Functor
+    def fmap(&f)
+      raise NotImplementedError, "this functor doesn't implement fmap"
+    end
+  end
+end

data/lib/kleisli/future.rb

@@ -0,0 +1,33 @@
+require 'kleisli/monad'
+
+module Kleisli
+  class Future < Monad
+    def self.lift(v=nil, &block)
+      if block
+        new(Thread.new(&block))
+      else
+        new(Thread.new { v })
+      end
+    end
+
+    def initialize(t)
+      @t = t
+    end
+
+    def >(f)
+      f.call(-> { await })
+    end
+
+    def fmap(&f)
+      Future.lift(f.call(-> { await }))
+    end
+
+    def await
+      @t.join.value
+    end
+  end
+end
+
+def Future(v=nil, &block)
+  Kleisli::Future.lift(v, &block)
+end

data/lib/kleisli/maybe.rb

@@ -0,0 +1,55 @@
+require 'kleisli/monad'
+
+module Kleisli
+  class Maybe < Monad
+    attr_reader :value
+
+    def self.lift(value)
+      if value.nil?
+        None.new
+      else
+        Some.new(value)
+      end
+    end
+
+    def ==(other)
+      value == other.value
+    end
+
+    class None < Maybe
+      def fmap(&f)
+        self
+      end
+
+      def >(block)
+        self
+      end
+    end
+
+    class Some < Maybe
+      def initialize(value)
+        @value = value
+      end
+
+      def fmap(&f)
+        Maybe.lift(f.call(@value))
+      end
+
+      def >(block)
+        block.call(@value)
+      end
+    end
+  end
+end
+
+def Maybe(v)
+  Kleisli::Maybe.lift(v)
+end
+
+def None()
+  Maybe(nil)
+end
+
+def Some(v)
+  Maybe(v)
+end

data/lib/kleisli/monad.rb

@@ -0,0 +1,9 @@
+require "kleisli/functor"
+
+module Kleisli
+  class Monad < Functor
+    def >(block)
+      raise NotImplementedError, "this monad doesn't implement >->"
+    end
+  end
+end

data/lib/kleisli/monoid.rb

@@ -0,0 +1,65 @@
+module Kleisli
+  module Monoid
+    def fold(others)
+      others.reduce(self) { |acc, x| acc.mappend x }
+    end
+
+    def mempty
+      raise NotImplementedError, "this monoid doesn't implement mpemty"
+    end
+
+    def mappend(other)
+      raise NotImplementedError, "this monoid doesn't implement mappend"
+    end
+  end
+end
+
+String.class_eval do
+  include Kleisli::Monoid
+
+  def mempty
+    ""
+  end
+
+  alias mappend +
+end
+
+Array.class_eval do
+  include Kleisli::Monoid
+
+  def mempty
+    []
+  end
+
+  alias mappend +
+end
+
+Hash.class_eval do
+  include Kleisli::Monoid
+
+  def mempty
+    {}
+  end
+
+  alias mappend merge
+end
+
+Fixnum.class_eval do
+  include Kleisli::Monoid
+
+  def mempty
+    0
+  end
+
+  alias mappend +
+end
+
+Float.class_eval do
+  include Kleisli::Monoid
+
+  def mempty
+    0
+  end
+
+  alias mappend +
+end

data/lib/kleisli/try.rb

@@ -0,0 +1,56 @@
+require 'kleisli/monad'
+require 'kleisli/maybe'
+
+module Kleisli
+  class Try < Monad
+    attr_reader :exception, :value
+
+    def self.lift(f)
+      Success.new(f.call)
+    rescue => e
+      Failure.new(e)
+    end
+
+    class Success < Try
+      def initialize(value)
+        @value = value
+      end
+
+      def >(f)
+        f.call(@value)
+      rescue => e
+        Failure.new(e)
+      end
+
+      def fmap(&f)
+        Try { f.call(@value) }
+      end
+
+      def to_maybe
+        Maybe::Some.new(@value)
+      end
+    end
+
+    class Failure < Try
+      def initialize(exception)
+        @exception = exception
+      end
+
+      def >(f)
+        self
+      end
+
+      def fmap(&f)
+        self
+      end
+
+      def to_maybe
+        Maybe::None.new
+      end
+    end
+  end
+end
+
+def Try(&f)
+  Kleisli::Try.lift(f)
+end

data/lib/kleisli/version.rb

@@ -0,0 +1,3 @@
+module Kleisli
+  VERSION = "0.0.1"
+end

data/lib/kleisli/writer.rb

@@ -0,0 +1,36 @@
+require 'kleisli/monad'
+require 'kleisli/monoid'
+
+module Kleisli
+  class Writer < Monad
+    def self.lift(log, value)
+      new(log, value)
+    end
+
+    def initialize(log, value)
+      @log, @value = log, value
+    end
+
+    def ==(other)
+      unwrap == other.unwrap
+    end
+
+    def >(f)
+      other_log, other_value = f.call(@value).unwrap
+      Writer.new(@log + other_log, other_value)
+    end
+
+    def fmap(&f)
+      new_value = f.call(@value)
+      Writer.new(@log, new_value)
+    end
+
+    def unwrap
+      [@log, @value]
+    end
+  end
+end
+
+def Writer(log, value)
+  Kleisli::Writer.lift(log, value)
+end

data/test/kleisli/either_test.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+
+class EitherTest < MiniTest::Unit::TestCase
+  def test_lift_right
+    assert_equal 3, Right(3).value
+  end
+
+  def test_lift_left
+    assert_equal "error", Left("error").value
+  end
+
+  def test_bind_right
+    v = Right(1) >-> x {
+      if x == 1
+        Right(x + 90)
+      else
+        Left("FAIL")
+      end
+    }
+    assert_equal Right(91), v
+  end
+
+  def test_bind_left
+    v = Left("error") >-> x {
+      Right(x * 20)
+    }
+    assert_equal Left("error"), v
+  end
+
+  def test_fmap_right
+    assert_equal Right(2), Right(1).fmap { |x| x * 2 }
+  end
+
+  def test_fmap_left
+    assert_equal Left("error"), Left("error").fmap { |x| x * 2 }
+  end
+
+  def test_to_maybe_right
+    assert_equal Some(2), Right(1).fmap { |x| x * 2 }.to_maybe
+  end
+
+  def test_to_maybe_left
+    assert_equal None(), Left("error").fmap { |x| x * 2 }.to_maybe
+  end
+end

data/test/kleisli/future_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class FutureTest < MiniTest::Unit::TestCase
+  def test_immediate_value
+    assert_equal 30, Future(30).await
+  end
+
+  def test_simple_future_executes_in_parallel
+    str = ""
+    Future { sleep 0.1; str << "bar" }.tap {
+      str << "foo"
+    }.await
+    assert_equal "foobar", str
+  end
+
+  def test_bind
+    f = Future(30) >-> n {
+      Future { n.call * 2 }
+    } >-> n {
+      Future { n.call * 2 } >-> m {
+        Future(m.call + 2)
+      }
+    }
+    assert_equal 122, f.await
+  end
+
+  def test_fmap
+    f = Future(30).fmap { |x| x.call * 2 }
+    assert_equal 60, f.await
+  end
+end

data/test/kleisli/maybe_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class MaybeTest < MiniTest::Unit::TestCase
+  def test_unwrapping_some
+    assert_equal 3, Some(3).value
+  end
+
+  def test_unwrapping_none
+    assert_equal nil, None().value
+  end
+
+  def test_bind_none
+    assert_equal None(), None() >-> x { Maybe(x * 2) }
+  end
+
+  def test_bind_some
+    assert_equal Some(6), Some(3) >-> x { Maybe(x * 2) }
+  end
+
+  def test_fmap_none
+    assert_equal None(), None().fmap { |x| x * 2 }
+  end
+
+  def test_fmap_some
+    assert_equal Some(6), Some(3).fmap { |x| x * 2 }
+  end
+end

data/test/kleisli/monoid_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+class MonoidTest < MiniTest::Unit::TestCase
+  def test_string_fold
+    assert_equal "hellogoodbye", "hello".fold(%w(good bye))
+  end
+
+  def test_array_fold
+    assert_equal [1, 2, 3], [1].fold([[2], [3]])
+  end
+
+  def test_hash_fold
+    assert_equal({a: 1, b: 2, c: 3}, {a: 1}.fold([{b: 2}, {c: 3}]))
+  end
+
+  def test_fixnum_fold
+    assert_equal 6, 1.fold([2,3])
+  end
+
+  def test_float_fold
+    assert_equal 6.0, 1.0.fold([2.0,3.0])
+  end
+end

data/test/kleisli/try_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class TryTest < MiniTest::Unit::TestCase
+  def test_success
+    assert_equal 2, Try { 10 / 5 }.value
+  end
+
+  def test_failure
+    assert_kind_of ZeroDivisionError, Try { 10 / 0 }.exception
+  end
+
+  def test_to_maybe_success
+    assert_equal Some(2), Try { 10 / 5 }.to_maybe
+  end
+
+  def test_to_maybe_failure
+    assert_equal None(), Try { 10 / 0 }.to_maybe
+  end
+
+  def test_fmap_success
+    assert_equal 4, Try { 10 / 5 }.fmap { |x| x * 2 }.value
+  end
+
+  def test_fmap_failure
+    assert_kind_of ZeroDivisionError, Try { 10 / 0 }.fmap { |x| x * 2 }.exception
+  end
+end

data/test/kleisli/writer_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+class WriterTest < MiniTest::Unit::TestCase
+  def test_unwrap
+    log, value = Writer("log", 100).unwrap
+    assert_equal "log", log
+    assert_equal 100, value
+  end
+
+  def test_bind
+    writer = Writer("foo", 100) >-> value { Writer("bar", value + 100) }
+    assert_equal Writer("foobar", 200), writer
+  end
+
+  def test_fmap
+    writer = Writer("foo", 100).fmap { |value| value + 100 }
+    assert_equal Writer("foo", 200), writer
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'kleisli'
+require 'test/unit'

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: kleisli
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Josep M. Bach
+- Ryan Levick
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Usable, idiomatic common monads in Ruby
+email:
+- josep.m.bach@gmail.com
+- ryan.levick@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- kleisli.gemspec
+- lib/kleisli.rb
+- lib/kleisli/either.rb
+- lib/kleisli/functor.rb
+- lib/kleisli/future.rb
+- lib/kleisli/maybe.rb
+- lib/kleisli/monad.rb
+- lib/kleisli/monoid.rb
+- lib/kleisli/try.rb
+- lib/kleisli/version.rb
+- lib/kleisli/writer.rb
+- test/kleisli/either_test.rb
+- test/kleisli/future_test.rb
+- test/kleisli/maybe_test.rb
+- test/kleisli/monoid_test.rb
+- test/kleisli/try_test.rb
+- test/kleisli/writer_test.rb
+- test/test_helper.rb
+homepage: https://github.com/txus/kleisli
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Usable, idiomatic common monads in Ruby
+test_files:
+- test/kleisli/either_test.rb
+- test/kleisli/future_test.rb
+- test/kleisli/maybe_test.rb
+- test/kleisli/monoid_test.rb
+- test/kleisli/try_test.rb
+- test/kleisli/writer_test.rb
+- test/test_helper.rb