kleisli 0.0.6 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
---- 
-SHA1: 
-  metadata.gz: 54cce46f431f0930414953f5d860ab9805f8aa38
-  data.tar.gz: 03b56b5e9209404852e50d3a1ff639173efd82ff
-SHA512: 
-  metadata.gz: ca6dabae528183053604cf6adccf3a621e96d25fc5171d507113eeb5aaf2c7349cc21bceefe4e053275f62093381b3b737927cf76234ab63de3bbb3b0e03385d
-  data.tar.gz: 1f19da23d4ca766b1c8b16323863fb750b197c0e84602d0b4b34f6316bc7bb3fc171d8ae868e5bb023b978801890be7d95a5b2efc6cf399bf78dd28d5a072698
+---
+SHA1:
+  metadata.gz: faefce7df113e758631337927c7a3ec32f0305ff
+  data.tar.gz: 6e583da161293e7c603163f24dfd6af293c5445b
+SHA512:
+  metadata.gz: 24c366c7151184fb84fc42938f4afd1473e75575ff82c7e0ee5255b44bcef9f1ec028c10bd0ac19d84635b6b9ef53c7b6332f8e5e048df2ed9d73833482ca12c
+  data.tar.gz: b8d1ad6965cfe41ddf33e72af50ac7d4cfbc62b07aa23873625af8981c78a35f5a271aeea14929a76a1894fb26860faba1867af02f5d1c340368815cdf2d28bc

data/README.md

@@ -47,11 +47,9 @@ f.call "hello"
 Functions and methods are interchangeable:
 
 ```ruby
-def foo(s)
-  s.reverse
-end
+foo = lambda { |s| s.reverse }
 
-f = F . capitalize . foo
+f = F . capitalize . fn(&foo)
 f.call "hello"
 # => "Olleh"
 ```
@@ -60,11 +58,24 @@ All functions and methods are partially applicable:
 
 ```ruby
 
+# Partially applied method:
 f = F . split(":") . strip
-puts f.call "  localhost:9092     "
+f.call "  localhost:9092     "
+# => ["localhost", "9092"]
+
+# Partially applied lambda:
+my_split = lambda { |str, *args| str.split(*args) }
+f = F . fn(":", &split)
+f.call "  localhost:9092     "
 # => ["localhost", "9092"]
 ```
 
+Finally, for convenience, `F` is the identity function:
+
+```ruby
+F.call(1) # => 1
+```
+
 ## Maybe monad
 
 The Maybe monad is useful to express a pipeline of computations that might
