ick 0.0.2

data/tasks/deployment.rake

@@ -0,0 +1,34 @@
+desc 'Release the website and new gem version'
+task :deploy => [:check_version, :website, :release] do
+  puts "Remember to create SVN tag:"
+  puts "svn copy svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/trunk " +
+    "svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/tags/REL-#{VERS} "
+  puts "Suggested comment:"
+  puts "Tagging release #{CHANGES}"
+end
+
+desc 'Runs tasks website_generate and install_gem as a local deployment of the gem'
+task :local_deploy => [:website_generate, :install_gem]
+
+task :check_version do
+  unless ENV['VERSION']
+    puts 'Must pass a VERSION=x.y.z release version'
+    exit
+  end
+  unless ENV['VERSION'] == VERS
+    puts "Please update your version.rb to match the release version, currently #{VERS}"
+    exit
+  end
+end
+
+desc 'Install the package as a gem, without generating documentation(ri/rdoc)'
+task :install_gem_no_doc => [:clean, :package] do
+  sh "#{'sudo ' unless Hoe::WINDOZE }gem install pkg/*.gem --no-rdoc --no-ri"
+end
+
+namespace :manifest do
+  desc 'Recreate Manifest.txt to include ALL files'
+  task :refresh do
+    `rake check_manifest | patch -p0 > Manifest.txt`
+  end
+end

data/tasks/environment.rake

@@ -0,0 +1,7 @@
+task :ruby_env do
+  RUBY_APP = if RUBY_PLATFORM =~ /java/
+    "jruby"
+  else
+    "ruby"
+  end unless defined? RUBY_APP
+end

data/tasks/website.rake

