arrows 0.0.11 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 94df8a36337317e66fc6faaef9997ae62828e4d3
-  data.tar.gz: 5876f8e38bbb58e3bc778b0c4733f3f189776535
+  metadata.gz: 87e62ace5a7ed0350a0f2933213138fbc4adf91d
+  data.tar.gz: b3d590924508a3a8ee58b1b83c4f45d9df39244c
 SHA512:
-  metadata.gz: 16dbc25bd13d6a367b0ed47c700999819b2dec2c820356b1153cad35473203bedc082eb3dfb341f54e13daa83e193a9cf2e43e896b7e0d410f87211ab4531e23
-  data.tar.gz: f8efbc83a05a6acefadcafe5f7e6cdf41088b5d9a07688b53246962360606aa92e5d193fb205294dc253dcf26037e86d9a9a283487267f602783f56bb2f055c6
+  metadata.gz: e8a05896a7bc8593eaa83585fb71ab2957daf737597873639ffbe8653f2a4596dc9bf2220ec587200bc6066a52d342f52c13fae33b33a2397e4fef0d4735681b
+  data.tar.gz: cbc2435c3618794b04fad75e7ebe38f2a1a5d2fbcdd4323768774e5c3cf359a3190a899cbf1eb34fe92999e01208f67108441227d1c8be0d52d014d38ef4722c

data/README.md

@@ -18,6 +18,12 @@ x -> H -> z
 
 As in we pipe what F poops out into the mouth of G a la Human Centipede
 
