beethoven 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c66a2988156ddaabcb7d6e6791dad2a05e40473f
-  data.tar.gz: c1a3b6736a70a2f716525ddf4ae7be912537e336
+  metadata.gz: bdf26fc9c7904a96681b438f0ea47a2061eea493
+  data.tar.gz: 3f5d73b121875564e705d8685c0cbad45db42cd8
 SHA512:
-  metadata.gz: b7fc5cf70c12768bd8023185d3d37c8eb523fb6d9a04bdc0cc0755020796968a2d14578d63c054f1dc89bd9d9d6c7efd6f34c4e0bd2f794e4c8a5a787f2cc0d0
-  data.tar.gz: 1d1124e69a4054c80732671657de6208dcb0e657cec21bafadb4a189c9910610eb5af209e1fa8c52712481b6c8758ed4d1a7c142f6f37762b1a59c82656ccc79
+  metadata.gz: f5b044385e4b14c01511ee53286ff51839c5a949e10b04e090dafd6dfc7702bf14f2b5b1ac5573ed8bcc58f0a1755aef5d27dcc1a4e5ee7f4f9b8a940570e770
+  data.tar.gz: 88b3693bf215390c9b9c74524e5d6b93eaa74a4b67fa9a0809b3dfd36bb45af746ebdd09e0b53cf995125043b3b936011a514583574e3452dbe9f89b152bd75d

data/.ruby-gemset

@@ -0,0 +1 @@
+beethoven

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.2.2

data/README.md

@@ -1,6 +1,117 @@
 # Beethoven
 
-TODO: Write a gem description
+Composition is an incredibly useful technique in functional programming.
+I have been missing that in my development with Ruby, so I set out to implement it here.
+
+In Haskell, you can write a function like:
+
+```haskell
+-- f is a function that takes a value of type a
+-- and returns a value of type b
+f :: a -> b
+```
+
+We need some analogy with Ruby concepts.
+It doesn't appear to be methods, messages, or objects.
+Classes, however, seem to do it nicely.
+
+1. Replace the arrow with `new`
+2. `a` is the *interface* or *duck* that fits the single parameter of the class.
+3. `b` is the interface/duck that fits the object produced by new.
+
+So, we might express a class `F` that implements message `b` and expects an object responding to `a` as:
+
+```ruby
+class F
+  attr_reader :b
+
+  def initialize(x)
+    @b = x.a
+  end
+end
+```
+
+Next up, we want some class that implements the duck that `F` expects.
+
+```ruby
+class G
+  attr_reader :a
+
+  def initialize(x)
+    @a = x
+  end
+end
+
+G.new(5).a
+# => 5
+
+F.new(G.new(5)).b
+# => 5
+```
+
+This is class composition. But really, it'd be a lot nicer if we could write:
+
+```ruby
+(F * G).new(5).b
+# => 5
+```
+
+Or, perhaps you prefer the bash-like pipe operator and reading your compositions from left to right.
+No problem:
+
+```ruby
+(G | F).new(5).b
+# => 5
+```
+
+Naturally, this is quite a bit more interesting when your classes do something other than simply returning the value they were given.
+In this example, the classes expect a parameter that duck-types `value`.
+
+```ruby
+class Add5
+  def initialize(x)
+    @value = x.value
+  end
+
+  def value
+    @value + 5
+  end
+end
+
+class Multiply10
+  def initialize(x)
+    @value = x.value
+  end
+
+  def value
+    @value * 10
+  end
+end
+
+class Lift
+  attr_reader :value
+
+  def initialize(x)
+    @value = x
+  end
+end
+
+(Add5 * Multiply10 * Lift).new(7).value
+#=> 75
+
+(Lift | Multiply10 | Add5).new(4).value
+#=> 45
+```
+
+If you'd prefer to compose classes directly, use `Beethoven::Composer`:
+
+```ruby
+Mul10Add5 = Beethoven::Composer.new(Lift, Multiply10, Add5)
+Mul10Add5.new(5).value
+#=> 55
+```
+
+A more practical example is presented [here](https://gist.github.com/parsonsmatt/c1abbb830b6976566198)
 
 ## Installation
 
@@ -18,10 +129,6 @@ Or install it yourself as:
 
     $ gem install beethoven
 
-## Usage
-
-TODO: Write usage instructions here
-
 ## Contributing
 
 1. Fork it ( https://github.com/[my-github-username]/beethoven/fork )

data/lib/beethoven/composable.rb

@@ -0,0 +1,11 @@
+module Beethoven
+  module Composable
+    def *(other)
+      new(other, self)
+    end
+
+    def |(other)
+      new(self, other)
+    end
+  end
+end

data/lib/beethoven/version.rb

@@ -1,3 +1,3 @@
 module Beethoven
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: beethoven
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Matt Parsons
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-28 00:00:00.000000000 Z
+date: 2015-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -106,6 +106,8 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".ruby-gemset"
+- ".ruby-version"
 - Gemfile
 - Guardfile
 - LICENSE.txt
@@ -114,6 +116,7 @@ files:
 - beethoven.gemspec
 - lib/beethoven.rb
 - lib/beethoven/class.rb
+- lib/beethoven/composable.rb
 - lib/beethoven/composer.rb
 - lib/beethoven/version.rb
 - spec/beethoven/composer_spec.rb
@@ -140,7 +143,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Make it a bit easier to compose classes in Ruby