@@ -0,0 +1,17 @@
+desc 'Generate website files'
+task :website_generate => :ruby_env do
+  (Dir['website/**/*.txt'] - Dir['website/version*.txt']).each do |txt|
+    sh %{ #{RUBY_APP} script/txt2html #{txt} > #{txt.gsub(/txt$/,'html')} }
+  end
+end
+
+desc 'Upload website files to rubyforge'
+task :website_upload do
+  host = "#{rubyforge_username}@rubyforge.org"
+  remote_dir = "/var/www/gforge-projects/#{PATH}/"
+  local_dir = 'website'
+  sh %{rsync -aCv #{local_dir}/ #{host}:#{remote_dir}}
+end
+
+desc 'Generate and upload website files'
+task :website => [:website_generate, :website_upload, :publish_docs]

data/test/test_helper.rb

@@ -0,0 +1,7 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/ick/base'
+require File.dirname(__FILE__) + '/../lib/ick/wrapped'
+require File.dirname(__FILE__) + '/../lib/ick/guarded'
+require File.dirname(__FILE__) + '/../lib/ick/sugar'
+  
+Ick.sugarize

data/test/test_ick.rb

@@ -0,0 +1,128 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class Box
+  attr_accessor :value
+  
+  def initialize(_value)
+    self.value = _value
+  end
+  
+  def == (other)
+    other.respond_to?(:value) && self.value == other.value
+  end
+  
+  def to_s
+    "Box(#{value})"
+  end
+  
+  def inspect
+    "Box(#{value})"
+  end
+  
+end
+
+class TestIck < Test::Unit::TestCase
+  
+  attr_accessor :value
+
+  def setup
+    @one = Box.new(1)
+    self.value = 2
+    @either_or = returning(Object.new) do |obj|
+      def obj.does
+        self
+      end
+      def obj.doesnt
+        nil
+      end
+      def obj.inspect
+        "either-or"
+      end
+      def obj.to_s
+        "either-or"
+      end
+    end
+  end
+  
+  def test_let
+    assert_equal(1, let(@one) { |box| box.value } )
+    assert_equal(2, let(@one) { value } )
+    let(@one) { self.value = 3 }
+    assert_equal(3, self.value)
+    assert_equal(Box.new(1), @one)
+  end
+  
+  def test_returning
+    assert_equal(Box.new(1), returning(@one) { |box| box.value } )
+    assert_equal(Box.new(1), returning(@one) { value } )
+    returning(@one) { self.value = 3 }
+    assert_equal(3, self.value)
+    assert_equal(Box.new(1), @one)
+  end
+  
+  def test_my
+    assert_equal(1, my(@one) { |box| box.value } )
+    assert_equal(1, my(@one) { value } )
+    my(@one) { self.value = 3 }
+    assert_equal(2, self.value)
+    assert_equal(Box.new(3), @one)
+  end
+  
+  def test_inside
+    assert_equal(Box.new(1), inside(@one) { |box| box.value } )
+    assert_equal(Box.new(1), inside(@one) { value } )
+    inside(@one) { self.value = 3 }
+    assert_equal(2, self.value)
+    assert_equal(Box.new(3), @one)
+  end
+  
+  def test_maybe
+    assert_equal(@either_or, maybe(@either_or) do |e| e; end)
+    assert_equal(@either_or, maybe(@either_or) do |obj|
+      obj.does.does.does.does
+    end)
+    assert_nil(maybe(@either_or) do |obj|
+      obj.doesnt.doesnt.doesnt.doesnt.doesnt
+    end)
+    assert_equal(@either_or, maybe(@either_or) do |outer|
+      maybe(outer.does.does) do |inner|
+        inner.does.does.does
+      end
+    end)
+  end
+  
+  def test_try
+    assert_equal(@either_or, try(@either_or) do |obj|
+      obj.does.does.does.does
+    end
+    )
+    assert_nil(try(@either_or) do |obj|
+      obj.never.never.never.never
+    end
+    )
+  end
+  
+  def test_invocation_super_sugar
+     assert_nil(@either_or.maybe.doesnt)
+     assert_nil(
+      maybe(@either_or) do |obj|
+        obj.__send__(:doesnt)
+      end
+     )
+     assert_not_nil(
+      maybe(@either_or) do |obj|
+        obj.__send__(:does)
+      end
+     )
+     assert_not_nil(@either_or.maybe.does)
+     assert_nil(@either_or.try.never)
+     assert_not_nil(@either_or.try.does)
+  end
+  
+  def test_please
+    assert_nil(
+      please(:foo) { bar.blitz }
+    )
+  end
+  
+end

data/website/index.html

@@ -0,0 +1,329 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+  <link rel="stylesheet" href="stylesheets/screen.css" type="text/css" media="screen" />
+  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+  <title>
+      Invocation Construction Kit
+  </title>
+  <script src="javascripts/rounded_corners_lite.inc.js" type="text/javascript"></script>
+<style>
+
+</style>
+  <script type="text/javascript">
+    window.onload = function() {
+      settings = {
+          tl: { radius: 10 },
+          tr: { radius: 10 },
+          bl: { radius: 10 },
+          br: { radius: 10 },
+          antiAlias: true,
+          autoPad: true,
+          validTags: ["div"]
+      }
+      var versionBox = new curvyCorners(settings, document.getElementById("version"));
+      versionBox.applyCornersToAll();
+    }
+  </script>
+</head>
+<body>
+<div id="main">
+
+    <h1>Invocation Construction Kit</h1>
+    <div id="version" class="clickable" onclick='document.location = "http://rubyforge.org/projects/ick"; return false'>
+      <p>Get Version</p>
+      <a href="http://rubyforge.org/projects/ick" class="numbers">0.0.2</a>
+    </div>
+    <h1>&#x2192; &#8216;ick&#8217;</h1>
+
+
+	<h2>What</h2>
+
+
+	<p>The Generalized Greenspun Rule: <em>Any sufficiently complicated platform contains an ad hoc, informally-specified, bug-ridden, slow implementation of half of a functional programming language.</em></p>
+
+
+	<p>While Ruby provides an ad hoc, informally-specified, bug-ridden, slow implementation of half of higher-order functional programming, it lacks an ad hoc, informally-specified, bug-ridden, slow implementation of half of Monads.</p>
+
+
+	<p>Thus, the <strong>Invocation Construction Kit</strong>, or &#8220;Ick!&#8221; Ick provides the tools needed to easily build your own execution abstractions like the &#8220;Maybe&#8221; monad or the four canonical block evaluators, as well as providing some sugar so you can write things like:</p>
+
+
+	<p><pre class='syntax'>
+<span class="ident">please</span><span class="punct">(</span><span class="ident">sir</span><span class="punct">)</span> <span class="punct">{</span> <span class="ident">may</span><span class="punct">.</span><span class="ident">i</span><span class="punct">.</span><span class="ident">have</span><span class="punct">.</span><span class="ident">some</span><span class="punct">.</span><span class="ident">more</span> <span class="punct">}</span>
+</pre></p>
+
+
+	<h2>Installing</h2>
+
+
+<pre>sudo gem install ick</pre>
+
+	<h2>Block Structured Ruby</h2>
+
+
+	<p>Although Ruby borrows many of its features from Lisp and its syntax from Algol, it does not have block-local variables. In other words, if you declare a variable anywhere inside of a method, that variable is visible everywhere in that method. This is a problem, because it encourages writing methods where the instance variables create lot of dependencies between different expressions. Those methods can be hard to understand and refactor.</p>
+
+
+	<p>Ick solves this problem by providing four block structure methods: #let, #returning, #my, and #inside. These methods take an expression and bind it to a variable inside of a block. For example, if you want someone&#8217;s phone number only if they are a friend:</p>
+
+
+	<p><pre class='syntax'>
+<span class="ident">let</span><span class="punct">(</span><span class="constant">Person</span><span class="punct">.</span><span class="ident">find</span><span class="punct">(</span><span class="symbol">:first</span><span class="punct">,</span> <span class="punct">...))</span> <span class="punct">{</span> <span class="punct">|</span><span class="ident">person</span><span class="punct">|</span> <span class="ident">person</span><span class="punct">.</span><span class="ident">phone_number</span> <span class="keyword">if</span> <span class="ident">person</span><span class="punct">.</span><span class="ident">friend?</span> <span class="punct">}</span>
+</pre></p>
+
+
+	<p>This code makes it clear that you only need the <code>person</code> variable inside the block. If you want to refactor this code, you know that the entire expression can move without breaking another piece of code. We&#8217;ll elaborate on the differences between #let, #returning, #my, and #inside below.</p>
+
+
+	<p>(The four methods were inspired by <a href="http://blog.rubyenrails.nl/articles/2008/02/18/our-daily-method-10-object-r-rs-ds-s">Michiel de Mare&#8217;s post on the same subject</a>, although Ick&#8217;s nomenclature is not compatible with Michiel&#8217;s. Michiel&#8217;s #with, #tap, and #switch are called #returning, #let, and #inside in Ick. And Ick&#8217;s #my is fairly superfluous, it does exactly the same thing as Object#instance_eval.)</p>
+
+
+	<h2>Guarded Evaluation</h2>
+
+
+	<p>The example above is a common one. Sometimes we want to evaluate a chain of method calls without throwing a <code>NoMethodError</code> if one of the recipients is nil. Sometimes we want to send something a message if and only if it handles the method. There are lots of ad-hoc solutions, including <a href="http://andand.rubyforge.org">Object#andand</a>. What if you don&#8217;t want to install lots of different gems, one for each use?</p>
+
+
+	<p>Ick solves this problem by providing a structure for rolling your own guarded evaluation. You can check for nil, #respond_to?, custom permissions, whatever you like. It looks like this:</p>
+
+
+	<p><pre class='syntax'>
+<span class="keyword">class </span><span class="class">Try</span> <span class="punct">&lt;</span> <span class="constant">Ick</span><span class="punct">::</span><span class="constant">Guarded</span>
+  <span class="ident">guard_with</span> <span class="punct">{</span> <span class="punct">|</span><span class="ident">value</span><span class="punct">,</span> <span class="ident">sym</span><span class="punct">|</span> <span class="ident">value</span><span class="punct">.</span><span class="ident">respond_to?</span><span class="punct">(</span><span class="ident">sym</span><span class="punct">)</span> <span class="punct">==</span> <span class="constant">true</span> <span class="punct">}</span>
+  <span class="ident">evaluates_in_calling_environment</span> <span class="keyword">and</span> <span class="ident">returns_result</span>
+  <span class="ident">belongs_to</span> <span class="constant">Object</span>
+<span class="keyword">end</span>
+
+<span class="ident">try</span><span class="punct">(...)</span> <span class="punct">{</span> <span class="punct">|</span><span class="ident">sir</span><span class="punct">|</span> <span class="ident">sir</span><span class="punct">.</span><span class="ident">may</span><span class="punct">.</span><span class="ident">i</span><span class="punct">.</span><span class="ident">have</span><span class="punct">.</span><span class="ident">some</span><span class="punct">.</span><span class="ident">more</span> <span class="punct">}</span>
+</pre></p>
+
+
+	<p>(Try is built into Ick and was inspired by Chris Wanstrath&#8217;s <a href="http://ozmm.org/posts/try.html">try()</a> and Chalain&#8217;s <a href="http://chalain.livejournal.com/66798.html">Turtles</a>)</p>
+
+
+	<p>Maybe does exactly the same thing with checking nil rather than whether an object responds to a message:</p>
+
+
+	<p><pre class='syntax'>
+<span class="ident">maybe</span><span class="punct">(...)</span> <span class="punct">{</span> <span class="punct">|</span><span class="ident">person</span><span class="punct">|</span> <span class="ident">person</span><span class="punct">.</span><span class="ident">manager</span><span class="punct">.</span><span class="ident">authority_level</span><span class="punct">.</span><span class="ident">permissions</span> <span class="punct">}</span>
+</pre></p>
+
+
+	<p>Both #try and #maybe are <em>contagious</em>: everything in the chain inside the block is guarded.</p>
+
+
+	<h2>More sugar!</h2>
+
+
+	<p>If you just want to call a method by name without parameters, the existing blocks work well with Symbol#to_proc:</p>
+
+
+	<p><pre class='syntax'>
+<span class="ident">maybe</span><span class="punct">(</span><span class="constant">Person</span><span class="punct">.</span><span class="ident">find</span><span class="punct">(</span><span class="symbol">:first</span><span class="punct">,</span> <span class="punct">...),</span> <span class="punct">&amp;</span><span class="symbol">:manager</span><span class="punct">)</span>
+</pre></p>
+
+
+	<p>But you can also use these methods the way Object#andand works:</p>
+
+
+	<p><pre class='syntax'>
+<span class="constant">Person</span><span class="punct">.</span><span class="ident">find</span><span class="punct">(</span><span class="symbol">:first</span><span class="punct">,</span> <span class="punct">...).</span>
+	<span class="ident">maybe</span><span class="punct">.</span><span class="ident">time_cards</span><span class="punct">.</span>
+	<span class="ident">maybe</span><span class="punct">.</span><span class="ident">map</span><span class="punct">(&amp;</span><span class="symbol">:hours_worked</span><span class="punct">).</span>
+	<span class="ident">maybe</span><span class="punct">.</span><span class="ident">inject</span><span class="punct">(</span><span class="number">0</span><span class="punct">,</span> <span class="punct">&amp;:+)</span>
+</pre></p>
+
+
+	<p>When you do that, you have to keep calling the method in order to chain them all together, so you might prefer:</p>
+
+
+	<p><pre class='syntax'>
+<span class="ident">maybe</span><span class="punct">(</span><span class="constant">Person</span><span class="punct">.</span><span class="ident">find</span><span class="punct">(</span><span class="symbol">:first</span><span class="punct">,</span> <span class="punct">...))</span> <span class="punct">{</span> <span class="punct">|</span><span class="ident">p</span><span class="punct">|</span> 
+	<span class="ident">p</span><span class="punct">.</span><span class="ident">time_cards</span><span class="punct">.</span><span class="ident">map</span><span class="punct">(&amp;</span><span class="symbol">:hours_worked</span><span class="punct">).</span><span class="ident">inject</span><span class="punct">(</span><span class="number">0</span><span class="punct">,</span> <span class="punct">&amp;:+)</span> 
+<span class="punct">}</span>
+</pre></p>
+
+
+	<p>The Object#andand-style syntax is most useful when you&#8217;re just using it for a single method invocation, such as:</p>
+
+
+	<p><pre class='syntax'>
+<span class="constant">Person</span><span class="punct">.</span><span class="ident">find</span><span class="punct">(</span><span class="symbol">:first</span><span class="punct">,</span> <span class="punct">...).</span><span class="ident">maybe</span><span class="punct">.</span><span class="ident">salary</span> <span class="punct">=</span> <span class="number">42</span><span class="punct">,</span><span class="number">000</span>
+</pre></p>
+
+
+	<h3>(But I heard that Ick is destroying Ruby&#8253;)</h3>
+
+
+	<p>Have no fear of that. Ick will not modify any classes without permission. Out of the box, you cannot call any of Ick&#8217;s built in methods the way you see them in these examples. Instead of <code>please(sir) {...}</code> you actually have to call <code>Ick::Please.instance.invoke(sir) {...}</code>. If you want to install one or more of the built-in methods in to the Object class, you call #belongs_to. For example, to install the Maybe and Let methods but no others:</p>
+
+
+	<p><pre class='syntax'>
+<span class="constant">Ick</span><span class="punct">::</span><span class="constant">Maybe</span><span class="punct">.</span><span class="ident">belongs_to</span> <span class="constant">Object</span>
+<span class="constant">Ick</span><span class="punct">::</span><span class="constant">Let</span><span class="punct">.</span><span class="ident">belongs_to</span> <span class="constant">Object</span>
+</pre></p>
+
+
+	<p>You could also install some or all of the methods into a single class where you think you&#8217;ll be using them a lot but nowhere else:</p>
+
+
+	<p><pre class='syntax'>
+<span class="keyword">class </span><span class="class">MyAwesomeImplementationOfAsteroids</span>
+	<span class="punct">[</span><span class="constant">Ick</span><span class="punct">::</span><span class="constant">Let</span><span class="punct">,</span> <span class="constant">Ick</span><span class="punct">::</span><span class="constant">Returning</span><span class="punct">,</span> <span class="constant">Ick</span><span class="punct">::</span><span class="constant">My</span><span class="punct">,</span> <span class="constant">Ick</span><span class="punct">::</span><span class="constant">Inside</span><span class="punct">].</span><span class="ident">each</span> <span class="keyword">do</span> <span class="punct">|</span><span class="ident">clazz</span><span class="punct">|</span>
+		<span class="ident">clazz</span><span class="punct">.</span><span class="ident">belongs_to</span> <span class="constant">self</span>
+	<span class="keyword">end</span>
+<span class="keyword">end</span>
+</pre></p>
+
+
+	<p>If you simply want everything you see here working exactly as it&#8217;s shown, simply call <code>Ick.sugarize</code> once and all of the built-in methods will be installed into Object for you. You can put that in your environment.rb file if you&#8217;re using Rails.</p>
+
+
+	<p>The point is, <code>try(program) { responsibly }</code>. You choose which classes to open and which methods to add. <a href="http://avdi.org/devblog/2008/02/25/full-disclosure/">All I’m saying is this: before re-opening a class, did you go through the rest of your toolbox first?</a></p>
+
+
+	<h2>More about the four block structures</h2>
+
+
+	<p>There are two binary decisions to be made about every block: First, do you want to evaluate the block in the calling environment (which is how almost every block is evaluated in Ruby), or do you want to evaluate the block in the value&#8217;s context. In other words, does <em>self</em> stay the same, or does it become the value in the block?</p>
+
+
+	<p>The methods #try and #maybe are both implemented as <em>evaluates_in_calling_environment</em>, because that is least surprising. But when you&#8217;re rolling your own, you might want to change that to make things more sugary. For example, here is a different version of #try:</p>
+
+
+	<p><pre class='syntax'>
+<span class="keyword">class </span><span class="class">Please</span> <span class="punct">&lt;</span> <span class="constant">Ick</span><span class="punct">::</span><span class="constant">Guarded</span>
+  <span class="ident">guard_with</span> <span class="punct">{</span> <span class="punct">|</span><span class="ident">value</span><span class="punct">,</span> <span class="ident">sym</span><span class="punct">|</span> <span class="ident">value</span><span class="punct">.</span><span class="ident">respond_to?</span><span class="punct">(</span><span class="ident">sym</span><span class="punct">)</span> <span class="punct">==</span> <span class="constant">true</span> <span class="punct">}</span>
+  <span class="ident">evaluates_in_value_environment</span> <span class="keyword">and</span> <span class="ident">returns_result</span>
+  <span class="ident">belongs_to</span> <span class="constant">Object</span>
+<span class="keyword">end</span>
+
+<span class="ident">please</span><span class="punct">(...)</span> <span class="punct">{</span> <span class="ident">may</span><span class="punct">.</span><span class="ident">i</span><span class="punct">.</span><span class="ident">have</span><span class="punct">.</span><span class="ident">some</span><span class="punct">.</span><span class="ident">more</span> <span class="punct">}</span>
+</pre></p>
+
+
+	<p>The method #please executes in the value&#8217;s environment, and thus it can call methods directly.</p>
+
+
+	<p>You already saw #let, it takes your expression and binds it to a parameter, then it evaluates a block in the calling environment, just as #try evaluates and guards its block in the calling environment. If you want something that behaves like #let but evaluates in the value&#8217;s environment just like #please, you can use #my:</p>
+
+
+	<p><pre class='syntax'>
+<span class="ident">my</span><span class="punct">(</span><span class="constant">Person</span><span class="punct">.</span><span class="ident">find</span><span class="punct">(</span><span class="symbol">:first</span><span class="punct">,</span> <span class="punct">...))</span> <span class="keyword">do</span>
+	<span class="ident">first_name</span> <span class="punct">=</span> <span class="punct">'</span><span class="string">Charles</span><span class="punct">'</span>
+	<span class="ident">last_name</span> <span class="punct">=</span> <span class="punct">'</span><span class="string">Babbage</span><span class="punct">'</span>
+	<span class="ident">friends</span> <span class="punct">&lt;&lt;</span> <span class="punct">'</span><span class="string">Ada Lovelace</span><span class="punct">'</span>
+<span class="keyword">end</span>
+</pre></p>
+
+
+	<p>This will return Charles Babbage&#8217;s friends. On the surface, <em>evaluates_in_value_environment</em> is about the syntactic sugar of dropping an instance variable. But with a little thought, you can come up with some really cool way to (mis)use this capability.</p>
+
+
+	<p>So #let and #my both pass an expression to a block and return the result. Given that they both &#8216;declare&#8217; <em>returns_result</em>, this is not surprising. But there is another choice: <em>returns_value</em> instead of <em>returns_result</em>. Ruby on Rails includes the popular #returning method, and it works the same in Ick:</p>
+
+
+	<p><pre class='syntax'>
+<span class="ident">returning</span><span class="punct">(</span><span class="constant">Person</span><span class="punct">.</span><span class="ident">find</span><span class="punct">(</span><span class="symbol">:first</span><span class="punct">,</span> <span class="punct">...))</span> <span class="keyword">do</span> <span class="punct">|</span><span class="ident">p</span><span class="punct">|</span>
+	<span class="ident">p</span><span class="punct">.</span><span class="ident">first_name</span> <span class="punct">=</span> <span class="punct">'</span><span class="string">Charles</span><span class="punct">'</span>
+	<span class="ident">p</span><span class="punct">.</span><span class="ident">last_name</span> <span class="punct">=</span> <span class="punct">'</span><span class="string">Babbage</span><span class="punct">'</span>
+	<span class="ident">p</span><span class="punct">.</span><span class="ident">friends</span> <span class="punct">&lt;&lt;</span> <span class="punct">'</span><span class="string">Ada Lovelace</span><span class="punct">'</span>
+<span class="keyword">end</span>
+</pre></p>
+
+
+	<p>This returns the person record, not the list of friends. The block is evaluated strictly for side effects. And what happens if we want to return the value and also evaluate in the value&#8217;s environment?</p>
+
+
+	<p><pre class='syntax'>
+<span class="ident">inside</span><span class="punct">(</span><span class="constant">Person</span><span class="punct">.</span><span class="ident">find</span><span class="punct">(</span><span class="symbol">:first</span><span class="punct">,</span> <span class="punct">...))</span> <span class="keyword">do</span>
+	<span class="ident">first_name</span> <span class="punct">=</span> <span class="punct">'</span><span class="string">Charles</span><span class="punct">'</span>
+	<span class="ident">last_name</span> <span class="punct">=</span> <span class="punct">'</span><span class="string">Babbage</span><span class="punct">'</span>
+	<span class="ident">friends</span> <span class="punct">&lt;&lt;</span> <span class="punct">'</span><span class="string">Ada Lovelace</span><span class="punct">'</span>
+<span class="keyword">end</span>
+</pre></p>
+
+
+	<p>The method #inside returns the value and evaluates the block in the value&#8217;s environment.</p>
+
+
+	<h2>Under the Hood</h2>
+
+
+	<p>Ick is actually a construction kit. By all means install the gem and go wild with #let, #returning, #my, #inside, #try, and #maybe. But have a look under the hood. It&#8217;s easy to build your own methods.</p>
+
+
+	<h3>Every programming problem can be solved with another layer of abstraction, except the problem of too many layers of abstraction</h3>
+
+
+	<p>Ick uses classes and template methods to replicate what can be done in a few lines of explicit code. For example, Object#returning is implemented in Rails as:</p>
+
+
+	<p><pre class='syntax'>
+<span class="keyword">class </span><span class="class">Object</span>
+  <span class="keyword">def </span><span class="method">returning</span><span class="punct">(</span><span class="ident">value</span><span class="punct">)</span>
+    <span class="keyword">yield</span><span class="punct">(</span><span class="ident">value</span><span class="punct">)</span>
+    <span class="ident">value</span>
+  <span class="keyword">end</span>
+<span class="keyword">end</span>
+</pre></p>
+
+
+	<p>So why bother with Ick? Well, Ick is a construction kit. if you want to make a method just like Object#returning, only <em>X</em> (for some value of X), you can&#8217;t do that without copying, pasting, and modifying. Ick&#8217;s classes are included specifically so you can subclass things and make your own new kinds of methods that are variations of the existing methods.</p>
+
+
+	<p>Thus, the extra abstraction is appropriate if you want to use the built-in methods as a starting point for your own exploratory programming. And if you don&#8217;t care, you just want the methods, by all means install the gem and just use them. Don&#8217;t worry about the implementation unless you identify it as a performance problem.</p>
+
+
+	<h3>Where do you want to go today?</h3>
+
+
+	<p>The point behind abstracting invocation and evaluation is that you can <em>separate concerns</em>. For example, which methods to chain is one concern. How to handle nil or an object that does not respond to a method is a separate concern. Should you raise and handle and exception? Return nil? log an error? Why should error handling and logging be intermingled with your code?</p>
+
+
+	<p>With Ick, you can separate the two issues. You can even make the handling pluggable. For example, if instead of calling #let you call your own method, you could sometimes invoke <code>Ick::Let</code> with a block and other times invoke your own handler, perhaps one that logs every method called.</p>
+
+
+	<p>Ick raises how you handle things to the level of first-class objects in Ruby, so you can mix and match and separate concerns as you see fit. Logging, permissions, error handling&#8230; These are some of the places you can take Ick. Have fun.</p>
+
+
+	<h2>Administrivia</h2>
+
+
+	<h3>How to submit patches</h3>
+
+
+	<p>Read the <a href="http://drnicwilliams.com/2007/06/01/8-steps-for-fixing-other-peoples-code/">8 steps for fixing other people&#8217;s code</a>.</p>
+
+
+	<p>The trunk repository is <code>svn://rubyforge.org/var/svn/ick/trunk</code> for anonymous access.</p>
+
+
+	<h3>License</h3>
+
+
+	<p>This code is free to use under the terms of the <a href="http://en.wikipedia.org/wiki/MIT_License"><span class="caps">MIT</span> license</a>.</p>
+
+
+	<h3>Shout Out</h3>
+
+
+	<p><a href="http://mcommons.com/">Mobile Commons</a>. Still Huge After All These Years.</p>
+
+
+	<h3>Contact</h3>
+
+
+	<p>Comments are welcome. Send an email to <a href="mailto:raganwald+rubyforge@gmail.com">Reginald Braithwaite</a>. And you can always visit <a href="http://weblog.raganwald.com/">weblog.raganwald.com</a> to see what&#8217;s cooking.</p>
+    <p class="coda">
+      <a href="http://weblog.raganwald.com/">Reginald Braithwaite</a>, 7th March 2008<br>
+      Theme extended from <a href="http://rb2js.rubyforge.org/">Paul Battley</a>
+    </p>
+</div>
+
+<!-- insert site tracking codes here, like Google Urchin -->
+
+</body>
+</html>