functional-ruby 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8c798e8848a4a1a3e47077fa48ac65c0595df304
-  data.tar.gz: 0785957a5566c7fe58c753d8a2c09b040e11a17c
+  metadata.gz: 7ebc0dab7cc6ee079416729c8cc131bf239ca2bb
+  data.tar.gz: 24b3193d7e6fef20addd8688ab372c104163edae
 SHA512:
-  metadata.gz: 7e2bd7f3b530d2c95134733f2a275ed2eb5ea16a68aac88ae9bbc9f50a9391a277afbf1608b9b15e7a25df193179523f5b6da920751e5e64f5255841823ebc6e
-  data.tar.gz: 46a8e971f0c9e39f4287c3b743495678975a7fac5f22dbb607b9ec10321e5e2c27ee120bcf67a6d8adde48d4a7b95b910f65a7be0fe38931481153bf0b7afecf
+  metadata.gz: 65b487a457f8b8a4dcb3adfe98e8429ae0184656d3ddf6292c515c598f4cb6e610f8aca4185950626bf4e67cda95a77eb081031caf5f7ea95ccf3592df6c9d0a
+  data.tar.gz: bbe8b613ee9ac7a4aa4ed6626a36a2bfc148e4ddc42ef5fd2f5be5703f74567beb15dd772d0b4e63156f6ca46accae1425dfdeac0a36d75a34a09aa4bceafc45

data/README.md

@@ -1,12 +1,15 @@
 # Functional Ruby [![Build Status](https://secure.travis-ci.org/jdantonio/functional-ruby.png)](https://travis-ci.org/jdantonio/functional-ruby?branch=master) [![Dependency Status](https://gemnasium.com/jdantonio/functional-ruby.png)](https://gemnasium.com/jdantonio/functional-ruby)
 