@@ -88,14 +99,12 @@ maybe_user = Maybe(user) >-> user {
 x = Some(10)
 y = None()
 
-# Now using fancy point-free style:
-Maybe(user) >> F . Maybe . address >> F . Maybe . street
 ```
 
-As always, using point-free style is much cleaner:
+As usual (with Maybe and Either), using point-free style is much cleaner:
 
 ```ruby
-Maybe(user) >> F . Maybe . address >> F . Maybe . street
+Maybe(user) >> F . fn(&Maybe) . address >> F . fn(&Maybe) . street
 ```
 
 ### `fmap`
@@ -206,6 +215,11 @@ 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"
+
+# Point-free style bind!
+result = Right(3) >> F . fn(&Right) . *(2)
+result # => Right(6)
+result.value # => 6
 ```
 
 ### `fmap`
@@ -225,6 +239,18 @@ result # => Right(20)
 result # => Left("wrong")
 ```
 
+### `or`
+
+`or` does pretty much what would you expect:
+
+```ruby
+require 'kleisli'
+
+Right(10).or(Right(999)) # => Right(10)
+Left("error").or(Left("new error")) # => Left("new error")
+Left("error").or { |err| Left("new #{err}") } # => Left("new error")
+```
+
 ### `to_maybe`
 
 Sometimes it's useful to turn an `Either` into a `Maybe`. You can use

data/lib/kleisli/{blankslate.rb → blank.rb}

@@ -1,4 +1,6 @@
 #!/usr/bin/env ruby
+# Note: BlankSlate was renamed to Blank to avoid collisions in this project.
+#
 #--
 # Copyright 2004, 2006 by Jim Weirich (jim@weirichhouse.org).
 # All rights reserved.
@@ -9,15 +11,15 @@
 #++
 
 ######################################################################
-# BlankSlate provides an abstract base class with no predefined
+# Blank provides an abstract base class with no predefined
 # methods (except for <tt>\_\_send__</tt> and <tt>\_\_id__</tt>).
-# BlankSlate is useful as a base class when writing classes that
+# Blank is useful as a base class when writing classes that
 # depend upon <tt>method_missing</tt> (e.g. dynamic proxies).
 #
-class BlankSlate
+class Blank
   class << self
 
-    # Hide the method named +name+ in the BlankSlate class.  Don't
+    # Hide the method named +name+ in the Blank class.  Don't
     # hide +instance_eval+ or any method beginning with "__".
     def hide(name)
       methods = instance_methods.map(&:to_sym)
@@ -48,21 +50,21 @@ end
 
 ######################################################################
 # Since Ruby is very dynamic, methods added to the ancestors of
-# BlankSlate <em>after BlankSlate is defined</em> will show up in the
-# list of available BlankSlate methods.  We handle this by defining a
+# Blank <em>after Blank is defined</em> will show up in the
+# list of available Blank methods.  We handle this by defining a
 # hook in the Object and Kernel classes that will hide any method
-# defined after BlankSlate has been loaded.
+# defined after Blank has been loaded.
 #
 module Kernel
   class << self
     alias_method :blank_slate_method_added, :method_added
 
     # Detect method additions to Kernel and remove them in the
-    # BlankSlate class.
+    # Blank class.
     def method_added(name)
       result = blank_slate_method_added(name)
       return result if self != Kernel
-      BlankSlate.hide(name)
+      Blank.hide(name)
       result
     end
   end
@@ -76,11 +78,11 @@ class Object
     alias_method :blank_slate_method_added, :method_added
 
     # Detect method additions to Object and remove them in the
-    # BlankSlate class.
+    # Blank class.
     def method_added(name)
       result = blank_slate_method_added(name)
       return result if self != Object
-      BlankSlate.hide(name)
+      Blank.hide(name)
       result
     end
 
@@ -103,7 +105,7 @@ class Module
     result = blankslate_original_append_features(mod)
     return result if mod != Object
     instance_methods.each do |name|
-      BlankSlate.hide(name)
+      Blank.hide(name)
     end
     result
   end

data/lib/kleisli/composition.rb

@@ -1,3 +1,5 @@
+require_relative 'blank'
+
 class Proc
   def self.comp(f, g)
     lambda { |*args| f[g[*args]] }
@@ -9,26 +11,33 @@ class Proc
 end
 
 module Kleisli
-  class ComposedFn < BasicObject
+  class ComposedFn < Blank
     include ::Kernel
 
     def initialize(fns=[])
       @fns = fns
     end
 
-    def method_missing(m, *args, &block)
-      fn = -> a, x {
-        if x.respond_to?(m)
-          x.send(m, *a)
-        else
-          send(m, *[x, a])
-        end
+    def fn(*args, &block)
+      f = -> arguments, receiver {
+        block.call(receiver, *arguments)
+      }.curry[args]
+      ComposedFn.new(@fns + [f])
+    end
+
+    def method_missing(meth, *args, &block)
+      f = -> arguments, receiver {
+        receiver.send(meth, *arguments, &block)
       }.curry[args]
-      ComposedFn.new(@fns + [fn])
+      ComposedFn.new(@fns + [f])
     end
 
     def call(*args)
-      @fns.reduce(:*).call(*args)
+      if @fns.any?
+        @fns.reduce(:*).call(*args)
+      else
+        args.first
+      end
     end
 
     def to_ary

data/lib/kleisli/either.rb

@@ -28,7 +28,7 @@ module Kleisli
         Maybe::Some.new(@right)
       end
 
-      def or(other)
+      def or(other, &other_blk)
         self
       end
     end
@@ -52,13 +52,20 @@ module Kleisli
         Maybe::None.new
       end
 
-      def or(other)
-        other
+      def or(other, &other_blk)
+        if other_blk
+          other_blk.call(@left)
+        else
+          other
+        end
       end
     end
   end
 end
 
+Right = Kleisli::Either::Right.method(:new)
+Left = Kleisli::Either::Left.method(:new)
+
 def Right(v)
   Kleisli::Either::Right.new(v)
 end

data/lib/kleisli/maybe.rb

@@ -50,8 +50,10 @@ module Kleisli
   end
 end
 
+Maybe = Kleisli::Maybe.method(:lift)
+
 def Maybe(v)
-  Kleisli::Maybe.lift(v)
+  Maybe.(v)
 end
 
 def None()

data/lib/kleisli/version.rb

@@ -1,3 +1,3 @@
 module Kleisli
-  VERSION = "0.0.6"
+  VERSION = "0.1.0"
 end

data/test/kleisli/composition_test.rb

@@ -0,0 +1,78 @@
+require 'test_helper'
+
+class CompositionTest < MiniTest::Unit::TestCase
+  def test_one_method
+    f = F . first
+    result = f.call([1])
+    assert Fixnum === result, "#{result} is not a number"
+    assert_equal 1, result
+  end
+
+  def test_two_methods
+    f = F . first . last
+    result = f.call([1, [2,3]])
+    assert Fixnum === result, "#{result} is not a number"
+    assert_equal 2, result
+  end
+
+  def test_one_function
+    my_first = lambda { |x| x.first }
+
+    f = F . fn(&my_first)
+    result = f.call([1])
+    assert Fixnum === result, "#{result} is not a number"
+    assert_equal 1, result
+  end
+
+  def test_two_functions
+    my_first = lambda { |x| x.first }
+    my_last = lambda { |x| x.last }
+
+    f = F . fn(&my_first) . fn(&my_last)
+    result = f.call([1, [2,3]])
+    assert Fixnum === result, "#{result} is not a number"
+    assert_equal 2, result
+  end
+
+  def test_one_function_one_block
+    my_last = lambda { |x| x.last }
+
+    f = F . fn { |x| x.first } . fn(&my_last)
+    result = f.call([1, [2,3]])
+    assert Fixnum === result, "#{result} is not a number"
+    assert_equal 2, result
+  end
+
+  def test_one_function_one_method
+    my_last = lambda { |x| x.last }
+
+    f = F . first . fn(&my_last)
+    result = f.call([1, [2,3]])
+    assert Fixnum === result, "#{result} is not a number"
+    assert_equal 2, result
+  end
+
+  def test_undefined_method
+    f = F . foo
+    assert_raises(NoMethodError) { f.call(1) }
+  end
+
+  def test_identity
+    assert_equal 1, F.call(1)
+  end
+
+  def test_partially_applied_method
+    f = F . split(":")
+    result = f.call("localhost:9092")
+    assert Array === result, "#{result} is not an array"
+    assert_equal ["localhost", "9092"], result
+  end
+
+  def test_partially_applied_fn
+    split = lambda { |x, *args| x.split(*args) }
+    f = F . fn(":", &split)
+    result = f.call("localhost:9092")
+    assert Array === result, "#{result} is not an array"
+    assert_equal ["localhost", "9092"], result
+  end
+end

data/test/kleisli/either_test.rb

@@ -42,4 +42,8 @@ class EitherTest < MiniTest::Unit::TestCase
   def test_to_maybe_left
     assert_equal None(), Left("error").fmap { |x| x * 2 }.to_maybe
   end
+
+  def test_pointfree
+    assert_equal Right(10), Right(5) >> F . fn(&Right) . *(2)
+  end
 end

data/test/kleisli/maybe_test.rb

@@ -9,13 +9,13 @@ class MaybeTest < MiniTest::Unit::TestCase
     assert_equal nil, None().value
   end
 
-  # def test_bind_none
-  #   assert_equal None(), None() >> F . Maybe . *(2)
-  # end
+  def test_bind_none
+    assert_equal None(), None() >> F . fn(&Maybe) . *(2)
+  end
 
-  # def test_bind_some
-  #   assert_equal Some(6), Some(3) >> F . Maybe . *(2)
-  # end
+  def test_bind_some
+    assert_equal Some(6), Some(3) >> F . fn(&Maybe) . *(2)
+  end
 
   def test_fmap_none
     assert_equal None(), None().fmap { |x| x * 2 }

data/test/kleisli/try_test.rb

@@ -29,9 +29,4 @@ class TryTest < MiniTest::Unit::TestCase
     try = Try { 20 / 10 } >-> number { Try { 10 / number } }
     assert_equal 5, try.value
   end
-
-  # def test_pointfree
-  #   try = Try { 20 / 10 } >> F . Try { 10 / 2 }
-  #   assert_equal 5, try.value
-  # end
 end

metadata

@@ -1,57 +1,61 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: kleisli
-version: !ruby/object:Gem::Version 
-  version: 0.0.6
+version: !ruby/object:Gem::Version
+  version: 0.1.0
 platform: ruby
-authors: 
+authors:
 - Josep M. Bach
 - Ryan Levick
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2014-11-17 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2014-11-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: bundler
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        version: "1.6"
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rake
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        version: "10.0"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
   type: :development
-  version_requirements: *id002
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
 description: Usable, idiomatic common monads in Ruby
-email: 
+email:
 - josep.m.bach@gmail.com
 - ryan.levick@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- .gitignore
-- .travis.yml
+files:
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - kleisli.gemspec
 - lib/kleisli.rb
-- lib/kleisli/blankslate.rb
+- lib/kleisli/blank.rb
 - lib/kleisli/composition.rb
 - lib/kleisli/either.rb
 - lib/kleisli/functor.rb
@@ -62,6 +66,7 @@ files:
 - lib/kleisli/try.rb
 - lib/kleisli/version.rb
 - lib/kleisli/writer.rb
+- test/kleisli/composition_test.rb
 - test/kleisli/either_test.rb
 - test/kleisli/future_test.rb
 - test/kleisli/maybe_test.rb
@@ -70,32 +75,31 @@ files:
 - test/kleisli/writer_test.rb
 - test/test_helper.rb
 homepage: https://github.com/txus/kleisli
-licenses: 
+licenses:
 - MIT
 metadata: {}
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - &id003 
-    - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - *id003
+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.4.2
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Usable, idiomatic common monads in Ruby
-test_files: 
+test_files:
+- test/kleisli/composition_test.rb
 - test/kleisli/either_test.rb
 - test/kleisli/future_test.rb
 - test/kleisli/maybe_test.rb