+```ruby
+f = Arrows.lift -> (apple) { apple.to_orange }
+g = Arrows.lift -> (orange) { orange.to_kiwi }
+apple_to_kiwi = f >> g
+```
+![Regular >> composition](https://raw.githubusercontent.com/foxnewsnetwork/arrows/master/pics/compose.mermaid.png)
 
 ### Applicative composition
 Calls map (in Haskell, they generalize it to fmap) on the data passed in
@@ -28,15 +34,64 @@ x -> F -> y and [x]
 Returns
 [x] -> F -> [z]
 
+```ruby
+apples = Arrows.lift [apple, apple, apple]
+apple_to_kiwi = Arrows.lift -> (apple) { apple.to_kiwi }
+kiwis = apples >= apple_to_kiwi
+```
+![functor >= composition](https://raw.githubusercontent.com/foxnewsnetwork/arrows/master/pics/fmap.mermaid.png)
+
 ### Arrow fan out
 x -> y
 x -> z
 becomes
 x -> [y,z]
 
+```ruby
+apple_to_orange = Arrows.lift -> (apple) { apple.to_orange }
+apple_to_kiwi = Arrows.lift -> (apple) { apple.to_kiwi }
+orange_and_kiwi = Arrows.lift(apple) >> (apple_to_orange / apple_to_kiwi)
+```
+![fanout / composition](https://raw.githubusercontent.com/foxnewsnetwork/arrows/master/pics/fanout.mermaid.png)
+
 ### Arrow Fork
 f ^ g produces a proc that takes in a Either, and if either is good, f is evaluated, if either is evil, g is evaluated
 
+```ruby
+apple_to_orange = Arrows.lift -> (apple) { apple.to_orange }
+apple_to_kiwi = Arrows.lift -> (apple) { apple.to_kiwi }
+orange = Arrows.lift(apple) >> Arrows::Good >> (apple_to_orange ^ apple_to_kiwi)
+kiwi = Arrows.lift(apple) >> Arrows::Evil >> (apple_to_orange ^ apple_to_kiwi)
+```
+![fork / composition](https://raw.githubusercontent.com/foxnewsnetwork/arrows/master/pics/fork.mermaid.png)
+
+### ArrowLoop
+step <=> chose produces a proc that cycles between step and chose until chose returns a good either. Then returns whatever was in the good either
+
+```ruby
+context '<=> feedback' do
+    let(:step) { Arrows.lift -> (arg_acc) { [arg_acc.first - 1, arg_acc.reduce(&:*)] } }
+    let(:chose) { Arrows.lift -> (arg_acc) { arg_acc.first < 1 ? Arrows.good(arg_acc.last) : Arrows.evil(arg_acc) } }
+    let(:factorial) { step <=> chose }
+    context '120' do
+      let(:one_twenty) { Arrows.lift(5) >> factorial }
+      subject { one_twenty.call }
+      specify { should eq 120 }
+    end
+    context '1' do
+      let(:one) { Arrows.lift(1) >> factorial }
+      subject { one.call }
+      specify { should eq 1 }
+    end
+    context '0' do
+      let(:zero) { Arrows.lift(0) >> factorial }
+      subject { zero.call }
+      specify { should eq 0 }
+    end
+  end
+```
+![feedback / composition](https://raw.githubusercontent.com/foxnewsnetwork/arrows/master/pics/feedback.mermaid.png)
+
 ## Memoization
 ```ruby
 @some_process = Arrows.lift -> (a) { a }

data/lib/arrows.rb

@@ -4,6 +4,17 @@ module Arrows
   require 'arrows/either'
   require 'arrows/proc'
   class << self
+    def feedback(merge, split)
+      Arrows::Proc.new do |args|
+        single = merge.call [args]
+        either = split.call single
+        while not either.good?
+          single = merge.call either.payload
+          either = split.call single
+        end
+        either.payload
+      end
+    end
     def fork(f,g)
       Arrows::Proc.new do |either|
         either.good? ? f[either.payload] : g[either.payload]
@@ -23,11 +34,11 @@ module Arrows
     def fmap(xs, f)
       Arrows::Proc.new { |args| xs[args].map { |x| f[x] }  }
     end
-    def good(x)
+    def good(x=nil)
       return x if x.respond_to?(:good?) && x.respond_to?(:payload)
       Arrows::Either.new true, x
     end
-    def evil(x)
+    def evil(x=nil)
       return x if x.respond_to?(:good?) && x.respond_to?(:payload)
       Arrows::Either.new false, x
     end 

data/lib/arrows/either.rb

@@ -7,4 +7,7 @@ class Arrows::Either
   def good?
     @good
   end
+  def evil?
+    not good?
+  end
 end

data/lib/arrows/proc.rb

@@ -24,6 +24,11 @@ class Arrows::Proc < Proc
     Arrows.fork self, f
   end
 
+  # feedback (aka ArrowLoop) composition
+  def <=>(g) 
+    Arrows.feedback self, g
+  end
+
   # Returns a memoizing version of this proc
   def memoize
     cache = {}

data/lib/arrows/version.rb

@@ -1,3 +1,3 @@
 module Arrows
-  VERSION = "0.0.11"
+  VERSION = "0.0.12"
 end

data/pics/compose.mermaid

@@ -0,0 +1,3 @@
+graph LR;
+  A[apple "->" orange] --> B((compose))
+  B --> C[orange "->" kiwi];

data/pics/concurrent.mermaid

@@ -0,0 +1,5 @@
+graph LR;
+  A[apple, orange] --> X((compose));
+  X --> B{concurrent};
+  B --> C[apple "->" pear];
+  B --> D[orange "->" kiwi];

data/pics/fanout.mermaid

@@ -0,0 +1,7 @@
+graph LR;
+  A[apple] --> B((compose))
+  B --> C[apple "->" pear];
+  B --> D[apple "->" kiwi];
+  C --> E{fork};
+  D --> E;
+  E --> F[pear, kiwi];

data/pics/feedback.mermaid

@@ -0,0 +1,7 @@
+graph LR;
+  A[apple] --> B((compose));
+  B --> C[apple, mango "->" cherry];
+  C --> X((feedback));
+  X --> D[cherry "->" Either pear, mango];
+  D --> C;
+  D --> F[pear];

data/pics/fmap.mermaid

@@ -0,0 +1,4 @@
+graph LR;
+  A[apples] --> B((fmap));
+  B --> C[apple "->" pear];
+  C --> D[pears];

data/pics/fork.mermaid

@@ -0,0 +1,4 @@
+graph LR;
+  C[apple "->" Either pear, kiwi] --> D{ fork };
+  D -->|good| E[pear];
+  D -->|evil| F(kiwi);

data/spec/arrows/proc_spec.rb

@@ -29,6 +29,27 @@ RSpec.describe Arrows::Proc do
     end
   end
 
+  context '<=> feedback' do
+    let(:step) { Arrows.lift -> (arg_acc) { [arg_acc.first - 1, arg_acc.reduce(&:*)] } }
+    let(:chose) { Arrows.lift -> (arg_acc) { arg_acc.first < 1 ? Arrows.good(arg_acc.last) : Arrows.evil(arg_acc) } }
+    let(:factorial) { step <=> chose }
+    context '120' do
+      let(:one_twenty) { Arrows.lift(5) >> factorial }
+      subject { one_twenty.call }
+      specify { should eq 120 }
+    end
+    context '1' do
+      let(:one) { Arrows.lift(1) >> factorial }
+      subject { one.call }
+      specify { should eq 1 }
+    end
+    context '0' do
+      let(:zero) { Arrows.lift(0) >> factorial }
+      subject { zero.call }
+      specify { should eq 0 }
+    end
+  end
+
   context '>> composition' do
     let(:times2) { -> (x) { x * 2 } }
     let(:plus3) { -> (x) { x + 3 } }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: arrows
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.12
 platform: ruby
 authors:
 - Thomas Chen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-23 00:00:00.000000000 Z
+date: 2014-12-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -72,6 +72,18 @@ files:
 - lib/arrows/either.rb
 - lib/arrows/proc.rb
 - lib/arrows/version.rb
+- pics/compose.mermaid
+- pics/compose.mermaid.png
+- pics/concurrent.mermaid
+- pics/concurrent.mermaid.png
+- pics/fanout.mermaid
+- pics/fanout.mermaid.png
+- pics/feedback.mermaid
+- pics/feedback.mermaid.png
+- pics/fmap.mermaid
+- pics/fmap.mermaid.png
+- pics/fork.mermaid
+- pics/fork.mermaid.png
 - spec/arrows/proc_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/foxnewsnetwork/arrows