-A gem for adding Erlang, Clojure, and Go inspired concurrency and functional programming tools to Ruby.
+A gem for adding Erlang, Clojure, and Go inspired functional programming tools to Ruby.
+
+*NOTE: As of version 0.7.0 the concurrency tools from this gem have been moved to the
+[concurrent-ruby](https://github.com/jdantonio/concurrent-ruby) gem.*
 
 The project is hosted on the following sites:
 
 * [RubyGems project page](https://rubygems.org/gems/functional-ruby)
 * [Source code on GitHub](https://github.com/jdantonio/functional-ruby)
-* [YARD documentation on RubyDoc.info](http://rubydoc.info/github/jdantonio/functional-ruby/master/frames)
+* [YARD documentation on RubyDoc.info](http://rubydoc.info/github/jdantonio/functional-ruby/frames)
 * [Continuous integration on Travis-CI](https://travis-ci.org/jdantonio/functional-ruby)
 * [Dependency tracking on Gemnasium](https://gemnasium.com/jdantonio/functional-ruby)
 * [Follow me on Twitter](https://twitter.com/jerrydantonio)
@@ -27,19 +30,11 @@ area. Ruby 2.0 is now a [relevant](https://blog.heroku.com/archives/2013/6/17/ru
 platform for concurrent applications.
 
 This gem is my small and humble attempt to help Ruby reach its full potential as
-a highly performant, functional, concurrent programming language.
+a highly performant, functional programming language.
 
 ### Goals
 
-My history with high-performance, highly-concurrent programming goes back to my days with C/C++.
-I have the same scars as everyone else doing that kind of work with those languages.
-I'm fascinated by modern concurrency patterns like [Actors](http://en.wikipedia.org/wiki/Actor_model),
-[Agents](http://doc.akka.io/docs/akka/snapshot/java/agents.html), and
-[Promises](http://promises-aplus.github.io/promises-spec/). I'm equally fascinated by languages
-with strong concurrency support like [Erlang](http://www.erlang.org/doc/getting_started/conc_prog.html),
-[Go](http://golang.org/doc/articles/concurrency_patterns.html), and
-[Clojure](http://clojure.org/concurrent_programming) (I program with Erlang at work).
-My goal is to implement those patterns in Ruby. Specifically:
+My goal is to implement various functional programming patterns in Ruby. Specifically:
 
 * Stay true to the spirit of the languages providing inspiration
 * But implement in a way that makes sense for Ruby
@@ -51,12 +46,10 @@ My goal is to implement those patterns in Ruby. Specifically:
 
 ## Features (and Documentation)
 
-Several features from Erlang, Co, Clojure, and JavaScript have been implemented this far:
+Several features from Erlang, Go, and Clojure have been implemented thus far:
 
 * Function overloading with Erlang-style [Pattern Matching](https://github.com/jdantonio/functional-ruby/blob/master/md/pattern_matching.md)
 * Interface specifications with Erlang-style [Behavior](https://github.com/jdantonio/functional-ruby/blob/master/md/behavior.md)
-* Chained asynchronous operations inspried by JavaScript [Promises](https://github.com/jdantonio/functional-ruby/blob/master/md/promise.md)
-* Additional Clojure, Go, and Erlang inspired [Concurrency](https://github.com/jdantonio/functional-ruby/blob/master/md/concurrency.md)
 * Several useful functional [Utilities](https://github.com/jdantonio/functional-ruby/blob/master/md/utilities.md)
 
 ### Is it any good?
@@ -85,30 +78,18 @@ gem 'functional-ruby'
 
 and run `bundle install` from your shell.
 
-Once you've installed the gem you must `require` it in your project. Becuase this gem includes multiple features
-that not all users may want, several `require` options are available:
+Once you've installed the gem you must `require` it in your project:
 
 ```ruby
-require 'functional/behavior'
-require 'functional/behaviour' # alternate spelling
-require 'functional/concurrency'
-require 'functional/pattern_matching'
-require 'functional/promise'
-require 'functional/utilities'
+require 'functional'
 ```
 
-If you want everything you can do that, too:
-
-```ruby
-require 'functional/all'
-```
-
-## Examples
+### Examples
 
 For complete examples, see the specific documentation linked above. Below are a
 few examples to whet your appetite.
 
-### Pattern Matching (Erlang)
+#### Pattern Matching (Erlang)
 
 Documentation: [Pattern Matching](https://github.com/jdantonio/functional-ruby/blob/master/md/pattern_matching.md)
 
@@ -132,7 +113,7 @@ foo.greet(:male)   #=> "Hello, sir!"
 foo.greet(:female) #=> "Hello, ma'am!"
 ```
 
-### Behavior (Erlang)
+#### Behavior (Erlang)
 
 Documentation: [Behavior](https://github.com/jdantonio/functional-ruby/blob/master/md/behavior.md)
 
@@ -160,100 +141,7 @@ foo.behaves_as?(:bogus)     #=> false
 'foo'.behaves_as? :gen_foo  #=> false
 ```
 
-### Goroutine (Go)
-
-```ruby
-require 'functional/concurrency'
-
-@expected = nil
-go(1, 2, 3){|a, b, c| @expected = [c, b, a] }
-sleep(0.1)
-@expected #=> [3, 2, 1]
-```
-
-### Agent (Clojure)
-
-```ruby
-require 'functional/agent'
-# or
-require 'functional/concurrency'
-
-score = agent(10)
-score.value #=> 10
-
-score << proc{|current| current + 100 }
-sleep(0.1)
-score.value #=> 110
-
-score << proc{|current| current * 2 }
-sleep(0.1)
-deref score #=> 220
-
-score << proc{|current| current - 50 }
-sleep(0.1)
-score.value #=> 170
-```
-
-### Future (Clojure)
-
-```ruby
-require 'functional/future'
-# or
-require 'functional/concurrency'
-
-count = future{ sleep(1); 10 }
-count.state #=> :pending
-# do stuff...
-count.value #=> 10 (after blocking)
-deref count #=> 10
-```
-
-### Promise (JavaScript)
-
-* [Promises/A](http://wiki.commonjs.org/wiki/Promises/A)
-* [Promises/A+](http://promises-aplus.github.io/promises-spec/)
-
-```ruby
-require 'functional/promise'
-# or
-require 'functional/concurrency'
-
-p = promise("Jerry", "D'Antonio"){|a, b| "#{a} #{b}" }.
-    then{|result| "Hello #{result}." }.
-    rescue(StandardError){|ex| puts "Boom!" }.
-    then{|result| "#{result} Would you like to play a game?"}
-sleep(1)
-p.value #=> "Hello Jerry D'Antonio. Would you like to play a game?" 
-```
-
-### Thread Pools
-
-```ruby
-require 'functional/fixed_thread_pool'
-require 'functional/cached_thread_pool'
-# or
-require 'functional/concurrency'
-
-pool = Functional::FixedThreadPool.new(10)
-@expected = 0
-pool.post{ sleep(0.5); @expected += 100 }
-pool.post{ sleep(0.5); @expected += 100 }
-pool.post{ sleep(0.5); @expected += 100 }
-@expected #=> nil
-sleep(1)
-@expected #=> 300
-
-pool = Functional::CachedThreadPool.new
-@expected = 0
-pool << proc{ sleep(0.5); @expected += 10 }
-pool << proc{ sleep(0.5); @expected += 10 }
-pool << proc{ sleep(0.5); @expected += 10 }
-@expected #=> 0
-sleep(1)
-@expected #=> 30
-```
-
-### Utilities
+#### Utilities
 
 Documentation: [Utilities](https://github.com/jdantonio/functional-ruby/blob/master/md/utilities.md)
 

data/lib/functional.rb

@@ -1 +1,4 @@
-require 'functional/all'
+require 'functional/behavior'
+require 'functional/pattern_matching'
+require 'functional/utilities'
+require 'functional/version'

data/lib/functional/utilities.rb

@@ -30,6 +30,52 @@ module Kernel
   end
   module_function :delta
 
+  # Perform an operation numerous times, passing the value of the
+  # previous iteration, and collecting the results into an array.
+  #
+  # @yield iterates over each element in the data set
+  # @yieldparam previous the initial value (or nil) for the first
+  #   iteration then the value of the previous iteration for all
+  #   subsequent iterations
+  #
+  # @param [Integer] count the number of times to perform the operation
+  # @param [Object] initial the initial value to pass to the first iteration
+  #
+  # @return [Array] the results of the iterations collected into an array
+  def repeatedly(count, initial = nil)
+    return [] if (count = count.to_i) == 0
+    return count.times.collect{ nil } unless block_given?
+    return count.times.collect do
+      initial = yield(initial)
+    end
+  end
+  module_function :repeatedly
+
+  # Try an operation. If it fails (raises an exception), wait a second
+  # and try again. Try no more than the given number of times.
+  #
+  # @yield Tries the given block operation
+  #
+  # @param [Integer] tries The maximum number of times to attempt the operation.
+  # @param [Array] args Optional block arguments
+  #
+  # @return [Boolean] true if the operation succeeds on any attempt,
+  #   false if none of the attempts are successful
+  def retro(tries, *args)
+    tries = tries.to_i
+    return false if tries == 0 || ! block_given?
+    yield(*args)
+    return true
+  rescue Exception
+    sleep(1)
+    if (tries = tries - 1) > 0
+      retry
+    else
+      return false
+    end
+  end
+  module_function :retro
+
   # Sandbox the given operation at a high $SAFE level.
   #
   # @param args [Array] zero or more arguments to pass to the block

data/lib/functional/version.rb

@@ -1,3 +1,3 @@
 module Functional
-  VERSION = '0.6.0'
+  VERSION = '0.7.0'
 end

data/lib/functional_ruby.rb

@@ -1 +1 @@
-require 'functional/all'
+require 'functional'

data/md/utilities.md

@@ -21,6 +21,8 @@ pp_s [1,2,3,4] #=> "[1, 2, 3, 4]\n" props to Rha7
 
 delta(-1, 1) #=> 2
 delta({count: -1}, {count: 1}){|item| item[:count]} #=> 2
+
+repeatedly(10, 1){|previous| previous * 2 } #=> [2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
 ```
 
 ## Copyright

data/spec/functional/behavior_spec.rb

@@ -107,7 +107,7 @@ describe '-behavior' do
 
       lambda {
         clazz.new
-      }.should_not raise_error(BehaviorError)
+      }.should_not raise_error
     end
 
     it 'creates the object when function definitions match' do
@@ -120,7 +120,7 @@ describe '-behavior' do
 
       lambda {
         clazz.new
-      }.should_not raise_error(BehaviorError)
+      }.should_not raise_error
     end
   end
 

data/spec/functional/pattern_matching_spec.rb

@@ -44,7 +44,7 @@ describe PatternMatching do
 
     it 'can pattern match the constructor' do
 
-      unless RUBY_VERSION = '1.9.2'
+      unless RUBY_VERSION == '1.9.2'
         subject.defn(:initialize, PatternMatching::UNBOUND, PatternMatching::UNBOUND, PatternMatching::UNBOUND) { 'three args' }
         subject.defn(:initialize, PatternMatching::UNBOUND, PatternMatching::UNBOUND) { 'two args' }
         subject.defn(:initialize, PatternMatching::UNBOUND) { 'one arg' }
@@ -152,7 +152,7 @@ describe PatternMatching do
 
       lambda {
         obj.foo
-      }.should_not raise_error(NoMethodError)
+      }.should_not raise_error
     end
 
     it 'does not accept any parameters' do

data/spec/functional/utilities_spec.rb

@@ -3,43 +3,125 @@ require 'fakefs/safe'
 
 describe 'utilities' do
 
-  context '#repl?' do
+  context '#delta' do
 
-    before(:each) do
-      @dollar_zero = $0
+    it 'computes the delta of two positive values' do
+      delta(10.5, 5.0).should be_within(0.01).of(5.5)
     end
 
-    after(:each) do
-      $0 = @dollar_zero
+    it 'computes the delta of two negative values' do
+      delta(-10.5, -5.0).should be_within(0.01).of(5.5)
     end
 
-    def set_dollar_zero(val)
-      $0 = val
+    it 'computes the delta of a positive and negative value' do
+      delta(10.5, -5.0).should be_within(0.01).of(15.5)
     end
 
-    it 'recognizes IRB' do
-      set_dollar_zero('irb')
-      repl?.should be_true
+    it 'computes the delta of two positive values with a block' do
+      v1 = {:count => 10.5}
+      v2 = {:count => 5.0}
+      delta(v1, v2){|x| x[:count]}.should be_within(0.01).of(5.5)
     end
 
-    it 'recognizes Pry' do
-      set_dollar_zero('pry')
-      repl?.should be_true
+    it 'computes the delta of two negative values with a block' do
+      v1 = {:count => -10.5}
+      v2 = {:count => -5.0}
+      delta(v1, v2){|x| x[:count]}.should be_within(0.01).of(5.5)
     end
 
-    it 'recognizes Rails Console' do
-      set_dollar_zero('script/rails')
-      repl?.should be_true
+    it 'computes the delta of a positive and negative value with a block' do
+      v1 = {:count => 10.5}
+      v2 = {:count => -5.0}
+      delta(v1, v2){|x| x[:count]}.should be_within(0.01).of(15.5)
     end
+  end
 
-    it 'recognizes Bundle Console' do
-      set_dollar_zero('bin/bundle')
-      repl?.should be_true
+  context '#repeatedly' do
+
+    it 'returns an empty array when requested times is zero' do
+      expected = repeatedly(0){ 1 }
+      expected.should be_empty
     end
 
-    it 'returns false when not in a REPL' do
-      set_dollar_zero(__FILE__)
-      repl?.should be_false
+    it 'returns an array with all nil values when no block is given' do
+      expected = repeatedly(10)
+      expected.length.should eq 10
+      expected.each do |elem|
+        elem.should be_nil
+      end
+    end
+
+    it 'iterates the requested number of times and puts the results into an array' do
+      expected = repeatedly(10){ 5 }
+      expected.length.should eq 10
+      expected.each do |elem|
+        elem.should eq 5
+      end
+    end
+
+    it 'passes the initial value to the first iteration' do
+      @expected = nil
+      repeatedly(1,100){|previous| @expected = previous }
+      @expected.should eq 100
+    end
+
+    it 'passes the result of each iteration to the next iteration' do
+      expected = repeatedly(10, 1){|previous| previous * 2 }
+      expected.should eq [2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
+    end
+  end
+
+  context '#retro' do
+
+    it 'does not run the block if requested times is zero' do
+      @expected = true
+      retro(0){ @expected = false }
+      @expected.should be_true
+    end
+
+    it 'passes all arguments to the block' do
+      @expected = nil
+      retro(1, ?a, ?b, ?c){|*args| @expected = args }
+      @expected.should eq [?a, ?b, ?c]
+    end
+
+    it 'calls the block once if the first pass is successful' do
+      @expected = 0
+      retro(5){ @expected += 1 }
+      @expected.should eq 1
+    end
+
+    it 'calls the block more than once if the first pass fails' do
+      @expected = 0
+      retro(5) do
+        @expected += 1
+        raise StandardError if @expected < 3
+      end
+      @expected.should eq 3
+    end
+
+    it 'calls the block no more than the requested number of times' do
+      @expected = 0
+      retro(5) do
+        @expected += 1
+        raise StandardError
+      end
+      @expected.should eq 5
+    end
+
+    it 'returns true if any attempt succeeds' do
+      expected = retro(1){ nil }
+      expected.should be_true
+    end
+
+    it 'returns false if all attempts fail' do
+      expected = retro(1){ raise StandardError }
+      expected.should be_false
+    end
+
+    it 'returns false if no block is given' do
+      expected = retro(10)
+      expected.should eq false
     end
   end
 
@@ -48,7 +130,7 @@ describe 'utilities' do
     it 'allows safe operations' do
       lambda {
         safe{ 1 + 1 }
-      }.should_not raise_error(SecurityError)
+      }.should_not raise_error
     end
 
     it 'returns the value of the block when safe' do
@@ -113,37 +195,43 @@ describe 'utilities' do
     end
   end
 
-  context '#delta' do
+  context '#repl?' do
 
-    it 'computes the delta of two positive values' do
-      delta(10.5, 5.0).should be_within(0.01).of(5.5)
+    before(:each) do
+      @dollar_zero = $0
     end
 
-    it 'computes the delta of two negative values' do
-      delta(-10.5, -5.0).should be_within(0.01).of(5.5)
+    after(:each) do
+      $0 = @dollar_zero
     end
 
-    it 'computes the delta of a positive and negative value' do
-      delta(10.5, -5.0).should be_within(0.01).of(15.5)
+    def set_dollar_zero(val)
+      $0 = val
     end
 
-    it 'computes the delta of two positive values with a block' do
-      v1 = {:count => 10.5}
-      v2 = {:count => 5.0}
-      delta(v1, v2){|x| x[:count]}.should be_within(0.01).of(5.5)
+    it 'recognizes IRB' do
+      set_dollar_zero('irb')
+      repl?.should be_true
     end
 
-    it 'computes the delta of two negative values with a block' do
-      v1 = {:count => -10.5}
-      v2 = {:count => -5.0}
-      delta(v1, v2){|x| x[:count]}.should be_within(0.01).of(5.5)
+    it 'recognizes Pry' do
+      set_dollar_zero('pry')
+      repl?.should be_true
     end
 
-    it 'computes the delta of a positive and negative value with a block' do
-      v1 = {:count => 10.5}
-      v2 = {:count => -5.0}
-      delta(v1, v2){|x| x[:count]}.should be_within(0.01).of(15.5)
+    it 'recognizes Rails Console' do
+      set_dollar_zero('script/rails')
+      repl?.should be_true
+    end
+
+    it 'recognizes Bundle Console' do
+      set_dollar_zero('bin/bundle')
+      repl?.should be_true
     end
-  end
 
+    it 'returns false when not in a REPL' do
+      set_dollar_zero(__FILE__)
+      repl?.should be_false
+    end
+  end
 end