zucker 0.9 → 1

data/Rakefile

@@ -3,10 +3,11 @@ require 'rake/gempackagetask'
 require 'rubygems'
 require 'spec/rake/spectask'
 
+# gem
 PKG_FILES = FileList[ '[a-zA-Z]*', 'lib/**/*' ]
 spec = Gem::Specification.new do |s|
   s.name = 'zucker'
-  s.version = '0.9'
+  s.version = '1'
   s.date = '2010-08-05'
   s.authors = ['Jan Lelis']
   s.email = 'mail@janlelis.de'
@@ -16,7 +17,6 @@ spec = Gem::Specification.new do |s|
   s.require_paths = [".","lib"]
 end
 
-desc 'build gem'
 Rake::GemPackageTask.new(spec) do |pkg|
   pkg.gem_spec = spec
 end

data/lib/zucker.rb

@@ -1,5 +1,9 @@
+module Zucker
+  VERSION = '1'
+end
+
 # nothing is done here
-# to use zucker:
+#  to use zucker:
 
 # require 'zucker/default'
 
@@ -8,3 +12,4 @@
 # require 'zucker/debug'
 
 #  or cherry-pick the cubes you want ;)
+

data/lib/zucker/1/{descriptions → desc}/D.yaml

@@ -3,7 +3,7 @@ D:
   methods:
     Object#D: |
       some.D.methods.D.noone.D.knows.D
-      # ...outputs 4 lines with the inspected object
+      # ...outputs 4 lines with the inspected objects
       # => (result)
 
       21+Math.sin(42).D
@@ -16,10 +16,8 @@ D:
       # => 'Hello Earth'
   package: debug
   info:
-  - "This is inspired by the funny ⇧.tap⇧ method: http://moonbase.rydia.net/mental/blog/programming/eavesdropping-on-expressions"
+  - "This is inspired by the funny →⇧.tap⇧ method→http://moonbase.rydia.net/mental/blog/programming/eavesdropping-on-expressions→"
   versions:
   - 1.9
   - 1.8
-  authors:
-  - Jan Lelis
 

data/lib/zucker/1/{descriptions → desc}/aliases.yaml

@@ -13,6 +13,4 @@ aliases:
   versions:
   - 1.9
   - 1.8
-  authors:
-  - Jan Lelis
 

data/lib/zucker/1/{descriptions → desc}/array.yaml

@@ -1,5 +1,5 @@
 array:
-  summary: Methods one could miss for ⇧Array⇧
+  summary: Methods one could miss for ⇧Array⇧.
   why:
   - ⇧Array⇧ has ⇧&⇧ and ⇧|⇧, but why does it not have ⇧^⇧?
   - ⇧sum⇧ is an alias for ⇧inject(:+)⇧, but it is just needed pretty often!
@@ -11,6 +11,4 @@ array:
   versions:
   - 1.9
   - 1.8
-  authors:
-  - Jan Lelis
 

data/lib/zucker/1/{descriptions → desc}/array2proc.yaml

@@ -4,12 +4,10 @@ array2proc:
   methods:
     Array#to_proc: '[1,2,3,4].map( &[:to_s, 2] )  # => ["1", "10", "11", "100"]'
   info:
-  - Inspired by http://www.sanityinc.com/articles/adding-array-to-proc-to-ruby
-  - "More about to_proc: http://rbjl.net/29-become-a-proc-star"
+  - Inspired by →this article→http://www.sanityinc.com/articles/adding-array-to-proc-to-ruby→.
+  - "More about →to_proc→http://rbjl.net/29-become-a-proc-star→."
   package: default
   versions:
   - 1.9
   - 1.8
-  authors:
-  - Jan Lelis
 

data/lib/zucker/1/{descriptions → desc}/binding.yaml

@@ -7,6 +7,4 @@ binding:
   versions:
   - 1.9
   - 1.8
-  authors:
-  - Jan Lelis
 

data/lib/zucker/1/{descriptions → desc}/blank.yaml

@@ -9,6 +9,4 @@ blank:
   versions:
   - 1.9
   - 1.8
-  authors:
-  - Jan Lelis (this implementation)
 

data/lib/zucker/1/{descriptions → desc}/class2proc.yaml

@@ -4,12 +4,9 @@ class2proc:
     Class#to_proc: "[ [1,2],[3,5,6,7,3] ].map(&Set) # => [ Set[1,2], Set[5,6,7,3] ]"
   package: default
   info:
-  - Inspired by Ruby Facets
-  - "More about to_proc: http://rbjl.net/29-become-a-proc-star"
+  - Inspired by Ruby Facets.
+  - "More about →to_proc→http://rbjl.net/29-become-a-proc-star→."
   versions:
   - 1.9
   - 1.8
-  authors:
-  - Facet authors
-  - Jan Lelis (this implementation)
 

data/lib/zucker/1/{descriptions → desc}/egonil.yaml

@@ -1,5 +1,5 @@
 egonil:
-  summary: Creates a block, where ⇧nil⇧ does not raise ⇧NoMethodError⇧s
+  summary: Creates a block, where ⇧nil⇧ does not raise ⇧NoMethodError⇧s.
   methods:
     egonil, nn: |
       egonil do
@@ -10,11 +10,8 @@ egonil:
       # => 5
   package: default
   info:
-  - See http://rbjl.net/26-the-28-bytes-of-ruby-joy for more information and discussion
+  - See →this post→http://rbjl.net/26-the-28-bytes-of-ruby-joy→ for more information and discussion
   versions:
   - 1.9
   - 1.8
-  authors:
-  - Jan Lelis
-  - Yohan
 

data/lib/zucker/1/{descriptions → desc}/enumerable.yaml

@@ -8,6 +8,4 @@ enumerable:
   versions:
   - 1.9
   - 1.8
-  authors:
-  - Jan Lelis
 

data/lib/zucker/1/{descriptions → desc}/hash.yaml

@@ -9,6 +9,4 @@ hash:
   versions:
   - 1.9
   - 1.8
-  authors:
-  - Jan Lelis
 

data/lib/zucker/1/{descriptions → desc}/hash2proc.yaml

@@ -4,10 +4,8 @@ hash2proc:
     Hash#to_proc: "[1,2,3,4].map(&{\n2 => lambda {|e| e + 1000},\n4 => :to_s,\n}) # => [1, 1002, 3, '4']"
   package: default
   info:
-  - "More about to_proc: http://rbjl.net/29-become-a-proc-star"
+  - "More about →to_proc→http://rbjl.net/29-become-a-proc-star→."
   versions:
   - 1.9
   - 1.8
-  authors:
-  - Jan Lelis
 

data/lib/zucker/1/{descriptions → desc}/iterate.yaml

@@ -4,7 +4,7 @@ iterate:
   methods:
     iterate: |
       iterate [1,2], [3,4,5] do |e,f|
-        puts ”#{e},#{f}”
+        puts "#{e},#{f}"
       end
       # outputs
       #  1,3
@@ -14,6 +14,4 @@ iterate:
   versions:
   - 1.9
   - 1.8
-  authors:
-  - Jan Lelis
 

data/lib/zucker/1/{descriptions → desc}/ivars.yaml

@@ -11,12 +11,10 @@ ivars:
         instance_variables_from binding # assigns @a and @b
 
         params = {:c => 3, :d => 4}
-        ivars params # # assigns @c and @d
+        instance_variables_from params # # assigns @c and @d
       end
   package: default
   versions:
   - 1.9
   - 1.8
-  authors:
-  - Jan Lelis
 

data/lib/zucker/1/{descriptions → desc}/mcopy.yaml

@@ -9,6 +9,4 @@ mcopy:
   versions:
   - 1.9
   - 1.8
-  authors:
-  - Jan Lelis
 

data/lib/zucker/1/{descriptions → desc}/mm.yaml

@@ -5,10 +5,8 @@ mm:
     Object#method_list, Object#mm: "'test'.mm 2 # outputs the list (2 levels deep)"
   package: debug
   info:
-  - See http://rbjl.net/31-the-multi-mega-method-list for more information
+  - See →this article→http://rbjl.net/31-the-multi-mega-method-list→ for more information
   versions:
   - 1.9
   - 1.8
-  authors:
-  - Jan Lelis (this implementation)
 

data/lib/zucker/1/{descriptions → desc}/regexp2proc.yaml

@@ -6,10 +6,8 @@ regexp2proc:
       %w|just another string array|.select &/[jy]/  # => ["just", "array"]
   package: default
   info:
-  - "More about to_proc: http://rbjl.net/29-become-a-proc-star"
+  - "More about →to_proc→http://rbjl.net/29-become-a-proc-star→."
   versions:
   - 1.9
   - 1.8
-  authors:
-  - Jan Lelis
 

data/lib/zucker/1/{descriptions → desc}/sandbox.yaml

@@ -11,6 +11,4 @@ sandbox:
   versions:
   - 1.9
   - 1.8
-  authors:
-  - Jan Lelis
 

data/lib/zucker/1/{descriptions → desc}/square_brackets_for.yaml

@@ -20,6 +20,4 @@ square_brackets_for:
   versions:
   - 1.9
   - 1.8
-  authors:
-  - Jan Lelis
 

data/lib/zucker/1/{descriptions → desc}/string.yaml

@@ -10,6 +10,4 @@ string:
   versions:
   - 1.9
   - 1.8
-  authors:
-  - Jan Lelis
 

data/lib/zucker/1/desc/unary.yaml

@@ -0,0 +1,15 @@
+unary:
+  summary: Easy conversion between strings and symbols.
+  why: "Sometimes, you do not care if you get a ⇧String⇧ or ⇧Symbol⇧ as input - but when analysing it, you often need to choose one format. A concise possibility for this conversion is using the unary operators ⇧String#-@⇧ and ⇧Symbol#+@⇧"
+  methods:
+    String#+@: "+'was_string' # => 'was_string'"
+    String#-@: "-'was_string' # => :was_string"
+    Symbol#+@: "+:was_symbol  # => 'was_symbol'"
+    Symbol#-@: "-:was_symbol  # => :was_symbol"
+  package: default
+  info:
+  - "Inspired by (I've seen the unary + for Symbol somewhere on the net... but cannot remember where...)"
+  versions:
+  - 1.9
+  - 1.8 (+:literal not possible)
+

data/lib/zucker/1/{documentation → doc}/zucker_doc.html

@@ -135,39 +135,163 @@ code, pre{
 .source{
   display:none;
   border:1px solid #005;
-  background:#111;
-  padding:5px;
+#  background:#111;
   width:98%;
 
-  background-color: #232323;
+#  background-color: #232323;
 #  border: 1px solid black;
-  font-family: 'Courier New', 'Terminal', monospace;
-  color: #E6E0DB;
+#  font-family: 'Courier New', 'Terminal', monospace;
+#  color: #E6E0DB;
   padding: 3px 5px;
 #  margin-right:1em;
   overflow: auto;
   font-size: 12px;
+  background-color: #f8f8f8;
+  border: 1px solid silver;
+  font-family: 'Courier New', 'Terminal', monospace;
+  color: #000;
+}
+
+#/*railscasts*/
+#.source .an { color:#E7BE69 }                      /* html attribute */
+#.source .c  { color:#BC9358; font-style: italic; } /* comment */
+#.source .ch { color:#509E4F }                      /* escaped character */
+#.source .cl { color:#FFF }                         /* class */
+#.source .co { color:#FFF }                         /* constant */
+#.source .fl { color:#A4C260 }                      /* float */
+#.source .fu { color:#FFC56D }                      /* function */
+#.source .gv { color:#D0CFFE }                      /* global variable */
+#.source .i  { color:#A4C260 }                      /* integer */
+#.source .il { background:#151515 }                 /* inline code */
+#.source .iv { color:#D0CFFE }                      /* instance variable */
+#.source .pp { color:#E7BE69 }                      /* doctype */
+#.source .r  { color:#CB7832 }                      /* keyword */
+#.source .rx { color:#A4C260 }                      /* regex */
+#.source .s  { color:#A4C260 }                      /* string */
+#.source .sy { color:#6C9CBD }                      /* symbol */
+#.source .ta { color:#E7BE69 }                      /* html tag */
+#.source .pc { color:#6C9CBD }                      /* boolean */
+
+# http://coderay.rubychan.de/
+.source pre { margin: 0px; }
+
+span.source { white-space: pre; border: 0px; padding: 2px; }
+
+table.source { border-collapse: collapse; width: 100%; padding: 2px; }
+table.source td { padding: 2px 4px; vertical-align: top; }
+
+.source .line_numbers, .source .no {
+  background-color: #def;
+  color: gray;
+  text-align: right;
 }
+.source .line_numbers a:target, .source .no a:target { color: blue; }
+.source .line_numbers .highlighted, .source .no .highlighted { color: red; }
+.source .no { padding: 0px 4px; }
+.source .code { width: 100%; }
+.source .code pre { overflow: auto; }
+
+.source .debug { color:white ! important; background:blue ! important; }
+
+.source .an { color:#007 }
+.source .at { color:#f08 }
+.source .av { color:#700 }
+.source .bi { color:#509; font-weight:bold }
+.source .c  { color:#888; }
+.source .c .dl { color:#444; }
+.source .c .ch { color:#444; }
+
+.source .ch { color:#04D }
+.source .ch .k { color:#04D }
+.source .ch .dl { color:#039 }
+
+.source .cl { color:#B06; font-weight:bold }
+.source .cm { color:#A08; font-weight:bold }
+.source .co { color:#036; font-weight:bold }
+.source .cr { color:#0A0 }
+.source .cv { color:#369 }
+.source .de { color:#B0B; }
+.source .df { color:#099; font-weight:bold }
+.source .di { color:#088; font-weight:bold }
+.source .dl { color:black }
+.source .do { color:#970 }
+.source .dt { color:#34b }
+.source .ds { color:#D42; font-weight:bold }
+.source .e  { color:#666; font-weight:bold }
+.source .en { color:#800; font-weight:bold }
+.source .er { color:#F00; background-color:#FAA }
+.source .ex { color:#C00; font-weight:bold }
+.source .fl { color:#60E; font-weight:bold }
+.source .fu { color:#06B; font-weight:bold }
+.source .gv { color:#d70; font-weight:bold }
+.source .hx { color:#058; font-weight:bold }
+.source .i  { color:#00D; font-weight:bold }
+.source .ic { color:#B44; font-weight:bold }
+
+.source .il { background-color: hsla(0,0%,0%,0.1); color: black }
+.source .il .idl { font-weight: bold; color: #666 }
+.source .idl { font-weight: bold; background-color: hsla(0,0%,0%,0.1); color: #666; }
+
+.source .im { color:#f00; }
+.source .in { color:#B2B; font-weight:bold }
+.source .iv { color:#33B }
+.source .la { color:#970; font-weight:bold }
+.source .lv { color:#963 }
+.source .ns { color:#707; font-weight:bold }
+.source .oc { color:#40E; font-weight:bold }
+.source .op { }
+.source .pc { color:#058; font-weight:bold }
+.source .pd { color:#369; font-weight:bold }
+.source .pp { color:#579; }
+.source .ps { color:#00C; font-weight:bold }
+.source .pt { color:#074; font-weight:bold }
+.source .r, .kw  { color:#080; font-weight:bold }
+
+.source .ke { color: #808; }
+.source .ke .dl { color: #606; }
+.source .ke .ch { color: #80f; }
+.source .vl { color: #088; }
+
+.source .rx { background-color:hsla(300,100%,50%,0.1); }
+.source .rx .k { color:#808 }
+.source .rx .dl { color:#404 }
+.source .rx .mod { color:#C2C }
+.source .rx .fu  { color:#404; font-weight: bold }
+
+.source .s { background-color:hsla(0,100%,50%,0.1); }
+.source .s .k { color: #D20; }
+.source .s .ch { color: #b0b; }
+.source .s .dl { color: #710; }
+
+.source .sh { background-color:hsla(120,100%,50%,0.1); }
+.source .sh .k { color:#2B2 }
+.source .sh .dl { color:#161 }
+
+.source .sy { color:#A60 }
+.source .sy .k { color:#A60 }
+.source .sy .dl { color:#630 }
+
+.source .ta { color:#070 }
+.source .ts { color:#D70; font-weight:bold }
+.source .ty { color:#339; font-weight:bold }
+.source .v  { color:#036 }
+.source .xt { color:#444 }
+
+.source .ins { background: hsla(120,100%,50%,0.2) }
+.source .del { background: hsla(0,100%,50%,0.2) }
+.source .chg { color: #aaf; background: #007; }
+.source .head { color: #f8f; background: #505 }
+.source .head .filename { color: white; }
+
+.source .ins .eye { background-color: hsla(120,100%,50%,0.2) }
+.source .del .eye { background-color: hsla(0,100%,50%,0.2) }
+
+.source .ins .ins { color: #080; background:transparent; font-weight:bold }
+.source .del .del { color: #800; background:transparent; font-weight:bold }
+.source .chg .chg { color: #66f; }
+.source .head .head { color: #f4f; }
+
 
-/*railscasts*/
-.source .an { color:#E7BE69 }                      /* html attribute */
-.source .c  { color:#BC9358; font-style: italic; } /* comment */
-.source .ch { color:#509E4F }                      /* escaped character */
-.source .cl { color:#FFF }                         /* class */
-.source .co { color:#FFF }                         /* constant */
-.source .fl { color:#A4C260 }                      /* float */
-.source .fu { color:#FFC56D }                      /* function */
-.source .gv { color:#D0CFFE }                      /* global variable */
-.source .i  { color:#A4C260 }                      /* integer */
-.source .il { background:#151515 }                 /* inline code */
-.source .iv { color:#D0CFFE }                      /* instance variable */
-.source .pp { color:#E7BE69 }                      /* doctype */
-.source .r  { color:#CB7832 }                      /* keyword */
-.source .rx { color:#A4C260 }                      /* regex */
-.source .s  { color:#A4C260 }                      /* string */
-.source .sy { color:#6C9CBD }                      /* symbol */
-.source .ta { color:#E7BE69 }                      /* html tag */
-.source .pc { color:#6C9CBD }                      /* boolean */
 
   </style>
 </head>
@@ -176,7 +300,7 @@ code, pre{
 
     <h1>Ruby Zucker 1</h1>
       <h2>What is it?</h2>
-      <p class="text">Zucker is the German word for sugar (<a href="http://www.forvo.com/word/zucker/">pronunciation</a>). This gem adds syntactical sugar in the form of independent, lightweight scripts that make Ruby even more beautiful. Read <a href="http://rbjl.net/32-">this blog post</a> for a little introduction!</p>
+      <p class="text">Zucker is the German word for sugar (<a href="http://www.forvo.com/word/zucker/">pronunciation</a>). This gem adds syntactical sugar in the form of independent, lightweight scripts that make Ruby even more sweet. Read <a href="http://rbjl.net/32-introducing-ruby-zucker-a-new-syntactical-sugar-gem">this blog post</a> for a little introduction.</p>
 
       <h2>Install</h2>
       <p class="text">
@@ -191,224 +315,19 @@ code, pre{
 
       Since there aren't any dependencies within the gem, you could also pick only the cubes you want:
 
-      <code class="scode">require 'zucker/1/egonil'</code>
+      <code class="scode">require 'zucker/egonil'</code>
       </p>
-      <p class="text"><em>Please note:</em> To cherry-pick cubes, you have to allude to the gem version you want to use. Future releases of the gem will include all previous versions, so the behaviour of directly required cubes will never change (except for critical bugs).</p>
+
+      <p class="text">You can also lock your require to a specific version of Zucker by simply putting the version before the cube name in this way:
+      <code>require 'zucker/1/egonil'</code>. Future releases of the gem will include all previous (main) versions, so the behaviour of these directly required cubes will not change (except for critical bugs).</p>
 
       <h2 title="require 'zucker/all'">Cubes</h2>
       <div class="cubes">
-         <h3 title="require 'zucker/1/class2proc'">class2proc</h3>
-         <table class="cube_table"
-                id="class2proc_cube"
-                title="require 'zucker/1/class2proc'"> <tr><th>Summary</th>    <td>Creates a new instance of the class.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Class#to_proc</h5><pre class="usage source" style="display:block">[ [<span class="i">1</span>,<span class="i">2</span>],[<span class="i">3</span>,<span class="i">5</span>,<span class="i">6</span>,<span class="i">7</span>,<span class="i">3</span>] ].map(&amp;<span class="co">Set</span>) <span class="c"># =&gt; [ Set[1,2], Set[5,6,7,3] ]</span></pre></td></tr><tr><th>Further information</th>    <td>Inspired by Ruby Facets<br/>More about to_proc: http://rbjl.net/29-become-a-proc-star</td></tr><tr><th>Specification</th>    <td> <span id="show_class2proc_specification">(<a href="javascript:show('class2proc_specification')">show</a>)</span>
-         <pre class="source" id="class2proc_specification">require <span class="s"><span class="dl">'</span><span class="k">class2proc</span><span class="dl">'</span></span>
-require <span class="s"><span class="dl">'</span><span class="k">set</span><span class="dl">'</span></span>
-
-describe <span class="s"><span class="dl">'</span><span class="k">Class#to_proc</span><span class="dl">'</span></span> <span class="r">do</span>
-  it <span class="s"><span class="dl">'</span><span class="k">should create new instances of the class</span><span class="dl">'</span></span> <span class="r">do</span>
-    [ [<span class="i">1</span>,<span class="i">2</span>],[<span class="i">3</span>,<span class="i">5</span>,<span class="i">6</span>,<span class="i">7</span>,<span class="i">3</span>] ].map(&amp;<span class="co">Set</span>).should == [ <span class="co">Set</span>[<span class="i">1</span>,<span class="i">2</span>], <span class="co">Set</span>[<span class="i">5</span>,<span class="i">6</span>,<span class="i">7</span>,<span class="i">3</span>] ]
-  <span class="r">end</span>
-<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_class2proc_source">(<a href="javascript:show('class2proc_source')">show</a>)</span>
-         <pre class="source" id="class2proc_source"><span class="r">class</span> <span class="cl">Class</span>
-  <span class="r">def</span> <span class="fu">to_proc</span>
-    <span class="co">Proc</span>.new <span class="r">do</span> |*args|
-      <span class="pc">self</span>.new *args
-    <span class="r">end</span>
-  <span class="r">end</span>
-<span class="r">end</span>
-
-<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/iterate'">iterate</h3>
-         <table class="cube_table"
-                id="iterate_cube"
-                title="require 'zucker/1/iterate'"> <tr><th>Summary</th>    <td>Iterate over one or more collections.</td></tr><tr><th>Why?</th>    <td>It's like <code>.each</code> with two differences: It feels more like a control structure and you can easily iterate over multiple objects.</td></tr><tr><th>Methods/Usage</th>    <td><h5>iterate</h5><pre class="usage source" style="display:block">iterate [<span class="i">1</span>,<span class="i">2</span>], [<span class="i">3</span>,<span class="i">4</span>,<span class="i">5</span>] <span class="r">do</span> |e,f|
-  puts <span class="er">”</span><span class="c">#{e},#{f}”</span>
-<span class="r">end</span>
-<span class="c"># outputs</span>
-<span class="c">#  1,3</span>
-<span class="c">#  2,4</span>
-<span class="c">#  ,5</span>
-</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_iterate_specification">(<a href="javascript:show('iterate_specification')">show</a>)</span>
-         <pre class="source" id="iterate_specification">require <span class="s"><span class="dl">'</span><span class="k">iterate</span><span class="dl">'</span></span>
-
-describe <span class="s"><span class="dl">'</span><span class="k">Object#iterate</span><span class="dl">'</span></span> <span class="r">do</span>
-  let <span class="sy">:a</span>   <span class="r">do</span> [<span class="i">1</span>, <span class="i">2</span>, <span class="i">3</span>]     <span class="r">end</span>
-  let <span class="sy">:b</span>   <span class="r">do</span> <span class="s"><span class="dl">%w|</span><span class="k">a b c d</span><span class="dl">|</span></span>   <span class="r">end</span>
-  let <span class="sy">:res</span> <span class="r">do</span> <span class="co">Hash</span>.new {[]} <span class="r">end</span>
-
-  it <span class="s"><span class="dl">'</span><span class="k">should behave like Enumerable#each for a single argument</span><span class="dl">'</span></span> <span class="r">do</span>
-    iterate a <span class="r">do</span> |ele|
-      res[<span class="sy">:iter</span>] &lt;&lt; ele
-    <span class="r">end</span>
-
-    a.each <span class="r">do</span> |ele|
-      res[<span class="sy">:each</span>] &lt;&lt; ele
-    <span class="r">end</span>
-
-    res[<span class="sy">:iter</span>].should == res[<span class="sy">:each</span>]
-  <span class="r">end</span>
-
-  it <span class="s"><span class="dl">'</span><span class="k">should pass the right params to the block</span><span class="dl">'</span></span> <span class="r">do</span>
-    res = <span class="co">Hash</span>.new {[]} <span class="c"># TODO: why?</span>
-    res[<span class="sy">:iter_a_b</span>] = [] <span class="c"># ....</span>
-    res[<span class="sy">:iter_b_a</span>] = [] <span class="c"># ....</span>
-
-
-    iterate a, b <span class="r">do</span> |e,f|
-      res[<span class="sy">:iter_a_b</span>] &lt;&lt; [e, f]
-<span class="c">#      p res[:iter_a_b], e, f</span>
-    <span class="r">end</span>
-
-    res[<span class="sy">:iter_a_b</span>].should == [
-      [<span class="i">1</span>, <span class="s"><span class="dl">'</span><span class="k">a</span><span class="dl">'</span></span>],
-      [<span class="i">2</span>, <span class="s"><span class="dl">'</span><span class="k">b</span><span class="dl">'</span></span>],
-      [<span class="i">3</span>, <span class="s"><span class="dl">'</span><span class="k">c</span><span class="dl">'</span></span>],
-      [<span class="pc">nil</span>, <span class="s"><span class="dl">'</span><span class="k">d</span><span class="dl">'</span></span>],
-    ]
-
-    iterate b, a <span class="r">do</span> |e,f|
-      res[<span class="sy">:iter_b_a</span>] &lt;&lt; [e, f]
-    <span class="r">end</span>
-
-    res[<span class="sy">:iter_b_a</span>].should == [
-      [<span class="s"><span class="dl">'</span><span class="k">a</span><span class="dl">'</span></span>, <span class="i">1</span>],
-      [<span class="s"><span class="dl">'</span><span class="k">b</span><span class="dl">'</span></span>, <span class="i">2</span>],
-      [<span class="s"><span class="dl">'</span><span class="k">c</span><span class="dl">'</span></span>, <span class="i">3</span>],
-      [<span class="s"><span class="dl">'</span><span class="k">d</span><span class="dl">'</span></span>, <span class="pc">nil</span>],
-    ]
-
-  <span class="r">end</span>
-
-  it <span class="s"><span class="dl">'</span><span class="k">should return enumerators if no block is applied</span><span class="dl">'</span></span> <span class="r">do</span>
-  <span class="r">end</span>
-<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_iterate_source">(<a href="javascript:show('iterate_source')">show</a>)</span>
-         <pre class="source" id="iterate_source"><span class="r">def</span> <span class="fu">iterate</span>(*params)
-  <span class="c"># params.shift.zip(*params).each{ |*elements| yield *elements }</span>
-
-  first = params.shift
-  <span class="r">if</span> params.empty? <span class="c"># single param - like each</span>
-    <span class="r">if</span> block_given?
-      first.map{|e| <span class="r">yield</span> e }
-    <span class="r">else</span>
-      first.map
-    <span class="r">end</span>
-  <span class="r">else</span>
-    padded_first = <span class="co">Array</span>.new( [first, *params].max_by(&amp;<span class="sy">:size</span>).size ){|i| first[i] } <span class="c"># append nils</span>
-    obj = padded_first.zip *params
-    <span class="r">if</span> block_given?
-      obj.map{|es| <span class="r">yield</span> *es }
-    <span class="r">else</span>
-      obj.map.to_enum
-    <span class="r">end</span>
-  <span class="r">end</span>
-<span class="r">end</span>
-
-<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/unary'">unary</h3>
-         <table class="cube_table"
-                id="unary_cube"
-                title="require 'zucker/1/unary'"> <tr><th>Summary</th>    <td>Easy conversion between strings and symbols.</td></tr><tr><th>Why?</th>    <td>Often, you do not care if you get a <code>String</code> or a <code>Symbol</code> as input - but you need one of both when analysing it.</td></tr><tr><th>Methods/Usage</th>    <td><h5>String#+@</h5><pre class="usage source" style="display:block">+<span class="s"><span class="dl">'</span><span class="k">was_string</span><span class="dl">'</span></span> <span class="c"># =&gt; 'was_string'</span></pre><h5>String#-@</h5><pre class="usage source" style="display:block">-<span class="s"><span class="dl">'</span><span class="k">was_string</span><span class="dl">'</span></span> <span class="c"># =&gt; :was_string</span></pre><h5>Symbol#+@</h5><pre class="usage source" style="display:block">+<span class="sy">:was_symbol</span>  <span class="c"># =&gt; 'was_symbol'</span></pre><h5>Symbol#-@</h5><pre class="usage source" style="display:block">-<span class="sy">:was_symbol</span>  <span class="c"># =&gt; :was_symbol</span></pre></td></tr><tr><th>Further information</th>    <td>Inspired by</td></tr><tr><th>Specification</th>    <td> <span id="show_unary_specification">(<a href="javascript:show('unary_specification')">show</a>)</span>
-         <pre class="source" id="unary_specification">require <span class="s"><span class="dl">'</span><span class="k">unary</span><span class="dl">'</span></span>
-
-describe <span class="co">Symbol</span>, <span class="s"><span class="dl">'</span><span class="k">#+@</span><span class="dl">'</span></span> <span class="r">do</span>
-  it <span class="s"><span class="dl">'</span><span class="k">should convert to_s</span><span class="dl">'</span></span> <span class="r">do</span>
-    +(<span class="sy">:matz</span>) == <span class="s"><span class="dl">'</span><span class="k">matz</span><span class="dl">'</span></span> <span class="c"># () 1.8 bug</span>
-  <span class="r">end</span>
-<span class="r">end</span>
-
-describe <span class="co">Symbol</span>, <span class="s"><span class="dl">'</span><span class="k">#-@</span><span class="dl">'</span></span> <span class="r">do</span>
-  it <span class="s"><span class="dl">'</span><span class="k">should do nothing</span><span class="dl">'</span></span> <span class="r">do</span>
-    -<span class="sy">:matz</span> == <span class="sy">:matz</span>
-  <span class="r">end</span>
-<span class="r">end</span>
-
-describe <span class="co">String</span>, <span class="s"><span class="dl">'</span><span class="k">#+@</span><span class="dl">'</span></span> <span class="r">do</span>
-  it <span class="s"><span class="dl">'</span><span class="k">should do nothing</span><span class="dl">'</span></span> <span class="r">do</span>
-    +<span class="s"><span class="dl">'</span><span class="k">matz</span><span class="dl">'</span></span> == <span class="s"><span class="dl">'</span><span class="k">matz</span><span class="dl">'</span></span>
-  <span class="r">end</span>
-<span class="r">end</span>
-
-describe <span class="co">String</span>, <span class="s"><span class="dl">'</span><span class="k">#-@</span><span class="dl">'</span></span> <span class="r">do</span>
-  it <span class="s"><span class="dl">'</span><span class="k">should convert to_sym</span><span class="dl">'</span></span> <span class="r">do</span>
-    -<span class="s"><span class="dl">'</span><span class="k">matz</span><span class="dl">'</span></span> == <span class="sy">:matz</span>
-  <span class="r">end</span>
-<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_unary_source">(<a href="javascript:show('unary_source')">show</a>)</span>
-         <pre class="source" id="unary_source"><span class="r">class</span> <span class="cl">String</span>
-  <span class="r">def</span> <span class="fu">+@</span>
-    <span class="pc">self</span>
-  <span class="r">end</span>
-
-  <span class="r">def</span> <span class="fu">-@</span>
-    to_sym
-  <span class="r">end</span>
-<span class="r">end</span>
-
-<span class="r">class</span> <span class="cl">Symbol</span>
-  <span class="r">def</span> <span class="fu">+@</span>
-    to_s
-  <span class="r">end</span>
-
-  <span class="r">def</span> <span class="fu">-@</span>
-    <span class="pc">self</span>
-  <span class="r">end</span>
-<span class="r">end</span>
-
-<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8 (+:literal not possible)</td></tr></table> <h3 title="require 'zucker/1/ivars'">ivars</h3>
-         <table class="cube_table"
-                id="ivars_cube"
-                title="require 'zucker/1/ivars'"> <tr><th>Summary</th>    <td>This method lets you easily assign lots of instance variables.</td></tr><tr><th>Why?</th>    <td>Often, you have to write boilerplate code for assigning instance varialbles, for example this one:<br/><code>def initialize(variable1, variable2)<br/>  @variable1, @variable2 = variable1, variable2<br/>end</code><br/></td></tr><tr><th>Methods/Usage</th>    <td><h5>instance_variables_from, ivars</h5><pre class="usage source" style="display:block"><span class="r">def</span> <span class="fu">a_method</span>(a = <span class="i">1</span>, b = <span class="i">2</span>)
-  instance_variables_from binding <span class="c"># assigns @a and @b</span>
-
-  params = {<span class="sy">:c</span> =&gt; <span class="i">3</span>, <span class="sy">:d</span> =&gt; <span class="i">4</span>}
-  ivars params <span class="c"># # assigns @c and @d</span>
-<span class="r">end</span>
-</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_ivars_specification">(<a href="javascript:show('ivars_specification')">show</a>)</span>
-         <pre class="source" id="ivars_specification">require <span class="s"><span class="dl">'</span><span class="k">ivars</span><span class="dl">'</span></span>
-
-describe <span class="s"><span class="dl">'</span><span class="k">instance_variables_from</span><span class="dl">'</span></span> <span class="r">do</span>
-  it <span class="s"><span class="dl">'</span><span class="k">should tansform the given parameter to instance variables</span><span class="dl">'</span></span> <span class="r">do</span>
-    <span class="r">def</span> <span class="fu">a_method</span>(a = <span class="i">1</span>, b = <span class="i">2</span>)
-      instance_variables_from binding <span class="c"># assigns @a and @b</span>
-
-      params = {<span class="sy">:c</span> =&gt; <span class="i">3</span>, <span class="sy">:d</span> =&gt; <span class="i">4</span>}
-      ivars params <span class="c"># # assigns @c and @d</span>
-    <span class="r">end</span>
-
-    a_method
-    <span class="iv">@a</span>.should == <span class="i">1</span>
-    <span class="iv">@b</span>.should == <span class="i">2</span>
-    <span class="iv">@c</span>.should == <span class="i">3</span>
-    <span class="iv">@d</span>.should == <span class="i">4</span>
-
-  <span class="r">end</span>
-<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_ivars_source">(<a href="javascript:show('ivars_source')">show</a>)</span>
-         <pre class="source" id="ivars_source"><span class="r">def</span> <span class="fu">instance_variables_from</span>(obj, *only)
-  iter =
-  <span class="r">if</span>    obj.is_a? <span class="co">Binding</span>
-    obj.eval(<span class="s"><span class="dl">'</span><span class="k">local_variables</span><span class="dl">'</span></span>).map{|e| [obj.eval(e), e] }
-  <span class="r">elsif</span> obj.is_a? <span class="co">Hash</span>
-    obj.map{|k,v| [v,k] }
-  <span class="r">else</span>
-<span class="c">#  elsif obj.is_a? Enumerable</span>
-    obj.each.with_index
-  <span class="r">end</span>
-
-  ret = []
-  iter.each{ |value, arg|
-    arg = arg.to_s
-    <span class="r">if</span> only.include?(arg) || only.include?(arg.to_sym) || only.empty?
-      arg = <span class="s"><span class="dl">'</span><span class="k">_</span><span class="dl">'</span></span> + arg  <span class="r">if</span> (<span class="i">48</span>..<span class="i">57</span>).member? arg.unpack(<span class="s"><span class="dl">'</span><span class="k">C</span><span class="dl">'</span></span>)[<span class="i">0</span>]  <span class="c"># 1.8+1.9</span>
-      ret &lt;&lt; ivar = <span class="sy"><span class="sy">:</span><span class="dl">&quot;</span><span class="k">@</span><span class="il"><span class="idl">#{</span>arg<span class="idl">}</span></span><span class="dl">&quot;</span></span>
-      <span class="pc">self</span>.instance_variable_set ivar, value
-    <span class="r">end</span>
-  }
-  ret
-<span class="r">end</span>
-<span class="r">alias</span> <span class="fu">ivars</span> <span class="fu">instance_variables_from</span>
-
-<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/D'">D</h3>
+         <h3 title="require 'zucker/D'">D</h3>
          <table class="cube_table"
                 id="D_cube"
-                title="require 'zucker/1/D'"> <tr><th>Summary</th>    <td>Easy debug printing with the <code>p</code> alternative <code>.D</code>. It outputs to stdout and returns <code>self</code>. Accepts a block.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Object#D</h5><pre class="usage source" style="display:block">some.<span class="co">D</span>.methods.<span class="co">D</span>.noone.<span class="co">D</span>.knows.<span class="co">D</span>
-<span class="c"># ...outputs 4 lines with the inspected object</span>
+                title="require 'zucker/D'"> <tr><th>Summary</th>    <td>Easy debug printing with the <code>p</code> alternative <code>.D</code>. It outputs to stdout and returns <code>self</code>. Accepts a block.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Object#D</h5><pre class="usage source" style="display:block">some.<span class="co">D</span>.methods.<span class="co">D</span>.noone.<span class="co">D</span>.knows.<span class="co">D</span>
+<span class="c"># ...outputs 4 lines with the inspected objects</span>
 <span class="c"># =&gt; (result)</span>
 
 <span class="i">21</span>+<span class="co">Math</span>.sin(<span class="i">42</span>).<span class="co">D</span>
@@ -419,8 +338,8 @@ name = <span class="s"><span class="dl">'</span><span class="k">Earth</span><spa
 <span class="s"><span class="dl">'</span><span class="k">Hello </span><span class="dl">'</span></span> + name.<span class="co">D</span>{|e| <span class="s"><span class="dl">&quot;</span><span class="k">The length is: </span><span class="il"><span class="idl">#{</span>e.size<span class="idl">}</span></span><span class="dl">&quot;</span></span>}
 <span class="c"># outputs &quot;The length is: 5&quot;</span>
 <span class="c"># =&gt; 'Hello Earth'</span>
-</pre></td></tr><tr><th>Further information</th>    <td>This is inspired by the funny <code>.tap</code> method: http://moonbase.rydia.net/mental/blog/programming/eavesdropping-on-expressions</td></tr><tr><th>Specification</th>    <td> <span id="show_D_specification">(<a href="javascript:show('D_specification')">show</a>)</span>
-         <pre class="source" id="D_specification">require <span class="s"><span class="dl">'</span><span class="k">D</span><span class="dl">'</span></span>
+</pre></td></tr><tr><th>Further information</th>    <td>This is inspired by the funny <a href="http://moonbase.rydia.net/mental/blog/programming/eavesdropping-on-expressions"><code>.tap</code> method</a></td></tr><tr><th>Specification</th>    <td> <span id="show_D_spec">(<a href="javascript:show('D_spec')">show</a>)</span>
+         <pre class="source" id="D_spec">require <span class="s"><span class="dl">'</span><span class="k">D</span><span class="dl">'</span></span>
 
 describe <span class="s"><span class="dl">'</span><span class="k">Object#D</span><span class="dl">'</span></span> <span class="r">do</span>
 
@@ -463,11 +382,74 @@ describe <span class="s"><span class="dl">'</span><span class="k">Object#D</span
   <span class="r">end</span>
 <span class="r">end</span>
 
-<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/array'">array</h3>
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/aliases'">aliases</h3>
+         <table class="cube_table"
+                id="aliases_cube"
+                title="require 'zucker/aliases'"> <tr><th>Summary</th>    <td>Some convenient aliases (and constants) for existing methods.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Object#is_an?</h5><pre class="usage source" style="display:block"><span class="co">Object</span>.is_a?</pre><h5>Enumerable#with</h5><pre class="usage source" style="display:block"><span class="co">Enumerable</span><span class="c">#zip</span></pre><h5>Enumerable#%</h5><pre class="usage source" style="display:block"><span class="co">Enumerable</span><span class="c">#zip</span></pre><h5>Array#**</h5><pre class="usage source" style="display:block"><span class="co">Array</span><span class="c">#product</span></pre><h5>Hash#+</h5><pre class="usage source" style="display:block"><span class="co">Hash</span><span class="c">#merge</span></pre><h5>Binding#[]</h5><pre class="usage source" style="display:block"><span class="co">Binding</span><span class="c">#eval</span></pre><h5>Infinity</h5><pre class="usage source" style="display:block"><span class="fl">1.0</span> / <span class="fl">0.0</span></pre><h5>NaN</h5><pre class="usage source" style="display:block"><span class="fl">0.0</span> / <span class="fl">0.0</span></pre></td></tr><tr><th>Specification</th>    <td> <span id="show_aliases_spec">(<a href="javascript:show('aliases_spec')">show</a>)</span>
+         <pre class="source" id="aliases_spec">require <span class="s"><span class="dl">'</span><span class="k">aliases</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">(aliases)</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should create these aliases [ sorry, no real spec for this one :P ] </span><span class="dl">'</span></span> <span class="r">do</span>
+  <span class="c"># alias is_an? is_a?</span>
+
+  <span class="c">#  module Enumerable</span>
+  <span class="c">#    alias with zip</span>
+  <span class="c">#    alias %    zip</span>
+  <span class="c">#  end</span>
+
+  <span class="c">#  class Array</span>
+  <span class="c">#    alias ** product</span>
+  <span class="c">#  end</span>
+
+  <span class="c">#  class Hash</span>
+  <span class="c">#    alias + merge</span>
+  <span class="c">#  end</span>
+
+  <span class="c">#  class Binding</span>
+  <span class="c">#    #alias [] eval</span>
+  <span class="c">#    def [](expr)</span>
+  <span class="c">#      self.eval &quot;#{expr}&quot;</span>
+  <span class="c">#    end</span>
+  <span class="c">#  end</span>
+
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should define these constants</span><span class="dl">'</span></span> <span class="r">do</span>
+    <span class="co">Infinity</span>.finite?.should == <span class="pc">false</span>
+    <span class="co">NaN</span>.nan?.should         == <span class="pc">true</span>
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_aliases_source">(<a href="javascript:show('aliases_source')">show</a>)</span>
+         <pre class="source" id="aliases_source"><span class="r">alias</span> <span class="fu">is_an?</span> <span class="fu">is_a?</span>
+
+<span class="r">module</span> <span class="cl">Enumerable</span>
+  <span class="r">alias</span> <span class="fu">with</span> <span class="fu">zip</span>
+  <span class="r">alias</span> <span class="fu">%</span>    <span class="fu">zip</span>
+<span class="r">end</span>
+
+<span class="r">class</span> <span class="cl">Array</span>
+  <span class="r">alias</span> <span class="fu">**</span> <span class="fu">product</span>
+<span class="r">end</span>
+
+<span class="r">class</span> <span class="cl">Hash</span>
+  <span class="r">alias</span> <span class="fu">+</span> <span class="fu">merge</span>
+<span class="r">end</span>
+
+<span class="r">class</span> <span class="cl">Binding</span>
+  <span class="c">#alias [] eval</span>
+  <span class="r">def</span> <span class="fu">[]</span>(expr)
+    <span class="pc">self</span>.eval <span class="s"><span class="dl">&quot;</span><span class="il"><span class="idl">#{</span>expr<span class="idl">}</span></span><span class="dl">&quot;</span></span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># constants - who would use these in real-world code for other things?</span>
+<span class="co">Infinity</span> = <span class="fl">1.0</span> / <span class="fl">0.0</span> <span class="c"># or 2*Float::MAX</span>
+<span class="co">NaN</span>      = <span class="fl">0.0</span> / <span class="fl">0.0</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/array'">array</h3>
          <table class="cube_table"
                 id="array_cube"
-                title="require 'zucker/1/array'"> <tr><th>Summary</th>    <td>Methods one could miss for <code>Array</code></td></tr><tr><th>Why?</th>    <td><p><code>Array</code> has <code>&</code> and <code>|</code>, but why does it not have <code>^</code>?</p><p><code>sum</code> is an alias for <code>inject(:+)</code>, but it is just needed pretty often!</p></td></tr><tr><th>Methods/Usage</th>    <td><h5>Array#^</h5><pre class="usage source" style="display:block">[<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>] ^ [<span class="i">3</span>,<span class="i">4</span>,<span class="i">5</span>,<span class="i">6</span>]  <span class="c"># =&gt; [1,2,5,6]</span></pre><h5>Array#sum</h5><pre class="usage source" style="display:block">[<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>,<span class="i">5</span>].sum  <span class="c"># =&gt; 15</span></pre><h5>Array#chrs</h5><pre class="usage source" style="display:block">[<span class="i">72</span>, <span class="i">97</span>, <span class="i">108</span>, <span class="i">108</span>, <span class="i">111</span>].chrs  <span class="c"># =&gt; 'Hallo'</span></pre></td></tr><tr><th>Specification</th>    <td> <span id="show_array_specification">(<a href="javascript:show('array_specification')">show</a>)</span>
-         <pre class="source" id="array_specification">require <span class="s"><span class="dl">'</span><span class="k">array</span><span class="dl">'</span></span>
+                title="require 'zucker/array'"> <tr><th>Summary</th>    <td>Methods one could miss for <code>Array</code>.</td></tr><tr><th>Why?</th>    <td><p><code>Array</code> has <code>&</code> and <code>|</code>, but why does it not have <code>^</code>?</p><p><code>sum</code> is an alias for <code>inject(:+)</code>, but it is just needed pretty often!</p></td></tr><tr><th>Methods/Usage</th>    <td><h5>Array#^</h5><pre class="usage source" style="display:block">[<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>] ^ [<span class="i">3</span>,<span class="i">4</span>,<span class="i">5</span>,<span class="i">6</span>]  <span class="c"># =&gt; [1,2,5,6]</span></pre><h5>Array#sum</h5><pre class="usage source" style="display:block">[<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>,<span class="i">5</span>].sum  <span class="c"># =&gt; 15</span></pre><h5>Array#chrs</h5><pre class="usage source" style="display:block">[<span class="i">72</span>, <span class="i">97</span>, <span class="i">108</span>, <span class="i">108</span>, <span class="i">111</span>].chrs  <span class="c"># =&gt; 'Hallo'</span></pre></td></tr><tr><th>Specification</th>    <td> <span id="show_array_spec">(<a href="javascript:show('array_spec')">show</a>)</span>
+         <pre class="source" id="array_spec">require <span class="s"><span class="dl">'</span><span class="k">array</span><span class="dl">'</span></span>
 
 describe <span class="s"><span class="dl">'</span><span class="k">Array#^</span><span class="dl">'</span></span> <span class="r">do</span>
   it <span class="s"><span class="dl">'</span><span class="k">should do an exclusive or</span><span class="dl">'</span></span> <span class="r">do</span>
@@ -504,11 +486,11 @@ describe <span class="s"><span class="dl">'</span><span class="k">Array#chrs</sp
   <span class="r">end</span>
 <span class="r">end</span>
 
-<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/array2proc'">array2proc</h3>
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/array2proc'">array2proc</h3>
          <table class="cube_table"
                 id="array2proc_cube"
-                title="require 'zucker/1/array2proc'"> <tr><th>Summary</th>    <td>Calls the method named by the first paramenter and passes the other elements as paramaters.</td></tr><tr><th>Why?</th>    <td>When using <code>Symbol#to_proc</code>, you often wish to pass parameters.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Array#to_proc</h5><pre class="usage source" style="display:block">[<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>].map( &amp;[<span class="sy">:to_s</span>, <span class="i">2</span>] )  <span class="c"># =&gt; [&quot;1&quot;, &quot;10&quot;, &quot;11&quot;, &quot;100&quot;]</span></pre></td></tr><tr><th>Further information</th>    <td>Inspired by http://www.sanityinc.com/articles/adding-array-to-proc-to-ruby<br/>More about to_proc: http://rbjl.net/29-become-a-proc-star</td></tr><tr><th>Specification</th>    <td> <span id="show_array2proc_specification">(<a href="javascript:show('array2proc_specification')">show</a>)</span>
-         <pre class="source" id="array2proc_specification">require <span class="s"><span class="dl">'</span><span class="k">array2proc</span><span class="dl">'</span></span>
+                title="require 'zucker/array2proc'"> <tr><th>Summary</th>    <td>Calls the method named by the first paramenter and passes the other elements as paramaters.</td></tr><tr><th>Why?</th>    <td>When using <code>Symbol#to_proc</code>, you often wish to pass parameters.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Array#to_proc</h5><pre class="usage source" style="display:block">[<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>].map( &amp;[<span class="sy">:to_s</span>, <span class="i">2</span>] )  <span class="c"># =&gt; [&quot;1&quot;, &quot;10&quot;, &quot;11&quot;, &quot;100&quot;]</span></pre></td></tr><tr><th>Further information</th>    <td>Inspired by <a href="http://www.sanityinc.com/articles/adding-array-to-proc-to-ruby">this article</a>.<br/>More about <a href="http://rbjl.net/29-become-a-proc-star">to_proc</a>.</td></tr><tr><th>Specification</th>    <td> <span id="show_array2proc_spec">(<a href="javascript:show('array2proc_spec')">show</a>)</span>
+         <pre class="source" id="array2proc_spec">require <span class="s"><span class="dl">'</span><span class="k">array2proc</span><span class="dl">'</span></span>
 
 describe <span class="s"><span class="dl">'</span><span class="k">Array#to_proc</span><span class="dl">'</span></span> <span class="r">do</span>
   it <span class="s"><span class="dl">'</span><span class="k">should call the method of the first symbol, using the remaining elements as paramaters</span><span class="dl">'</span></span> <span class="r">do</span>
@@ -523,193 +505,215 @@ describe <span class="s"><span class="dl">'</span><span class="k">Array#to_proc<
   <span class="r">end</span>
 <span class="r">end</span>
 
-<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/square_brackets_for'">square_brackets_for</h3>
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/binding'">binding</h3>
          <table class="cube_table"
-                id="square_brackets_for_cube"
-                title="require 'zucker/1/square_brackets_for'"> <tr><th>Summary</th>    <td>This helper methods defines <code>[]</code> and <code>[]=</code> for accesing an instance variable.</td></tr><tr><th>Methods/Usage</th>    <td><h5>square_brackets_for</h5><pre class="usage source" style="display:block"><span class="r">class</span> <span class="cl">Klass</span>
-  <span class="r">def</span> <span class="fu">initialize</span>
-    <span class="iv">@var</span> = {
-      <span class="sy">:a_key</span> =&gt; <span class="i">1</span>,
-      <span class="sy">:another_one</span> =&gt; <span class="i">2</span>,
-    }
-  <span class="r">end</span>
-
-  square_brackets_for <span class="sy">:var</span> <span class="c"># creates [] and []=</span>
-  <span class="c"># square_brackets_for :var, false # would create only []</span>
-<span class="r">end</span>
-
-a = <span class="co">Klass</span>.new
-a[<span class="sy">:a_key</span>] <span class="c"># =&gt; 1</span>
-</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_square_brackets_for_specification">(<a href="javascript:show('square_brackets_for_specification')">show</a>)</span>
-         <pre class="source" id="square_brackets_for_specification">require <span class="s"><span class="dl">'</span><span class="k">square_brackets_for</span><span class="dl">'</span></span>
-
-describe <span class="s"><span class="dl">'</span><span class="k">square_brackets_for</span><span class="dl">'</span></span> <span class="r">do</span>
+                id="binding_cube"
+                title="require 'zucker/binding'"> <tr><th>Summary</th>    <td>Adds a verbose Binding#inspect</td></tr><tr><th>Why?</th>    <td>It gives you information about the current environment</td></tr><tr><th>Methods/Usage</th>    <td><h5>Binding#inspect</h5><pre class="usage source" style="display:block">binding.inspect</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_binding_spec">(<a href="javascript:show('binding_spec')">show</a>)</span>
+         <pre class="source" id="binding_spec">require <span class="s"><span class="dl">'</span><span class="k">binding</span><span class="dl">'</span></span>
 
-  before <span class="r">do</span>
-    <span class="r">class</span> <span class="cl">Klass</span>
-      <span class="r">def</span> <span class="fu">initialize</span>
-        <span class="iv">@var</span> = {
-          <span class="sy">:a_key</span> =&gt; <span class="i">1</span>,
-          <span class="sy">:another_one</span> =&gt; <span class="i">2</span>,
-        }
+describe <span class="s"><span class="dl">'</span><span class="k">Binding#inspect</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should output the current environment</span><span class="dl">'</span></span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_binding_source">(<a href="javascript:show('binding_source')">show</a>)</span>
+         <pre class="source" id="binding_source"><span class="r">class</span> <span class="cl">Binding</span>
+  <span class="r">def</span> <span class="fu">inspect</span>
+    put_vars = lambda { |array|
+      <span class="r">if</span> array.empty?
+        <span class="s"><span class="dl">'</span><span class="k"> - none</span><span class="dl">'</span></span>
+      <span class="r">else</span>
+        array.map{|e| <span class="s"><span class="dl">&quot;</span><span class="k"> - </span><span class="il"><span class="idl">#{</span>e<span class="idl">}</span></span><span class="k">: </span><span class="il"><span class="idl">#{</span> <span class="pc">self</span>.eval <span class="s"><span class="dl">'</span><span class="k">#{e}</span><span class="dl">'</span></span><span class="idl">}</span></span><span class="dl">&quot;</span></span>}*<span class="s"><span class="dl">&quot;</span><span class="ch">\n</span><span class="dl">&quot;</span></span>
       <span class="r">end</span>
+    }
 
-      <span class="iv">@eigenvar</span> = {
-        <span class="sy">:a_key</span> =&gt; <span class="i">99</span>
-      }
-    <span class="r">end</span>
-  <span class="r">end</span>
+<span class="s"><span class="dl">&quot;</span><span class="il"><span class="idl">#{</span><span class="pc">self</span>.to_s<span class="idl">}</span></span><span class="k">
+local vars
+</span><span class="il"><span class="idl">#{</span> put_vars[ <span class="pc">self</span>.eval <span class="s"><span class="dl">'</span><span class="k">local_variables</span><span class="dl">'</span></span> ] <span class="idl">}</span></span><span class="k">
+(instance vars)
+</span><span class="il"><span class="idl">#{</span> put_vars[ <span class="pc">self</span>.eval <span class="s"><span class="dl">'</span><span class="k">instance_variables</span><span class="dl">'</span></span> ] <span class="idl">}</span></span><span class="k">
+self
+ - </span><span class="il"><span class="idl">#{</span><span class="pc">self</span>.eval <span class="s"><span class="dl">'</span><span class="k">self</span><span class="dl">'</span></span><span class="idl">}</span></span><span class="k">
+block_given?
+ - </span><span class="il"><span class="idl">#{</span><span class="pc">self</span>.eval <span class="s"><span class="dl">'</span><span class="k">block_given?</span><span class="dl">'</span></span><span class="idl">}</span></span><span class="dl">&quot;</span></span>
 
-  it <span class="s"><span class="dl">'</span><span class="k">should define a [] getter (not a setter) for an instance var, if the second parameter is false</span><span class="dl">'</span></span> <span class="r">do</span>
+  <span class="r">end</span>
+<span class="r">end</span>
 
-    <span class="r">class</span> <span class="cl">Klass</span>
-      square_brackets_for <span class="sy">:var</span>, <span class="pc">nil</span>
-    <span class="r">end</span>
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/blank'">blank</h3>
+         <table class="cube_table"
+                id="blank_cube"
+                title="require 'zucker/blank'"> <tr><th>Summary</th>    <td>Does pretty the same as in ActiveSupport (Every object can be asked if it is blank)</td></tr><tr><th>Why?</th>    <td>It's too familiar ;)</td></tr><tr><th>Methods/Usage</th>    <td><h5>Object#blank?</h5><pre class="usage source" style="display:block"><span class="s"><span class="dl">'</span><span class="k">an object</span><span class="dl">'</span></span>.blank? <span class="c"># =&gt; false</span></pre></td></tr><tr><th>Further information</th>    <td>See ActiveSupport</td></tr><tr><th>Specification</th>    <td> <span id="show_blank_spec">(<a href="javascript:show('blank_spec')">show</a>)</span>
+         <pre class="source" id="blank_spec">require <span class="s"><span class="dl">'</span><span class="k">blank</span><span class="dl">'</span></span>
 
-    a = <span class="co">Klass</span>.new
-    a[<span class="sy">:a_key</span>].should == <span class="i">1</span>
+describe <span class="s"><span class="dl">'</span><span class="k">Object#blank?</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should be blank for blank values</span><span class="dl">'</span></span> <span class="r">do</span>
+    blank_values   = [ <span class="pc">nil</span>, <span class="pc">false</span>, <span class="s"><span class="dl">'</span><span class="dl">'</span></span>, <span class="s"><span class="dl">'</span><span class="k">   </span><span class="dl">'</span></span>, <span class="s"><span class="dl">&quot;</span><span class="k">  </span><span class="ch">\n</span><span class="ch">\t</span><span class="k">  </span><span class="ch">\r</span><span class="k"> </span><span class="dl">&quot;</span></span>, [], {}, <span class="rx"><span class="dl">/</span><span class="dl">/</span></span> ]
 
-    proc <span class="r">do</span>
-      a[<span class="sy">:this_is</span>] = <span class="s"><span class="dl">'</span><span class="k">not possible</span><span class="dl">'</span></span>
-    <span class="r">end</span>.should raise_exception <span class="co">NoMethodError</span>
+    blank_values.each{ |blank|
+      blank.blank?.should == <span class="pc">true</span>
+    }
   <span class="r">end</span>
 
-  it <span class="s"><span class="dl">'</span><span class="k">should define [] and []= for accessing an instance variable</span><span class="dl">'</span></span> <span class="r">do</span>
-
-    <span class="r">class</span> <span class="cl">Klass</span>
-      square_brackets_for <span class="sy">:var</span>
-    <span class="r">end</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should not be blank for non blank values</span><span class="dl">'</span></span> <span class="r">do</span>
+    present_values = [ <span class="co">Object</span>.new, <span class="pc">true</span>, <span class="i">0</span>, <span class="i">1</span>, <span class="s"><span class="dl">'</span><span class="k">a</span><span class="dl">'</span></span>, [<span class="pc">nil</span>], { <span class="pc">nil</span> =&gt; <span class="pc">nil</span> } ]
 
-    a = <span class="co">Klass</span>.new
-    a[<span class="sy">:a_key</span>].should == <span class="i">1</span>
+    present_values.each{ |present|
+      present.blank?.should == <span class="pc">false</span>
+    }
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_blank_source">(<a href="javascript:show('blank_source')">show</a>)</span>
+         <pre class="source" id="blank_source"><span class="r">class</span> <span class="cl">Object</span>
+  <span class="r">def</span> <span class="fu">blank?</span>
+    <span class="r">if</span> respond_to? <span class="sy">:empty?</span> <span class="r">then</span> empty? <span class="r">else</span> !<span class="pc">self</span> <span class="r">end</span>
+  <span class="r">end</span>
 
-    a[<span class="sy">:this_is</span>] = <span class="s"><span class="dl">'</span><span class="k">useful</span><span class="dl">'</span></span>
-    a[<span class="sy">:this_is</span>].should == <span class="s"><span class="dl">'</span><span class="k">useful</span><span class="dl">'</span></span>
+  <span class="r">def</span> <span class="fu">present?</span>
+    !blank?
   <span class="r">end</span>
+<span class="r">end</span>
 
-  it <span class="s"><span class="dl">'</span><span class="k">should also work for class-instance variables</span><span class="dl">'</span></span> <span class="r">do</span>
 
-    <span class="r">class</span> <span class="cl">Klass</span>
-      <span class="r">class</span> &lt;&lt; <span class="cl">Klass</span>
-        square_brackets_for <span class="sy">:eigenvar</span>
-      <span class="r">end</span>
-    <span class="r">end</span>
+{ <span class="c"># what to do              # for which classes</span>
+  lambda{ <span class="pc">true</span> }         =&gt; [<span class="co">FalseClass</span>, <span class="co">NilClass</span>],
+  lambda{ <span class="pc">false</span> }        =&gt; [<span class="co">TrueClass</span>, <span class="co">Numeric</span>],
+  lambda{ empty? }       =&gt; [<span class="co">Array</span>, <span class="co">Hash</span>],
+  lambda{ <span class="pc">self</span> !~ <span class="rx"><span class="dl">/</span><span class="ch">\S</span><span class="dl">/</span></span> } =&gt; [<span class="co">String</span>],
+  lambda{ <span class="pc">self</span> == <span class="rx"><span class="dl">/</span><span class="dl">/</span></span>   } =&gt; [<span class="co">Regexp</span>],
 
-    <span class="co">Klass</span>[<span class="sy">:a_key</span>].should == <span class="i">99</span>
-  <span class="r">end</span>
+}.each{ |action, klass_array|
+  klass_array.each{ |klass|
+    klass.send <span class="sy">:define_method</span>, <span class="sy">:blank?</span>, &amp;action
+  }
+}
 
-<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_square_brackets_for_source">(<a href="javascript:show('square_brackets_for_source')">show</a>)</span>
-         <pre class="source" id="square_brackets_for_source"><span class="r">def</span> <span class="fu">square_brackets_for</span>(ivar, assignment = <span class="pc">true</span>)
-<span class="c">#  undef []   if respond_to? :[]</span>
-<span class="c">#  undef []=  if respond_to? :[]=</span>
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/class2proc'">class2proc</h3>
+         <table class="cube_table"
+                id="class2proc_cube"
+                title="require 'zucker/class2proc'"> <tr><th>Summary</th>    <td>Creates a new instance of the class.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Class#to_proc</h5><pre class="usage source" style="display:block">[ [<span class="i">1</span>,<span class="i">2</span>],[<span class="i">3</span>,<span class="i">5</span>,<span class="i">6</span>,<span class="i">7</span>,<span class="i">3</span>] ].map(&amp;<span class="co">Set</span>) <span class="c"># =&gt; [ Set[1,2], Set[5,6,7,3] ]</span></pre></td></tr><tr><th>Further information</th>    <td>Inspired by Ruby Facets.<br/>More about <a href="http://rbjl.net/29-become-a-proc-star">to_proc</a>.</td></tr><tr><th>Specification</th>    <td> <span id="show_class2proc_spec">(<a href="javascript:show('class2proc_spec')">show</a>)</span>
+         <pre class="source" id="class2proc_spec">require <span class="s"><span class="dl">'</span><span class="k">class2proc</span><span class="dl">'</span></span>
+require <span class="s"><span class="dl">'</span><span class="k">set</span><span class="dl">'</span></span>
 
-<span class="c">#instance_eval do</span>
-  define_method <span class="sy">:[]</span> <span class="r">do</span> |key|
-    (instance_variable_get <span class="sy"><span class="sy">:</span><span class="dl">&quot;</span><span class="k">@</span><span class="il"><span class="idl">#{</span>ivar<span class="idl">}</span></span><span class="dl">&quot;</span></span>)[key]
+describe <span class="s"><span class="dl">'</span><span class="k">Class#to_proc</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should create new instances of the class</span><span class="dl">'</span></span> <span class="r">do</span>
+    [ [<span class="i">1</span>,<span class="i">2</span>],[<span class="i">3</span>,<span class="i">5</span>,<span class="i">6</span>,<span class="i">7</span>,<span class="i">3</span>] ].map(&amp;<span class="co">Set</span>).should == [ <span class="co">Set</span>[<span class="i">1</span>,<span class="i">2</span>], <span class="co">Set</span>[<span class="i">5</span>,<span class="i">6</span>,<span class="i">7</span>,<span class="i">3</span>] ]
   <span class="r">end</span>
-
-  <span class="r">if</span> assignment
-    define_method <span class="sy">:[]=</span> <span class="r">do</span> |key, value|
-      (instance_variable_get <span class="sy"><span class="sy">:</span><span class="dl">&quot;</span><span class="k">@</span><span class="il"><span class="idl">#{</span>ivar<span class="idl">}</span></span><span class="dl">&quot;</span></span>)[key] = value
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_class2proc_source">(<a href="javascript:show('class2proc_source')">show</a>)</span>
+         <pre class="source" id="class2proc_source"><span class="r">class</span> <span class="cl">Class</span>
+  <span class="r">def</span> <span class="fu">to_proc</span>
+    <span class="co">Proc</span>.new <span class="r">do</span> |*args|
+      <span class="pc">self</span>.new *args
     <span class="r">end</span>
   <span class="r">end</span>
-<span class="c">#end</span>
-
 <span class="r">end</span>
 
-<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/mm'">mm</h3>
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/egonil'">egonil</h3>
          <table class="cube_table"
-                id="mm_cube"
-                title="require 'zucker/1/mm'"> <tr><th>Summary</th>    <td><code>mm</code> displays an ordered public method list.</td></tr><tr><th>Why?</th>    <td>See some object's methods without those rarely used inherited methods</td></tr><tr><th>Methods/Usage</th>    <td><h5>Object#method_list, Object#mm</h5><pre class="usage source" style="display:block"><span class="s"><span class="dl">'</span><span class="k">test</span><span class="dl">'</span></span>.mm <span class="i">2</span> <span class="c"># outputs the list (2 levels deep)</span></pre></td></tr><tr><th>Further information</th>    <td>See http://rbjl.net/31-the-multi-mega-method-list for more information</td></tr><tr><th>Specification</th>    <td> <span id="show_mm_specification">(<a href="javascript:show('mm_specification')">show</a>)</span>
-         <pre class="source" id="mm_specification">require <span class="s"><span class="dl">'</span><span class="k">mm</span><span class="dl">'</span></span>
+                id="egonil_cube"
+                title="require 'zucker/egonil'"> <tr><th>Summary</th>    <td>Creates a block, where <code>nil</code> does not raise <code>NoMethodError</code>s.</td></tr><tr><th>Methods/Usage</th>    <td><h5>egonil, nn</h5><pre class="usage source" style="display:block">egonil <span class="r">do</span>
+  <span class="pc">nil</span>.some_methods.that[<span class="sy">:do</span>].not.exist
+<span class="r">end</span> <span class="c"># =&gt; nil</span>
 
-describe <span class="s"><span class="dl">'</span><span class="k">Object#method_list</span><span class="dl">'</span></span> <span class="r">do</span>
-  it <span class="s"><span class="dl">'</span><span class="k">should display an ordered method list</span><span class="dl">'</span></span>
-<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_mm_source">(<a href="javascript:show('mm_source')">show</a>)</span>
-         <pre class="source" id="mm_source"><span class="r">module</span> <span class="cl">Kernel</span>
-  <span class="r">def</span> <span class="fu">method_list</span>(levels = <span class="i">1</span>)
-    <span class="r">if</span> <span class="pc">self</span>.is_a? <span class="co">Module</span>
-      klass, method_function = <span class="pc">self</span>, <span class="sy">:public_methods</span>
-    <span class="r">else</span>
-      klass, method_function = <span class="pc">self</span>.class, <span class="sy">:public_instance_methods</span>
+nn(<span class="i">5</span>){ <span class="pc">nil</span>.some_methods.that[<span class="sy">:do</span>].not.exist }
+<span class="c"># =&gt; 5</span>
+</pre></td></tr><tr><th>Further information</th>    <td>See <a href="http://rbjl.net/26-the-28-bytes-of-ruby-joy">this post</a> for more information and discussion</td></tr><tr><th>Specification</th>    <td> <span id="show_egonil_spec">(<a href="javascript:show('egonil_spec')">show</a>)</span>
+         <pre class="source" id="egonil_spec">require <span class="s"><span class="dl">'</span><span class="k">egonil</span><span class="dl">'</span></span>
 
-      eigen = <span class="pc">self</span>.singleton_methods
-      <span class="r">if</span> !eigen.empty?
-        puts <span class="sy">:Eigenclass</span> <span class="c"># sorry for not being up to date, I just love the word</span>
-        p <span class="pc">self</span>.singleton_methods
-      <span class="r">end</span>
-    <span class="r">end</span>
+describe <span class="s"><span class="dl">'</span><span class="k">egonil</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should not raise nil exceptions in the block</span><span class="dl">'</span></span> <span class="r">do</span>
+    proc <span class="r">do</span>
+      egonil{ <span class="pc">nil</span>.some_methods.that[<span class="sy">:do</span>].not.exist }
+    <span class="r">end</span>.should_not raise_exception
+  <span class="r">end</span>
 
-    levels.times{ |level|
-      <span class="r">if</span> cur = klass.ancestors[level]
-        p cur                               <span class="c"># put class name</span>
-        p cur.send method_function, <span class="pc">false</span>   <span class="c"># put methods of the class</span>
-      <span class="r">else</span>
-        <span class="r">break</span>
-      <span class="r">end</span>
-    }
+  it <span class="s"><span class="dl">'</span><span class="k">should return the nil_value if given</span><span class="dl">'</span></span> <span class="r">do</span>
+    egonil(<span class="i">9</span>){ <span class="pc">nil</span>.some_methods.that[<span class="sy">:do</span>].not.exist }.should == <span class="i">9</span>
+  <span class="r">end</span>
 
-    <span class="pc">self</span> <span class="c"># or whatever</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should restore default behaviour after the block</span><span class="dl">'</span></span> <span class="r">do</span>
+    proc <span class="r">do</span>
+      egonil{ <span class="pc">nil</span>.some_methods.that[<span class="sy">:do</span>].not.exist }
+    <span class="r">end</span>.should_not raise_exception
+
+    proc <span class="r">do</span>
+      <span class="pc">nil</span>.a_method
+    <span class="r">end</span>.should raise_exception <span class="co">NoMethodError</span>
   <span class="r">end</span>
 
-  <span class="r">alias</span> <span class="fu">mm</span> <span class="fu">method_list</span>
+  it <span class="s"><span class="dl">'</span><span class="k">raise NoMethodError for non-nil objects</span><span class="dl">'</span></span> <span class="r">do</span>
+    proc <span class="r">do</span>
+      egonil{ <span class="i">5</span>.a_method }
+    <span class="r">end</span>.should raise_exception <span class="co">NoMethodError</span>
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_egonil_source">(<a href="javascript:show('egonil_source')">show</a>)</span>
+         <pre class="source" id="egonil_source"><span class="r">def</span> <span class="fu">egonil</span>(nil_value = <span class="pc">nil</span>)
+  <span class="r">yield</span>
+<span class="r">rescue</span> <span class="co">NoMethodError</span> =&gt; e
+  <span class="r">if</span> e.message =~ <span class="rx"><span class="dl">/</span><span class="k">NilClass$</span><span class="dl">/</span></span>
+    nil_value
+  <span class="r">else</span>
+    raise <span class="co">NoMethodError</span>
+  <span class="r">end</span>
 <span class="r">end</span>
 
-<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/regexp2proc'">regexp2proc</h3>
+<span class="r">alias</span> <span class="fu">nn</span> <span class="fu">egonil</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/enumerable'">enumerable</h3>
          <table class="cube_table"
-                id="regexp2proc_cube"
-                title="require 'zucker/1/regexp2proc'"> <tr><th>Summary</th>    <td>Use &/regex/ to match it against strings</td></tr><tr><th>Methods/Usage</th>    <td><h5>Regexp#to_proc</h5><pre class="usage source" style="display:block"><span class="s"><span class="dl">%w|</span><span class="k">just another string array</span><span class="dl">|</span></span>.map    &amp;<span class="rx"><span class="dl">/</span><span class="k">[jy]</span><span class="dl">/</span></span>  <span class="c"># =&gt; [&quot;j&quot;, nil, nil, &quot;y&quot;]</span>
-<span class="s"><span class="dl">%w|</span><span class="k">just another string array</span><span class="dl">|</span></span>.select &amp;<span class="rx"><span class="dl">/</span><span class="k">[jy]</span><span class="dl">/</span></span>  <span class="c"># =&gt; [&quot;just&quot;, &quot;array&quot;]</span>
-</pre></td></tr><tr><th>Further information</th>    <td>More about to_proc: http://rbjl.net/29-become-a-proc-star</td></tr><tr><th>Specification</th>    <td> <span id="show_regexp2proc_specification">(<a href="javascript:show('regexp2proc_specification')">show</a>)</span>
-         <pre class="source" id="regexp2proc_specification">require <span class="s"><span class="dl">'</span><span class="k">regexp2proc</span><span class="dl">'</span></span>
+                id="enumerable_cube"
+                title="require 'zucker/enumerable'"> <tr><th>Summary</th>    <td><code>Enumerable</code> extensions.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Enumerable#mash</h5><pre class="usage source" style="display:block">[<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>].mash{|e| [e, e.to_s] } <span class="c"># =&gt; {1=&gt;'1',2=&gt;'2',3=&gt;'3'}</span></pre></td></tr><tr><th>Further information</th>    <td>Inspired by Ruby Facets' mash</td></tr><tr><th>Specification</th>    <td> <span id="show_enumerable_spec">(<a href="javascript:show('enumerable_spec')">show</a>)</span>
+         <pre class="source" id="enumerable_spec">require <span class="s"><span class="dl">'</span><span class="k">enumerable</span><span class="dl">'</span></span>
 
-describe <span class="s"><span class="dl">'</span><span class="k">Regexp#to_proc</span><span class="dl">'</span></span> <span class="r">do</span>
-  it <span class="s"><span class="dl">'</span><span class="k">should match the regex</span><span class="dl">'</span></span> <span class="r">do</span>
-    <span class="s"><span class="dl">%w|</span><span class="k">just another string array</span><span class="dl">|</span></span>.map(     &amp;<span class="rx"><span class="dl">/</span><span class="k">[jy]</span><span class="dl">/</span></span>).should == [<span class="s"><span class="dl">&quot;</span><span class="k">j</span><span class="dl">&quot;</span></span>, <span class="pc">nil</span>, <span class="pc">nil</span>, <span class="s"><span class="dl">&quot;</span><span class="k">y</span><span class="dl">&quot;</span></span>]
-    <span class="s"><span class="dl">%w|</span><span class="k">just another string array</span><span class="dl">|</span></span>.select(  &amp;<span class="rx"><span class="dl">/</span><span class="k">[jy]</span><span class="dl">/</span></span>).should == [<span class="s"><span class="dl">&quot;</span><span class="k">just</span><span class="dl">&quot;</span></span>, <span class="s"><span class="dl">&quot;</span><span class="k">array</span><span class="dl">&quot;</span></span>]
+describe <span class="s"><span class="dl">'</span><span class="k">Enumerable#mash</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should &quot;map&quot; a hash</span><span class="dl">'</span></span> <span class="r">do</span>
+    [<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>].mash{|e| [e, e.to_s] }.should == {<span class="i">1</span>=&gt;<span class="s"><span class="dl">'</span><span class="k">1</span><span class="dl">'</span></span>,<span class="i">2</span>=&gt;<span class="s"><span class="dl">'</span><span class="k">2</span><span class="dl">'</span></span>,<span class="i">3</span>=&gt;<span class="s"><span class="dl">'</span><span class="k">3</span><span class="dl">'</span></span>,}
   <span class="r">end</span>
-<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_regexp2proc_source">(<a href="javascript:show('regexp2proc_source')">show</a>)</span>
-         <pre class="source" id="regexp2proc_source"><span class="r">class</span> <span class="cl">Regexp</span>
-  <span class="r">def</span> <span class="fu">to_proc</span>
-    proc <span class="r">do</span> |e|
-      e.to_s[<span class="pc">self</span>]
-    <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_enumerable_source">(<a href="javascript:show('enumerable_source')">show</a>)</span>
+         <pre class="source" id="enumerable_source"><span class="r">module</span> <span class="cl">Enumerable</span>
+  <span class="r">def</span> <span class="fu">mash</span>
+    ret = {}
+    each{ |kv|
+      ret.store *( <span class="r">yield</span>(kv)[<span class="i">0</span>,<span class="i">2</span>] )
+    }
+    ret
   <span class="r">end</span>
 <span class="r">end</span>
 
-<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/mcopy'">mcopy</h3>
-         <table class="cube_table"
-                id="mcopy_cube"
-                title="require 'zucker/1/mcopy'"> <tr><th>Summary</th>    <td>Adds <code>Object#mcopy</code> to create a deep copy using <code>Marshal</code>.</td></tr><tr><th>Why?</th>    <td>Every Ruby book describes, you can do <code>Marshal.load Marshal.dump object</code> to create a deep copy... But who needs this verbose syntax in everyday coding?</td></tr><tr><th>Methods/Usage</th>    <td><h5>Object#mcopy</h5><pre class="usage source" style="display:block">a = <span class="s"><span class="dl">%w[</span><span class="k">hello world</span><span class="dl">]</span></span>
-b = a.mcopy
-</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_mcopy_specification">(<a href="javascript:show('mcopy_specification')">show</a>)</span>
-         <pre class="source" id="mcopy_specification">require <span class="s"><span class="dl">'</span><span class="k">mcopy</span><span class="dl">'</span></span>
-
-describe <span class="s"><span class="dl">'</span><span class="k">Object#mcopy</span><span class="dl">'</span></span> <span class="r">do</span>
-  it <span class="s"><span class="dl">'</span><span class="k">create a (deep) copy via marshalling</span><span class="dl">'</span></span> <span class="r">do</span>
-    a = <span class="s"><span class="dl">%w[</span><span class="k">hello world</span><span class="dl">]</span></span>
-    b = a.mcopy
-    b.should == a
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/hash'">hash</h3>
+         <table class="cube_table"
+                id="hash_cube"
+                title="require 'zucker/hash'"> <tr><th>Summary</th>    <td>Some sugar for dealing with hashs.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Hash.zip</h5><pre class="usage source" style="display:block"><span class="co">Hash</span>.zip [<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>], [<span class="i">4</span>,<span class="i">5</span>,<span class="i">6</span>] <span class="c"># =&gt; {1 =&gt; 4, 2 =&gt; 5, 3 =&gt; 6}</span></pre><h5>Hash#<<</h5><pre class="usage source" style="display:block">{<span class="i">1</span> =&gt; <span class="i">2</span>} &lt;&lt; [<span class="i">3</span>, <span class="i">4</span>] <span class="c"># =&gt; {1 =&gt; 2, 3 =&gt; 4}</span></pre></td></tr><tr><th>Further information</th>    <td>Some of the operators are inspired by Ruby Facets</td></tr><tr><th>Specification</th>    <td> <span id="show_hash_spec">(<a href="javascript:show('hash_spec')">show</a>)</span>
+         <pre class="source" id="hash_spec">require <span class="s"><span class="dl">'</span><span class="k">hash</span><span class="dl">'</span></span>
 
-    b[<span class="i">0</span>][<span class="i">1</span>,<span class="i">1</span>] = <span class="s"><span class="dl">'</span><span class="dl">'</span></span>
-    b.should_not == a
+describe <span class="s"><span class="dl">'</span><span class="k">Hash.zip</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should zip together both given enumerables and take them as key=&gt;values for a new hash</span><span class="dl">'</span></span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Hash#&lt;&lt;</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should append new elements to the hash</span><span class="dl">'</span></span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_hash_source">(<a href="javascript:show('hash_source')">show</a>)</span>
+         <pre class="source" id="hash_source"><span class="r">class</span> <span class="cl">Hash</span>
+  <span class="r">def</span> <span class="pc">self</span>.<span class="fu">zip</span>(keys,values)
+    <span class="co">Hash</span>[ *[<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>].zip( [<span class="i">4</span>,<span class="i">5</span>,<span class="i">6</span>] ).flatten ]
   <span class="r">end</span>
-<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_mcopy_source">(<a href="javascript:show('mcopy_source')">show</a>)</span>
-         <pre class="source" id="mcopy_source"><span class="r">class</span> <span class="cl">Object</span>
-  <span class="r">def</span> <span class="fu">mcopy</span>
-    <span class="co">Marshal</span>.load <span class="co">Marshal</span>.dump <span class="pc">self</span>
+
+  <span class="r">def</span> <span class="fu">&lt;&lt;</span>(other)
+    <span class="r">case</span>
+    <span class="r">when</span> other.is_a?(<span class="co">Hash</span>)
+      merge! other
+    <span class="r">when</span> other.respond_to?(<span class="sy">:to_splat</span>)
+      merge! <span class="co">Hash</span>[*other]
+    <span class="r">else</span>
+      raise <span class="co">TypeError</span>, <span class="s"><span class="dl">'</span><span class="k">can only append other Hashs and Enumerables</span><span class="dl">'</span></span>
+    <span class="r">end</span>
   <span class="r">end</span>
-  <span class="c"># alias copy mcopy</span>
 <span class="r">end</span>
 
-<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/hash2proc'">hash2proc</h3>
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/hash2proc'">hash2proc</h3>
          <table class="cube_table"
                 id="hash2proc_cube"
-                title="require 'zucker/1/hash2proc'"> <tr><th>Summary</th>    <td>Use a hash to apply procs to specific objects.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Hash#to_proc</h5><pre class="usage source" style="display:block">[<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>].map(&amp;{
+                title="require 'zucker/hash2proc'"> <tr><th>Summary</th>    <td>Use a hash to apply procs to specific objects.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Hash#to_proc</h5><pre class="usage source" style="display:block">[<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>].map(&amp;{
 <span class="i">2</span> =&gt; lambda {|e| e + <span class="i">1000</span>},
 <span class="i">4</span> =&gt; <span class="sy">:to_s</span>,
-}) <span class="c"># =&gt; [1, 1002, 3, '4']</span></pre></td></tr><tr><th>Further information</th>    <td>More about to_proc: http://rbjl.net/29-become-a-proc-star</td></tr><tr><th>Specification</th>    <td> <span id="show_hash2proc_specification">(<a href="javascript:show('hash2proc_specification')">show</a>)</span>
-         <pre class="source" id="hash2proc_specification">require <span class="s"><span class="dl">'</span><span class="k">hash2proc</span><span class="dl">'</span></span>
+}) <span class="c"># =&gt; [1, 1002, 3, '4']</span></pre></td></tr><tr><th>Further information</th>    <td>More about <a href="http://rbjl.net/29-become-a-proc-star">to_proc</a>.</td></tr><tr><th>Specification</th>    <td> <span id="show_hash2proc_spec">(<a href="javascript:show('hash2proc_spec')">show</a>)</span>
+         <pre class="source" id="hash2proc_spec">require <span class="s"><span class="dl">'</span><span class="k">hash2proc</span><span class="dl">'</span></span>
 
 describe <span class="s"><span class="dl">'</span><span class="k">Hash#to_proc</span><span class="dl">'</span></span> <span class="r">do</span>
   it <span class="s"><span class="dl">'</span><span class="k">should run the proc given in the value for a key in the hash</span><span class="dl">'</span></span> <span class="r">do</span>
@@ -730,63 +734,151 @@ describe <span class="s"><span class="dl">'</span><span class="k">Hash#to_proc</
       <span class="r">end</span>
     }
   <span class="r">end</span>
-<span class="r">end</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/enumerable'">enumerable</h3>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/iterate'">iterate</h3>
          <table class="cube_table"
-                id="enumerable_cube"
-                title="require 'zucker/1/enumerable'"> <tr><th>Summary</th>    <td><code>Enumerable</code> extensions.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Enumerable#mash</h5><pre class="usage source" style="display:block">[<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>].mash{|e| [e, e.to_s] } <span class="c"># =&gt; {1=&gt;'1',2=&gt;'2',3=&gt;'3'}</span></pre></td></tr><tr><th>Further information</th>    <td>Inspired by Ruby Facets' mash</td></tr><tr><th>Specification</th>    <td> <span id="show_enumerable_specification">(<a href="javascript:show('enumerable_specification')">show</a>)</span>
-         <pre class="source" id="enumerable_specification">require <span class="s"><span class="dl">'</span><span class="k">enumerable</span><span class="dl">'</span></span>
+                id="iterate_cube"
+                title="require 'zucker/iterate'"> <tr><th>Summary</th>    <td>Iterate over one or more collections.</td></tr><tr><th>Why?</th>    <td>It's like <code>.each</code> with two differences: It feels more like a control structure and you can easily iterate over multiple objects.</td></tr><tr><th>Methods/Usage</th>    <td><h5>iterate</h5><pre class="usage source" style="display:block">iterate [<span class="i">1</span>,<span class="i">2</span>], [<span class="i">3</span>,<span class="i">4</span>,<span class="i">5</span>] <span class="r">do</span> |e,f|
+  puts <span class="s"><span class="dl">&quot;</span><span class="il"><span class="idl">#{</span>e<span class="idl">}</span></span><span class="k">,</span><span class="il"><span class="idl">#{</span>f<span class="idl">}</span></span><span class="dl">&quot;</span></span>
+<span class="r">end</span>
+<span class="c"># outputs</span>
+<span class="c">#  1,3</span>
+<span class="c">#  2,4</span>
+<span class="c">#  ,5</span>
+</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_iterate_spec">(<a href="javascript:show('iterate_spec')">show</a>)</span>
+         <pre class="source" id="iterate_spec">require <span class="s"><span class="dl">'</span><span class="k">iterate</span><span class="dl">'</span></span>
 
-describe <span class="s"><span class="dl">'</span><span class="k">Enumerable#mash</span><span class="dl">'</span></span> <span class="r">do</span>
-  it <span class="s"><span class="dl">'</span><span class="k">should &quot;map&quot; a hash</span><span class="dl">'</span></span> <span class="r">do</span>
-    [<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>].mash{|e| [e, e.to_s] }.should == {<span class="i">1</span>=&gt;<span class="s"><span class="dl">'</span><span class="k">1</span><span class="dl">'</span></span>,<span class="i">2</span>=&gt;<span class="s"><span class="dl">'</span><span class="k">2</span><span class="dl">'</span></span>,<span class="i">3</span>=&gt;<span class="s"><span class="dl">'</span><span class="k">3</span><span class="dl">'</span></span>,}
+describe <span class="s"><span class="dl">'</span><span class="k">Object#iterate</span><span class="dl">'</span></span> <span class="r">do</span>
+  let <span class="sy">:a</span>   <span class="r">do</span> [<span class="i">1</span>, <span class="i">2</span>, <span class="i">3</span>]     <span class="r">end</span>
+  let <span class="sy">:b</span>   <span class="r">do</span> <span class="s"><span class="dl">%w|</span><span class="k">a b c d</span><span class="dl">|</span></span>   <span class="r">end</span>
+  let <span class="sy">:res</span> <span class="r">do</span> <span class="co">Hash</span>.new {[]} <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should behave like Enumerable#each for a single argument</span><span class="dl">'</span></span> <span class="r">do</span>
+    iterate a <span class="r">do</span> |ele|
+      res[<span class="sy">:iter</span>] &lt;&lt; ele
+    <span class="r">end</span>
+
+    a.each <span class="r">do</span> |ele|
+      res[<span class="sy">:each</span>] &lt;&lt; ele
+    <span class="r">end</span>
+
+    res[<span class="sy">:iter</span>].should == res[<span class="sy">:each</span>]
   <span class="r">end</span>
-<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_enumerable_source">(<a href="javascript:show('enumerable_source')">show</a>)</span>
-         <pre class="source" id="enumerable_source"><span class="r">module</span> <span class="cl">Enumerable</span>
-  <span class="r">def</span> <span class="fu">mash</span>
-    ret = {}
-    each{ |kv|
-      ret.store *( <span class="r">yield</span>(kv)[<span class="i">0</span>,<span class="i">2</span>] )
-    }
-    ret
+
+  it <span class="s"><span class="dl">'</span><span class="k">should pass the right params to the block</span><span class="dl">'</span></span> <span class="r">do</span>
+    res = <span class="co">Hash</span>.new {[]} <span class="c"># TODO: why?</span>
+    res[<span class="sy">:iter_a_b</span>] = [] <span class="c"># ....</span>
+    res[<span class="sy">:iter_b_a</span>] = [] <span class="c"># ....</span>
+
+
+    iterate a, b <span class="r">do</span> |e,f|
+      res[<span class="sy">:iter_a_b</span>] &lt;&lt; [e, f]
+<span class="c">#      p res[:iter_a_b], e, f</span>
+    <span class="r">end</span>
+
+    res[<span class="sy">:iter_a_b</span>].should == [
+      [<span class="i">1</span>, <span class="s"><span class="dl">'</span><span class="k">a</span><span class="dl">'</span></span>],
+      [<span class="i">2</span>, <span class="s"><span class="dl">'</span><span class="k">b</span><span class="dl">'</span></span>],
+      [<span class="i">3</span>, <span class="s"><span class="dl">'</span><span class="k">c</span><span class="dl">'</span></span>],
+      [<span class="pc">nil</span>, <span class="s"><span class="dl">'</span><span class="k">d</span><span class="dl">'</span></span>],
+    ]
+
+    iterate b, a <span class="r">do</span> |e,f|
+      res[<span class="sy">:iter_b_a</span>] &lt;&lt; [e, f]
+    <span class="r">end</span>
+
+    res[<span class="sy">:iter_b_a</span>].should == [
+      [<span class="s"><span class="dl">'</span><span class="k">a</span><span class="dl">'</span></span>, <span class="i">1</span>],
+      [<span class="s"><span class="dl">'</span><span class="k">b</span><span class="dl">'</span></span>, <span class="i">2</span>],
+      [<span class="s"><span class="dl">'</span><span class="k">c</span><span class="dl">'</span></span>, <span class="i">3</span>],
+      [<span class="s"><span class="dl">'</span><span class="k">d</span><span class="dl">'</span></span>, <span class="pc">nil</span>],
+    ]
+
   <span class="r">end</span>
-<span class="r">end</span>
 
-<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/union'">union</h3>
-         <table class="cube_table"
-                id="union_cube"
-                title="require 'zucker/1/union'"> <tr><th>Summary</th>    <td>Easy creation of <code>Regexp.union</code>s</td></tr><tr><th>Methods/Usage</th>    <td><h5>Regexp#|, String#|</h5><pre class="usage source" style="display:block"><span class="rx"><span class="dl">/</span><span class="k">Ruby</span><span class="ch">\d</span><span class="dl">/</span></span> | <span class="rx"><span class="dl">/</span><span class="k">test</span><span class="dl">/</span><span class="mod">i</span></span> | <span class="s"><span class="dl">&quot;</span><span class="k">cheat</span><span class="dl">&quot;</span></span>
-<span class="c"># creates a Regexp similar to:</span>
-<span class="c"># /(Ruby\d|[tT][eE][sS][tT]|cheat)/</span>
-</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_union_specification">(<a href="javascript:show('union_specification')">show</a>)</span>
-         <pre class="source" id="union_specification">require <span class="s"><span class="dl">'</span><span class="k">union</span><span class="dl">'</span></span>
+  it <span class="s"><span class="dl">'</span><span class="k">should return enumerators if no block is applied</span><span class="dl">'</span></span> <span class="r">do</span>
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_iterate_source">(<a href="javascript:show('iterate_source')">show</a>)</span>
+         <pre class="source" id="iterate_source"><span class="r">def</span> <span class="fu">iterate</span>(*params)
+  <span class="c"># params.shift.zip(*params).each{ |*elements| yield *elements }</span>
 
-describe <span class="s"><span class="dl">'</span><span class="k">Regexp#|</span><span class="dl">'</span></span> <span class="r">do</span>
-  it <span class="s"><span class="dl">'</span><span class="k">should create an Regexp.union of both operands</span><span class="dl">'</span></span> <span class="r">do</span>
-    (<span class="rx"><span class="dl">/</span><span class="k">hallo</span><span class="dl">/</span></span> | <span class="rx"><span class="dl">/</span><span class="ch">\d</span><span class="k">+</span><span class="dl">/</span></span> | <span class="rx"><span class="dl">/</span><span class="k">.</span><span class="dl">/</span></span>).should ==
-      <span class="co">Regexp</span>.union( <span class="co">Regexp</span>.union(<span class="rx"><span class="dl">/</span><span class="k">hallo</span><span class="dl">/</span></span>, <span class="rx"><span class="dl">/</span><span class="ch">\d</span><span class="k">+</span><span class="dl">/</span></span>), <span class="rx"><span class="dl">/</span><span class="k">.</span><span class="dl">/</span></span> )
+  first = params.shift
+  <span class="r">if</span> params.empty? <span class="c"># single param - like each</span>
+    <span class="r">if</span> block_given?
+      first.map{|e| <span class="r">yield</span> e }
+    <span class="r">else</span>
+      first.map
+    <span class="r">end</span>
+  <span class="r">else</span>
+    padded_first = <span class="co">Array</span>.new( [first, *params].max_by(&amp;<span class="sy">:size</span>).size ){|i| first[i] } <span class="c"># append nils</span>
+    obj = padded_first.zip *params
+    <span class="r">if</span> block_given?
+      obj.map{|es| <span class="r">yield</span> *es }
+    <span class="r">else</span>
+      obj.map.to_enum
+    <span class="r">end</span>
   <span class="r">end</span>
 <span class="r">end</span>
 
-describe <span class="s"><span class="dl">'</span><span class="k">String#|</span><span class="dl">'</span></span> <span class="r">do</span>
-  it_should_behave_like <span class="s"><span class="dl">'</span><span class="k">Regexp#|</span><span class="dl">'</span></span>
-<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_union_source">(<a href="javascript:show('union_source')">show</a>)</span>
-         <pre class="source" id="union_source"><span class="r">class</span> <span class="cl">Regexp</span>
-  <span class="r">def</span> <span class="fu">|</span>(arg)
-    <span class="co">Regexp</span>.union <span class="pc">self</span>, arg.is_a?(<span class="co">Regexp</span>) ? arg : arg.to_s
-  <span class="r">end</span>
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/ivars'">ivars</h3>
+         <table class="cube_table"
+                id="ivars_cube"
+                title="require 'zucker/ivars'"> <tr><th>Summary</th>    <td>This method lets you easily assign lots of instance variables.</td></tr><tr><th>Why?</th>    <td>Often, you have to write boilerplate code for assigning instance varialbles, for example this one:<br/><code>def initialize(variable1, variable2)<br/>  @variable1, @variable2 = variable1, variable2<br/>end</code><br/></td></tr><tr><th>Methods/Usage</th>    <td><h5>instance_variables_from, ivars</h5><pre class="usage source" style="display:block"><span class="r">def</span> <span class="fu">a_method</span>(a = <span class="i">1</span>, b = <span class="i">2</span>)
+  instance_variables_from binding <span class="c"># assigns @a and @b</span>
+
+  params = {<span class="sy">:c</span> =&gt; <span class="i">3</span>, <span class="sy">:d</span> =&gt; <span class="i">4</span>}
+  instance_variables_from params <span class="c"># # assigns @c and @d</span>
 <span class="r">end</span>
+</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_ivars_spec">(<a href="javascript:show('ivars_spec')">show</a>)</span>
+         <pre class="source" id="ivars_spec">require <span class="s"><span class="dl">'</span><span class="k">ivars</span><span class="dl">'</span></span>
 
-<span class="r">class</span> <span class="cl">String</span>
-  <span class="r">def</span> <span class="fu">|</span>(arg)
-    <span class="co">Regexp</span>.union <span class="pc">self</span>, arg.is_a?(<span class="co">Regexp</span>) ? arg : arg.to_s
+describe <span class="s"><span class="dl">'</span><span class="k">instance_variables_from</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should tansform the given parameter to instance variables</span><span class="dl">'</span></span> <span class="r">do</span>
+    <span class="r">def</span> <span class="fu">a_method</span>(a = <span class="i">1</span>, b = <span class="i">2</span>)
+      instance_variables_from binding <span class="c"># assigns @a and @b</span>
+
+      params = {<span class="sy">:c</span> =&gt; <span class="i">3</span>, <span class="sy">:d</span> =&gt; <span class="i">4</span>}
+      ivars params <span class="c"># # assigns @c and @d</span>
+    <span class="r">end</span>
+
+    a_method
+    <span class="iv">@a</span>.should == <span class="i">1</span>
+    <span class="iv">@b</span>.should == <span class="i">2</span>
+    <span class="iv">@c</span>.should == <span class="i">3</span>
+    <span class="iv">@d</span>.should == <span class="i">4</span>
+
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_ivars_source">(<a href="javascript:show('ivars_source')">show</a>)</span>
+         <pre class="source" id="ivars_source"><span class="r">def</span> <span class="fu">instance_variables_from</span>(obj, *only)
+  iter =
+  <span class="r">if</span>    obj.is_a? <span class="co">Binding</span>
+    obj.eval(<span class="s"><span class="dl">'</span><span class="k">local_variables</span><span class="dl">'</span></span>).map{|e| [obj.eval(e), e] }
+  <span class="r">elsif</span> obj.is_a? <span class="co">Hash</span>
+    obj.map{|k,v| [v,k] }
+  <span class="r">else</span>
+<span class="c">#  elsif obj.is_a? Enumerable</span>
+    obj.each.with_index
   <span class="r">end</span>
+
+  ret = []
+  iter.each{ |value, arg|
+    arg = arg.to_s
+    <span class="r">if</span> only.include?(arg) || only.include?(arg.to_sym) || only.empty?
+      arg = <span class="s"><span class="dl">'</span><span class="k">_</span><span class="dl">'</span></span> + arg  <span class="r">if</span> (<span class="i">48</span>..<span class="i">57</span>).member? arg.unpack(<span class="s"><span class="dl">'</span><span class="k">C</span><span class="dl">'</span></span>)[<span class="i">0</span>]  <span class="c"># 1.8+1.9</span>
+      ret &lt;&lt; ivar = <span class="sy"><span class="sy">:</span><span class="dl">&quot;</span><span class="k">@</span><span class="il"><span class="idl">#{</span>arg<span class="idl">}</span></span><span class="dl">&quot;</span></span>
+      <span class="pc">self</span>.instance_variable_set ivar, value
+    <span class="r">end</span>
+  }
+  ret
 <span class="r">end</span>
+<span class="r">alias</span> <span class="fu">ivars</span> <span class="fu">instance_variables_from</span>
 
-<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9</td></tr></table> <h3 title="require 'zucker/1/kernel'">kernel</h3>
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/kernel'">kernel</h3>
          <table class="cube_table"
                 id="kernel_cube"
-                title="require 'zucker/1/kernel'"> <tr><th>Summary</th>    <td>Some useful general shortcut methods</td></tr><tr><th>Why?</th>    <td>Readability</td></tr><tr><th>Methods/Usage</th>    <td><h5>activate_warnings!</h5><pre class="usage source" style="display:block">activate_warnings! <span class="c"># sets $VERBOSE to 1</span></pre><h5>deactivate_warnings!</h5><pre class="usage source" style="display:block">deactivate_warnings! <span class="c"># sets $VERBOSE to 0</span></pre><h5>library?</h5><pre class="usage source" style="display:block">library? <span class="c"># checks, if the current file is ran directly</span></pre><h5>ignore_sigint!</h5><pre class="usage source" style="display:block">ignore_sigint! <span class="c"># blocks CTRL+C</span></pre></td></tr><tr><th>Specification</th>    <td> <span id="show_kernel_specification">(<a href="javascript:show('kernel_specification')">show</a>)</span>
-         <pre class="source" id="kernel_specification">require <span class="s"><span class="dl">'</span><span class="k">kernel</span><span class="dl">'</span></span>
+                title="require 'zucker/kernel'"> <tr><th>Summary</th>    <td>Some useful general shortcut methods</td></tr><tr><th>Why?</th>    <td>Readability</td></tr><tr><th>Methods/Usage</th>    <td><h5>activate_warnings!</h5><pre class="usage source" style="display:block">activate_warnings! <span class="c"># sets $VERBOSE to 1</span></pre><h5>deactivate_warnings!</h5><pre class="usage source" style="display:block">deactivate_warnings! <span class="c"># sets $VERBOSE to 0</span></pre><h5>library?</h5><pre class="usage source" style="display:block">library? <span class="c"># checks, if the current file is ran directly</span></pre><h5>ignore_sigint!</h5><pre class="usage source" style="display:block">ignore_sigint! <span class="c"># blocks CTRL+C</span></pre></td></tr><tr><th>Specification</th>    <td> <span id="show_kernel_spec">(<a href="javascript:show('kernel_spec')">show</a>)</span>
+         <pre class="source" id="kernel_spec">require <span class="s"><span class="dl">'</span><span class="k">kernel</span><span class="dl">'</span></span>
 
 describe <span class="s"><span class="dl">'</span><span class="k">activate_warnings!</span><span class="dl">'</span></span> <span class="r">do</span>
   it <span class="s"><span class="dl">'</span><span class="k">should set $VERBOSE to true</span><span class="dl">'</span></span> <span class="r">do</span>
@@ -837,108 +929,100 @@ describe <span class="s"><span class="dl">'</span><span class="k">ignore_sigint!
 
 <span class="r">def</span> <span class="fu">ignore_sigint!</span> <span class="c"># ctrl+c</span>
    <span class="co">Signal</span>.trap *<span class="s"><span class="dl">%w|</span><span class="k">SIGINT IGNORE</span><span class="dl">|</span></span>
-<span class="r">end</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/hash'">hash</h3>
+<span class="r">end</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/mcopy'">mcopy</h3>
          <table class="cube_table"
-                id="hash_cube"
-                title="require 'zucker/1/hash'"> <tr><th>Summary</th>    <td>Some sugar for dealing with hashs.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Hash.zip</h5><pre class="usage source" style="display:block"><span class="co">Hash</span>.zip [<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>], [<span class="i">4</span>,<span class="i">5</span>,<span class="i">6</span>] <span class="c"># =&gt; {1 =&gt; 4, 2 =&gt; 5, 3 =&gt; 6}</span></pre><h5>Hash#<<</h5><pre class="usage source" style="display:block">{<span class="i">1</span> =&gt; <span class="i">2</span>} &lt;&lt; [<span class="i">3</span>, <span class="i">4</span>] <span class="c"># =&gt; {1 =&gt; 2, 3 =&gt; 4}</span></pre></td></tr><tr><th>Further information</th>    <td>Some of the operators are inspired by Ruby Facets</td></tr><tr><th>Specification</th>    <td> <span id="show_hash_specification">(<a href="javascript:show('hash_specification')">show</a>)</span>
-         <pre class="source" id="hash_specification">require <span class="s"><span class="dl">'</span><span class="k">hash</span><span class="dl">'</span></span>
+                id="mcopy_cube"
+                title="require 'zucker/mcopy'"> <tr><th>Summary</th>    <td>Adds <code>Object#mcopy</code> to create a deep copy using <code>Marshal</code>.</td></tr><tr><th>Why?</th>    <td>Every Ruby book describes, you can do <code>Marshal.load Marshal.dump object</code> to create a deep copy... But who needs this verbose syntax in everyday coding?</td></tr><tr><th>Methods/Usage</th>    <td><h5>Object#mcopy</h5><pre class="usage source" style="display:block">a = <span class="s"><span class="dl">%w[</span><span class="k">hello world</span><span class="dl">]</span></span>
+b = a.mcopy
+</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_mcopy_spec">(<a href="javascript:show('mcopy_spec')">show</a>)</span>
+         <pre class="source" id="mcopy_spec">require <span class="s"><span class="dl">'</span><span class="k">mcopy</span><span class="dl">'</span></span>
 
-describe <span class="s"><span class="dl">'</span><span class="k">Hash.zip</span><span class="dl">'</span></span> <span class="r">do</span>
-  it <span class="s"><span class="dl">'</span><span class="k">should zip together both given enumerables and take them as key=&gt;values for a new hash</span><span class="dl">'</span></span>
-<span class="r">end</span>
+describe <span class="s"><span class="dl">'</span><span class="k">Object#mcopy</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">create a (deep) copy via marshalling</span><span class="dl">'</span></span> <span class="r">do</span>
+    a = <span class="s"><span class="dl">%w[</span><span class="k">hello world</span><span class="dl">]</span></span>
+    b = a.mcopy
+    b.should == a
 
-describe <span class="s"><span class="dl">'</span><span class="k">Hash#&lt;&lt;</span><span class="dl">'</span></span> <span class="r">do</span>
-  it <span class="s"><span class="dl">'</span><span class="k">should append new elements to the hash</span><span class="dl">'</span></span>
-<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_hash_source">(<a href="javascript:show('hash_source')">show</a>)</span>
-         <pre class="source" id="hash_source"><span class="r">class</span> <span class="cl">Hash</span>
-  <span class="r">def</span> <span class="pc">self</span>.<span class="fu">zip</span>(keys,values)
-    <span class="co">Hash</span>[ *[<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>].zip( [<span class="i">4</span>,<span class="i">5</span>,<span class="i">6</span>] ).flatten ]
+    b[<span class="i">0</span>][<span class="i">1</span>,<span class="i">1</span>] = <span class="s"><span class="dl">'</span><span class="dl">'</span></span>
+    b.should_not == a
   <span class="r">end</span>
-
-  <span class="r">def</span> <span class="fu">&lt;&lt;</span>(other)
-    <span class="r">case</span>
-    <span class="r">when</span> other.is_a?(<span class="co">Hash</span>)
-      merge! other
-    <span class="r">when</span> other.respond_to?(<span class="sy">:to_splat</span>)
-      merge! <span class="co">Hash</span>[*other]
-    <span class="r">else</span>
-      raise <span class="co">TypeError</span>, <span class="s"><span class="dl">'</span><span class="k">can only append other Hashs and Enumerables</span><span class="dl">'</span></span>
-    <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_mcopy_source">(<a href="javascript:show('mcopy_source')">show</a>)</span>
+         <pre class="source" id="mcopy_source"><span class="r">class</span> <span class="cl">Object</span>
+  <span class="r">def</span> <span class="fu">mcopy</span>
+    <span class="co">Marshal</span>.load <span class="co">Marshal</span>.dump <span class="pc">self</span>
   <span class="r">end</span>
+  <span class="c"># alias copy mcopy</span>
 <span class="r">end</span>
 
-<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/aliases'">aliases</h3>
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/mm'">mm</h3>
          <table class="cube_table"
-                id="aliases_cube"
-                title="require 'zucker/1/aliases'"> <tr><th>Summary</th>    <td>Some convenient aliases (and constants) for existing methods.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Object#is_an?</h5><pre class="usage source" style="display:block"><span class="co">Object</span>.is_a?</pre><h5>Enumerable#with</h5><pre class="usage source" style="display:block"><span class="co">Enumerable</span><span class="c">#zip</span></pre><h5>Enumerable#%</h5><pre class="usage source" style="display:block"><span class="co">Enumerable</span><span class="c">#zip</span></pre><h5>Array#**</h5><pre class="usage source" style="display:block"><span class="co">Array</span><span class="c">#product</span></pre><h5>Hash#+</h5><pre class="usage source" style="display:block"><span class="co">Hash</span><span class="c">#merge</span></pre><h5>Binding#[]</h5><pre class="usage source" style="display:block"><span class="co">Binding</span><span class="c">#eval</span></pre><h5>Infinity</h5><pre class="usage source" style="display:block"><span class="fl">1.0</span> / <span class="fl">0.0</span></pre><h5>NaN</h5><pre class="usage source" style="display:block"><span class="fl">0.0</span> / <span class="fl">0.0</span></pre></td></tr><tr><th>Specification</th>    <td> <span id="show_aliases_specification">(<a href="javascript:show('aliases_specification')">show</a>)</span>
-         <pre class="source" id="aliases_specification">require <span class="s"><span class="dl">'</span><span class="k">aliases</span><span class="dl">'</span></span>
-
-describe <span class="s"><span class="dl">'</span><span class="k">(aliases)</span><span class="dl">'</span></span> <span class="r">do</span>
-  it <span class="s"><span class="dl">'</span><span class="k">should create these aliases [ sorry, no real spec for this one :P ] </span><span class="dl">'</span></span> <span class="r">do</span>
-  <span class="c"># alias is_an? is_a?</span>
-
-  <span class="c">#  module Enumerable</span>
-  <span class="c">#    alias with zip</span>
-  <span class="c">#    alias %    zip</span>
-  <span class="c">#  end</span>
-
-  <span class="c">#  class Array</span>
-  <span class="c">#    alias ** product</span>
-  <span class="c">#  end</span>
+                id="mm_cube"
+                title="require 'zucker/mm'"> <tr><th>Summary</th>    <td><code>mm</code> displays an ordered public method list.</td></tr><tr><th>Why?</th>    <td>See some object's methods without those rarely used inherited methods</td></tr><tr><th>Methods/Usage</th>    <td><h5>Object#method_list, Object#mm</h5><pre class="usage source" style="display:block"><span class="s"><span class="dl">'</span><span class="k">test</span><span class="dl">'</span></span>.mm <span class="i">2</span> <span class="c"># outputs the list (2 levels deep)</span></pre></td></tr><tr><th>Further information</th>    <td>See <a href="http://rbjl.net/31-the-multi-mega-method-list">this article</a> for more information</td></tr><tr><th>Specification</th>    <td> <span id="show_mm_spec">(<a href="javascript:show('mm_spec')">show</a>)</span>
+         <pre class="source" id="mm_spec">require <span class="s"><span class="dl">'</span><span class="k">mm</span><span class="dl">'</span></span>
 
-  <span class="c">#  class Hash</span>
-  <span class="c">#    alias + merge</span>
-  <span class="c">#  end</span>
+describe <span class="s"><span class="dl">'</span><span class="k">Object#method_list</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should display an ordered method list</span><span class="dl">'</span></span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_mm_source">(<a href="javascript:show('mm_source')">show</a>)</span>
+         <pre class="source" id="mm_source"><span class="r">module</span> <span class="cl">Kernel</span>
+  <span class="r">def</span> <span class="fu">method_list</span>(levels = <span class="i">1</span>)
+    <span class="r">if</span> <span class="pc">self</span>.is_a? <span class="co">Module</span>
+      klass, method_function = <span class="pc">self</span>, <span class="sy">:public_methods</span>
+    <span class="r">else</span>
+      klass, method_function = <span class="pc">self</span>.class, <span class="sy">:public_instance_methods</span>
 
-  <span class="c">#  class Binding</span>
-  <span class="c">#    #alias [] eval</span>
-  <span class="c">#    def [](expr)</span>
-  <span class="c">#      self.eval &quot;#{expr}&quot;</span>
-  <span class="c">#    end</span>
-  <span class="c">#  end</span>
+      eigen = <span class="pc">self</span>.singleton_methods
+      <span class="r">if</span> !eigen.empty?
+        puts <span class="sy">:Eigenclass</span> <span class="c"># sorry for not being up to date, I just love the word</span>
+        p <span class="pc">self</span>.singleton_methods
+      <span class="r">end</span>
+    <span class="r">end</span>
 
-  <span class="r">end</span>
+    levels.times{ |level|
+      <span class="r">if</span> cur = klass.ancestors[level]
+        p cur                               <span class="c"># put class name</span>
+        p cur.send method_function, <span class="pc">false</span>   <span class="c"># put methods of the class</span>
+      <span class="r">else</span>
+        <span class="r">break</span>
+      <span class="r">end</span>
+    }
 
-  it <span class="s"><span class="dl">'</span><span class="k">should define these constants</span><span class="dl">'</span></span> <span class="r">do</span>
-    <span class="co">Infinity</span>.finite?.should == <span class="pc">false</span>
-    <span class="co">NaN</span>.nan?.should         == <span class="pc">true</span>
+    <span class="pc">self</span> <span class="c"># or whatever</span>
   <span class="r">end</span>
-<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_aliases_source">(<a href="javascript:show('aliases_source')">show</a>)</span>
-         <pre class="source" id="aliases_source"><span class="r">alias</span> <span class="fu">is_an?</span> <span class="fu">is_a?</span>
 
-<span class="r">module</span> <span class="cl">Enumerable</span>
-  <span class="r">alias</span> <span class="fu">with</span> <span class="fu">zip</span>
-  <span class="r">alias</span> <span class="fu">%</span>    <span class="fu">zip</span>
-<span class="r">end</span>
-
-<span class="r">class</span> <span class="cl">Array</span>
-  <span class="r">alias</span> <span class="fu">**</span> <span class="fu">product</span>
+  <span class="r">alias</span> <span class="fu">mm</span> <span class="fu">method_list</span>
 <span class="r">end</span>
 
-<span class="r">class</span> <span class="cl">Hash</span>
-  <span class="r">alias</span> <span class="fu">+</span> <span class="fu">merge</span>
-<span class="r">end</span>
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/regexp2proc'">regexp2proc</h3>
+         <table class="cube_table"
+                id="regexp2proc_cube"
+                title="require 'zucker/regexp2proc'"> <tr><th>Summary</th>    <td>Use &/regex/ to match it against strings</td></tr><tr><th>Methods/Usage</th>    <td><h5>Regexp#to_proc</h5><pre class="usage source" style="display:block"><span class="s"><span class="dl">%w|</span><span class="k">just another string array</span><span class="dl">|</span></span>.map    &amp;<span class="rx"><span class="dl">/</span><span class="k">[jy]</span><span class="dl">/</span></span>  <span class="c"># =&gt; [&quot;j&quot;, nil, nil, &quot;y&quot;]</span>
+<span class="s"><span class="dl">%w|</span><span class="k">just another string array</span><span class="dl">|</span></span>.select &amp;<span class="rx"><span class="dl">/</span><span class="k">[jy]</span><span class="dl">/</span></span>  <span class="c"># =&gt; [&quot;just&quot;, &quot;array&quot;]</span>
+</pre></td></tr><tr><th>Further information</th>    <td>More about <a href="http://rbjl.net/29-become-a-proc-star">to_proc</a>.</td></tr><tr><th>Specification</th>    <td> <span id="show_regexp2proc_spec">(<a href="javascript:show('regexp2proc_spec')">show</a>)</span>
+         <pre class="source" id="regexp2proc_spec">require <span class="s"><span class="dl">'</span><span class="k">regexp2proc</span><span class="dl">'</span></span>
 
-<span class="r">class</span> <span class="cl">Binding</span>
-  <span class="c">#alias [] eval</span>
-  <span class="r">def</span> <span class="fu">[]</span>(expr)
-    <span class="pc">self</span>.eval <span class="s"><span class="dl">&quot;</span><span class="il"><span class="idl">#{</span>expr<span class="idl">}</span></span><span class="dl">&quot;</span></span>
+describe <span class="s"><span class="dl">'</span><span class="k">Regexp#to_proc</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should match the regex</span><span class="dl">'</span></span> <span class="r">do</span>
+    <span class="s"><span class="dl">%w|</span><span class="k">just another string array</span><span class="dl">|</span></span>.map(     &amp;<span class="rx"><span class="dl">/</span><span class="k">[jy]</span><span class="dl">/</span></span>).should == [<span class="s"><span class="dl">&quot;</span><span class="k">j</span><span class="dl">&quot;</span></span>, <span class="pc">nil</span>, <span class="pc">nil</span>, <span class="s"><span class="dl">&quot;</span><span class="k">y</span><span class="dl">&quot;</span></span>]
+    <span class="s"><span class="dl">%w|</span><span class="k">just another string array</span><span class="dl">|</span></span>.select(  &amp;<span class="rx"><span class="dl">/</span><span class="k">[jy]</span><span class="dl">/</span></span>).should == [<span class="s"><span class="dl">&quot;</span><span class="k">just</span><span class="dl">&quot;</span></span>, <span class="s"><span class="dl">&quot;</span><span class="k">array</span><span class="dl">&quot;</span></span>]
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_regexp2proc_source">(<a href="javascript:show('regexp2proc_source')">show</a>)</span>
+         <pre class="source" id="regexp2proc_source"><span class="r">class</span> <span class="cl">Regexp</span>
+  <span class="r">def</span> <span class="fu">to_proc</span>
+    proc <span class="r">do</span> |e|
+      e.to_s[<span class="pc">self</span>]
+    <span class="r">end</span>
   <span class="r">end</span>
 <span class="r">end</span>
 
-<span class="c"># constants - who would use these in real-world code for other things?</span>
-<span class="co">Infinity</span> = <span class="fl">1.0</span> / <span class="fl">0.0</span> <span class="c"># or 2*Float::MAX</span>
-<span class="co">NaN</span>      = <span class="fl">0.0</span> / <span class="fl">0.0</span>
-
-<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/sandbox'">sandbox</h3>
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/sandbox'">sandbox</h3>
          <table class="cube_table"
                 id="sandbox_cube"
-                title="require 'zucker/1/sandbox'"> <tr><th>Summary</th>    <td>Creates a sandbox area.</td></tr><tr><th>Why?</th>    <td>Ruby comes with sandboxes, but they are hidden (--> integrated) in the <code>$SAFE</code> concept</td></tr><tr><th>Methods/Usage</th>    <td><h5>sandbox</h5><pre class="usage source" style="display:block">sandbox <span class="r">do</span>
+                title="require 'zucker/sandbox'"> <tr><th>Summary</th>    <td>Creates a sandbox area.</td></tr><tr><th>Why?</th>    <td>Ruby comes with sandboxes, but they are hidden (--> integrated) in the <code>$SAFE</code> concept</td></tr><tr><th>Methods/Usage</th>    <td><h5>sandbox</h5><pre class="usage source" style="display:block">sandbox <span class="r">do</span>
   <span class="c"># dangerous commands throw SecurityErrors ($SAFE=4)</span>
 <span class="r">end</span>
 <span class="c"># everything's normal again</span>
-</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_sandbox_specification">(<a href="javascript:show('sandbox_specification')">show</a>)</span>
-         <pre class="source" id="sandbox_specification">require <span class="s"><span class="dl">'</span><span class="k">sandbox</span><span class="dl">'</span></span>
+</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_sandbox_spec">(<a href="javascript:show('sandbox_spec')">show</a>)</span>
+         <pre class="source" id="sandbox_spec">require <span class="s"><span class="dl">'</span><span class="k">sandbox</span><span class="dl">'</span></span>
 
 describe <span class="s"><span class="dl">'</span><span class="k">sandbox</span><span class="dl">'</span></span> <span class="r">do</span>
   it <span class="s"><span class="dl">'</span><span class="k">should throw a SecurityError if bad commands are issued</span><span class="dl">'</span></span>
@@ -957,58 +1041,105 @@ describe <span class="s"><span class="dl">'</span><span class="k">sandbox</span>
   <span class="r">end</span>
 <span class="r">end</span>
 
-<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/blank'">blank</h3>
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/square_brackets_for'">square_brackets_for</h3>
          <table class="cube_table"
-                id="blank_cube"
-                title="require 'zucker/1/blank'"> <tr><th>Summary</th>    <td>Does pretty the same as in ActiveSupport (Every object can be asked if it is blank)</td></tr><tr><th>Why?</th>    <td>It's too familiar ;)</td></tr><tr><th>Methods/Usage</th>    <td><h5>Object#blank?</h5><pre class="usage source" style="display:block"><span class="s"><span class="dl">'</span><span class="k">an object</span><span class="dl">'</span></span>.blank? <span class="c"># =&gt; false</span></pre></td></tr><tr><th>Further information</th>    <td>See ActiveSupport</td></tr><tr><th>Specification</th>    <td> <span id="show_blank_specification">(<a href="javascript:show('blank_specification')">show</a>)</span>
-         <pre class="source" id="blank_specification">require <span class="s"><span class="dl">'</span><span class="k">blank</span><span class="dl">'</span></span>
+                id="square_brackets_for_cube"
+                title="require 'zucker/square_brackets_for'"> <tr><th>Summary</th>    <td>This helper methods defines <code>[]</code> and <code>[]=</code> for accesing an instance variable.</td></tr><tr><th>Methods/Usage</th>    <td><h5>square_brackets_for</h5><pre class="usage source" style="display:block"><span class="r">class</span> <span class="cl">Klass</span>
+  <span class="r">def</span> <span class="fu">initialize</span>
+    <span class="iv">@var</span> = {
+      <span class="sy">:a_key</span> =&gt; <span class="i">1</span>,
+      <span class="sy">:another_one</span> =&gt; <span class="i">2</span>,
+    }
+  <span class="r">end</span>
 
-describe <span class="s"><span class="dl">'</span><span class="k">Object#blank?</span><span class="dl">'</span></span> <span class="r">do</span>
-  it <span class="s"><span class="dl">'</span><span class="k">should be blank for blank values</span><span class="dl">'</span></span> <span class="r">do</span>
-    blank_values   = [ <span class="pc">nil</span>, <span class="pc">false</span>, <span class="s"><span class="dl">'</span><span class="dl">'</span></span>, <span class="s"><span class="dl">'</span><span class="k">   </span><span class="dl">'</span></span>, <span class="s"><span class="dl">&quot;</span><span class="k">  </span><span class="ch">\n</span><span class="ch">\t</span><span class="k">  </span><span class="ch">\r</span><span class="k"> </span><span class="dl">&quot;</span></span>, [], {}, <span class="rx"><span class="dl">/</span><span class="dl">/</span></span> ]
+  square_brackets_for <span class="sy">:var</span> <span class="c"># creates [] and []=</span>
+  <span class="c"># square_brackets_for :var, false # would create only []</span>
+<span class="r">end</span>
 
-    blank_values.each{ |blank|
-      blank.blank?.should == <span class="pc">true</span>
-    }
+a = <span class="co">Klass</span>.new
+a[<span class="sy">:a_key</span>] <span class="c"># =&gt; 1</span>
+</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_square_brackets_for_spec">(<a href="javascript:show('square_brackets_for_spec')">show</a>)</span>
+         <pre class="source" id="square_brackets_for_spec">require <span class="s"><span class="dl">'</span><span class="k">square_brackets_for</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">square_brackets_for</span><span class="dl">'</span></span> <span class="r">do</span>
+
+  before <span class="r">do</span>
+    <span class="r">class</span> <span class="cl">Klass</span>
+      <span class="r">def</span> <span class="fu">initialize</span>
+        <span class="iv">@var</span> = {
+          <span class="sy">:a_key</span> =&gt; <span class="i">1</span>,
+          <span class="sy">:another_one</span> =&gt; <span class="i">2</span>,
+        }
+      <span class="r">end</span>
+
+      <span class="iv">@eigenvar</span> = {
+        <span class="sy">:a_key</span> =&gt; <span class="i">99</span>
+      }
+    <span class="r">end</span>
   <span class="r">end</span>
 
-  it <span class="s"><span class="dl">'</span><span class="k">should not be blank for non blank values</span><span class="dl">'</span></span> <span class="r">do</span>
-    present_values = [ <span class="co">Object</span>.new, <span class="pc">true</span>, <span class="i">0</span>, <span class="i">1</span>, <span class="s"><span class="dl">'</span><span class="k">a</span><span class="dl">'</span></span>, [<span class="pc">nil</span>], { <span class="pc">nil</span> =&gt; <span class="pc">nil</span> } ]
+  it <span class="s"><span class="dl">'</span><span class="k">should define a [] getter (not a setter) for an instance var, if the second parameter is false</span><span class="dl">'</span></span> <span class="r">do</span>
 
-    present_values.each{ |present|
-      present.blank?.should == <span class="pc">false</span>
-    }
+    <span class="r">class</span> <span class="cl">Klass</span>
+      square_brackets_for <span class="sy">:var</span>, <span class="pc">nil</span>
+    <span class="r">end</span>
+
+    a = <span class="co">Klass</span>.new
+    a[<span class="sy">:a_key</span>].should == <span class="i">1</span>
+
+    proc <span class="r">do</span>
+      a[<span class="sy">:this_is</span>] = <span class="s"><span class="dl">'</span><span class="k">not possible</span><span class="dl">'</span></span>
+    <span class="r">end</span>.should raise_exception <span class="co">NoMethodError</span>
   <span class="r">end</span>
-<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_blank_source">(<a href="javascript:show('blank_source')">show</a>)</span>
-         <pre class="source" id="blank_source"><span class="r">class</span> <span class="cl">Object</span>
-  <span class="r">def</span> <span class="fu">blank?</span>
-    <span class="r">if</span> respond_to? <span class="sy">:empty?</span> <span class="r">then</span> empty? <span class="r">else</span> !<span class="pc">self</span> <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should define [] and []= for accessing an instance variable</span><span class="dl">'</span></span> <span class="r">do</span>
+
+    <span class="r">class</span> <span class="cl">Klass</span>
+      square_brackets_for <span class="sy">:var</span>
+    <span class="r">end</span>
+
+    a = <span class="co">Klass</span>.new
+    a[<span class="sy">:a_key</span>].should == <span class="i">1</span>
+
+    a[<span class="sy">:this_is</span>] = <span class="s"><span class="dl">'</span><span class="k">useful</span><span class="dl">'</span></span>
+    a[<span class="sy">:this_is</span>].should == <span class="s"><span class="dl">'</span><span class="k">useful</span><span class="dl">'</span></span>
   <span class="r">end</span>
 
-  <span class="r">def</span> <span class="fu">present?</span>
-    !blank?
+  it <span class="s"><span class="dl">'</span><span class="k">should also work for class-instance variables</span><span class="dl">'</span></span> <span class="r">do</span>
+
+    <span class="r">class</span> <span class="cl">Klass</span>
+      <span class="r">class</span> &lt;&lt; <span class="cl">Klass</span>
+        square_brackets_for <span class="sy">:eigenvar</span>
+      <span class="r">end</span>
+    <span class="r">end</span>
+
+    <span class="co">Klass</span>[<span class="sy">:a_key</span>].should == <span class="i">99</span>
   <span class="r">end</span>
-<span class="r">end</span>
 
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_square_brackets_for_source">(<a href="javascript:show('square_brackets_for_source')">show</a>)</span>
+         <pre class="source" id="square_brackets_for_source"><span class="r">def</span> <span class="fu">square_brackets_for</span>(ivar, assignment = <span class="pc">true</span>)
+<span class="c">#  undef []   if respond_to? :[]</span>
+<span class="c">#  undef []=  if respond_to? :[]=</span>
 
-{ <span class="c"># what to do              # for which classes</span>
-  lambda{ <span class="pc">true</span> }         =&gt; [<span class="co">FalseClass</span>, <span class="co">NilClass</span>],
-  lambda{ <span class="pc">false</span> }        =&gt; [<span class="co">TrueClass</span>, <span class="co">Numeric</span>],
-  lambda{ empty? }       =&gt; [<span class="co">Array</span>, <span class="co">Hash</span>],
-  lambda{ <span class="pc">self</span> !~ <span class="rx"><span class="dl">/</span><span class="ch">\S</span><span class="dl">/</span></span> } =&gt; [<span class="co">String</span>],
-  lambda{ <span class="pc">self</span> == <span class="rx"><span class="dl">/</span><span class="dl">/</span></span>   } =&gt; [<span class="co">Regexp</span>],
+<span class="c">#instance_eval do</span>
+  define_method <span class="sy">:[]</span> <span class="r">do</span> |key|
+    (instance_variable_get <span class="sy"><span class="sy">:</span><span class="dl">&quot;</span><span class="k">@</span><span class="il"><span class="idl">#{</span>ivar<span class="idl">}</span></span><span class="dl">&quot;</span></span>)[key]
+  <span class="r">end</span>
 
-}.each{ |action, klass_array|
-  klass_array.each{ |klass|
-    klass.send <span class="sy">:define_method</span>, <span class="sy">:blank?</span>, &amp;action
-  }
-}
+  <span class="r">if</span> assignment
+    define_method <span class="sy">:[]=</span> <span class="r">do</span> |key, value|
+      (instance_variable_get <span class="sy"><span class="sy">:</span><span class="dl">&quot;</span><span class="k">@</span><span class="il"><span class="idl">#{</span>ivar<span class="idl">}</span></span><span class="dl">&quot;</span></span>)[key] = value
+    <span class="r">end</span>
+  <span class="r">end</span>
+<span class="c">#end</span>
+
+<span class="r">end</span>
 
-<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/string'">string</h3>
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/string'">string</h3>
          <table class="cube_table"
                 id="string_cube"
-                title="require 'zucker/1/string'"> <tr><th>Summary</th>    <td><code>String</code> extensions.</td></tr><tr><th>Why?</th>    <td>Strings cannot be comfortable enough ;)</td></tr><tr><th>Methods/Usage</th>    <td><h5>String#^</h5><pre class="usage source" style="display:block"><span class="s"><span class="dl">'</span><span class="k">Yes vs No</span><span class="dl">'</span></span>^<span class="i">3</span> <span class="c"># =&gt; 'Yes'</span></pre><h5>String#lchomp</h5><pre class="usage source" style="display:block"><span class="s"><span class="dl">'</span><span class="k">   Yes</span><span class="dl">'</span></span>.lchomp  <span class="c"># =&gt; 'Yes'</span></pre><h5>String#lchomp!</h5><pre class="usage source" style="display:block"><span class="c"># mutable lchomp version</span></pre><h5>String#ords</h5><pre class="usage source" style="display:block"><span class="s"><span class="dl">'</span><span class="k">Hallo</span><span class="dl">'</span></span>.ords <span class="c"># =&gt; [72, 97, 108, 108, 111]</span></pre></td></tr><tr><th>Specification</th>    <td> <span id="show_string_specification">(<a href="javascript:show('string_specification')">show</a>)</span>
-         <pre class="source" id="string_specification">require <span class="s"><span class="dl">'</span><span class="k">string</span><span class="dl">'</span></span>
+                title="require 'zucker/string'"> <tr><th>Summary</th>    <td><code>String</code> extensions.</td></tr><tr><th>Why?</th>    <td>Strings cannot be comfortable enough ;)</td></tr><tr><th>Methods/Usage</th>    <td><h5>String#^</h5><pre class="usage source" style="display:block"><span class="s"><span class="dl">'</span><span class="k">Yes vs No</span><span class="dl">'</span></span>^<span class="i">3</span> <span class="c"># =&gt; 'Yes'</span></pre><h5>String#lchomp</h5><pre class="usage source" style="display:block"><span class="s"><span class="dl">'</span><span class="k">   Yes</span><span class="dl">'</span></span>.lchomp  <span class="c"># =&gt; 'Yes'</span></pre><h5>String#lchomp!</h5><pre class="usage source" style="display:block"><span class="c"># mutable lchomp version</span></pre><h5>String#ords</h5><pre class="usage source" style="display:block"><span class="s"><span class="dl">'</span><span class="k">Hallo</span><span class="dl">'</span></span>.ords <span class="c"># =&gt; [72, 97, 108, 108, 111]</span></pre></td></tr><tr><th>Specification</th>    <td> <span id="show_string_spec">(<a href="javascript:show('string_spec')">show</a>)</span>
+         <pre class="source" id="string_spec">require <span class="s"><span class="dl">'</span><span class="k">string</span><span class="dl">'</span></span>
 
 describe <span class="s"><span class="dl">'</span><span class="k">String#^</span><span class="dl">'</span></span> <span class="r">do</span>
   it <span class="s"><span class="dl">'</span><span class="k">should give C-like substring access to strings</span><span class="dl">'</span></span> <span class="r">do</span>
@@ -1059,90 +1190,87 @@ describe <span class="s"><span class="dl">'</span><span class="k">String#ords</s
   <span class="r">end</span>
 <span class="r">end</span>
 
-<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/binding'">binding</h3>
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/unary'">unary</h3>
          <table class="cube_table"
-                id="binding_cube"
-                title="require 'zucker/1/binding'"> <tr><th>Summary</th>    <td>Adds a verbose Binding#inspect</td></tr><tr><th>Why?</th>    <td>It gives you information about the current environment</td></tr><tr><th>Methods/Usage</th>    <td><h5>Binding#inspect</h5><pre class="usage source" style="display:block">binding.inspect</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_binding_specification">(<a href="javascript:show('binding_specification')">show</a>)</span>
-         <pre class="source" id="binding_specification">require <span class="s"><span class="dl">'</span><span class="k">binding</span><span class="dl">'</span></span>
+                id="unary_cube"
+                title="require 'zucker/unary'"> <tr><th>Summary</th>    <td>Easy conversion between strings and symbols.</td></tr><tr><th>Why?</th>    <td>Sometimes, you do not care if you get a <code>String</code> or <code>Symbol</code> as input - but when analysing it, you often need to choose one format. A concise possibility for this conversion is using the unary operators <code>String#-@</code> and <code>Symbol#+@</code></td></tr><tr><th>Methods/Usage</th>    <td><h5>String#+@</h5><pre class="usage source" style="display:block">+<span class="s"><span class="dl">'</span><span class="k">was_string</span><span class="dl">'</span></span> <span class="c"># =&gt; 'was_string'</span></pre><h5>String#-@</h5><pre class="usage source" style="display:block">-<span class="s"><span class="dl">'</span><span class="k">was_string</span><span class="dl">'</span></span> <span class="c"># =&gt; :was_string</span></pre><h5>Symbol#+@</h5><pre class="usage source" style="display:block">+<span class="sy">:was_symbol</span>  <span class="c"># =&gt; 'was_symbol'</span></pre><h5>Symbol#-@</h5><pre class="usage source" style="display:block">-<span class="sy">:was_symbol</span>  <span class="c"># =&gt; :was_symbol</span></pre></td></tr><tr><th>Further information</th>    <td>Inspired by (I've seen the unary + for Symbol somewhere on the net... but cannot remember where...)</td></tr><tr><th>Specification</th>    <td> <span id="show_unary_spec">(<a href="javascript:show('unary_spec')">show</a>)</span>
+         <pre class="source" id="unary_spec">require <span class="s"><span class="dl">'</span><span class="k">unary</span><span class="dl">'</span></span>
 
-describe <span class="s"><span class="dl">'</span><span class="k">Binding#inspect</span><span class="dl">'</span></span> <span class="r">do</span>
-  it <span class="s"><span class="dl">'</span><span class="k">should output the current environment</span><span class="dl">'</span></span>
-<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_binding_source">(<a href="javascript:show('binding_source')">show</a>)</span>
-         <pre class="source" id="binding_source"><span class="r">class</span> <span class="cl">Binding</span>
-  <span class="r">def</span> <span class="fu">inspect</span>
-    put_vars = lambda { |array|
-      <span class="r">if</span> array.empty?
-        <span class="s"><span class="dl">'</span><span class="k"> - none</span><span class="dl">'</span></span>
-      <span class="r">else</span>
-        array.map{|e| <span class="s"><span class="dl">&quot;</span><span class="k"> - </span><span class="il"><span class="idl">#{</span>e<span class="idl">}</span></span><span class="k">: </span><span class="il"><span class="idl">#{</span> <span class="pc">self</span>.eval <span class="s"><span class="dl">'</span><span class="k">#{e}</span><span class="dl">'</span></span><span class="idl">}</span></span><span class="dl">&quot;</span></span>}*<span class="s"><span class="dl">&quot;</span><span class="ch">\n</span><span class="dl">&quot;</span></span>
-      <span class="r">end</span>
-    }
+describe <span class="co">Symbol</span>, <span class="s"><span class="dl">'</span><span class="k">#+@</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should convert to_s</span><span class="dl">'</span></span> <span class="r">do</span>
+    +(<span class="sy">:matz</span>) == <span class="s"><span class="dl">'</span><span class="k">matz</span><span class="dl">'</span></span> <span class="c"># () 1.8 bug</span>
+  <span class="r">end</span>
+<span class="r">end</span>
 
-<span class="s"><span class="dl">&quot;</span><span class="il"><span class="idl">#{</span><span class="pc">self</span>.to_s<span class="idl">}</span></span><span class="k">
-local vars
-</span><span class="il"><span class="idl">#{</span> put_vars[ <span class="pc">self</span>.eval <span class="s"><span class="dl">'</span><span class="k">local_variables</span><span class="dl">'</span></span> ] <span class="idl">}</span></span><span class="k">
-(instance vars)
-</span><span class="il"><span class="idl">#{</span> put_vars[ <span class="pc">self</span>.eval <span class="s"><span class="dl">'</span><span class="k">instance_variables</span><span class="dl">'</span></span> ] <span class="idl">}</span></span><span class="k">
-self
- - </span><span class="il"><span class="idl">#{</span><span class="pc">self</span>.eval <span class="s"><span class="dl">'</span><span class="k">self</span><span class="dl">'</span></span><span class="idl">}</span></span><span class="k">
-block_given?
- - </span><span class="il"><span class="idl">#{</span><span class="pc">self</span>.eval <span class="s"><span class="dl">'</span><span class="k">block_given?</span><span class="dl">'</span></span><span class="idl">}</span></span><span class="dl">&quot;</span></span>
+describe <span class="co">Symbol</span>, <span class="s"><span class="dl">'</span><span class="k">#-@</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should do nothing</span><span class="dl">'</span></span> <span class="r">do</span>
+    -<span class="sy">:matz</span> == <span class="sy">:matz</span>
+  <span class="r">end</span>
+<span class="r">end</span>
 
+describe <span class="co">String</span>, <span class="s"><span class="dl">'</span><span class="k">#+@</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should do nothing</span><span class="dl">'</span></span> <span class="r">do</span>
+    +<span class="s"><span class="dl">'</span><span class="k">matz</span><span class="dl">'</span></span> == <span class="s"><span class="dl">'</span><span class="k">matz</span><span class="dl">'</span></span>
   <span class="r">end</span>
 <span class="r">end</span>
 
-<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/egonil'">egonil</h3>
-         <table class="cube_table"
-                id="egonil_cube"
-                title="require 'zucker/1/egonil'"> <tr><th>Summary</th>    <td>Creates a block, where <code>nil</code> does not raise <code>NoMethodError</code>s</td></tr><tr><th>Methods/Usage</th>    <td><h5>egonil, nn</h5><pre class="usage source" style="display:block">egonil <span class="r">do</span>
-  <span class="pc">nil</span>.some_methods.that[<span class="sy">:do</span>].not.exist
-<span class="r">end</span> <span class="c"># =&gt; nil</span>
+describe <span class="co">String</span>, <span class="s"><span class="dl">'</span><span class="k">#-@</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should convert to_sym</span><span class="dl">'</span></span> <span class="r">do</span>
+    -<span class="s"><span class="dl">'</span><span class="k">matz</span><span class="dl">'</span></span> == <span class="sy">:matz</span>
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_unary_source">(<a href="javascript:show('unary_source')">show</a>)</span>
+         <pre class="source" id="unary_source"><span class="r">class</span> <span class="cl">String</span>
+  <span class="r">def</span> <span class="fu">+@</span>
+    <span class="pc">self</span>
+  <span class="r">end</span>
 
-nn(<span class="i">5</span>){ <span class="pc">nil</span>.some_methods.that[<span class="sy">:do</span>].not.exist }
-<span class="c"># =&gt; 5</span>
-</pre></td></tr><tr><th>Further information</th>    <td>See http://rbjl.net/26-the-28-bytes-of-ruby-joy for more information and discussion</td></tr><tr><th>Specification</th>    <td> <span id="show_egonil_specification">(<a href="javascript:show('egonil_specification')">show</a>)</span>
-         <pre class="source" id="egonil_specification">require <span class="s"><span class="dl">'</span><span class="k">egonil</span><span class="dl">'</span></span>
+  <span class="r">def</span> <span class="fu">-@</span>
+    to_sym
+  <span class="r">end</span>
+<span class="r">end</span>
 
-describe <span class="s"><span class="dl">'</span><span class="k">egonil</span><span class="dl">'</span></span> <span class="r">do</span>
-  it <span class="s"><span class="dl">'</span><span class="k">should not raise nil exceptions in the block</span><span class="dl">'</span></span> <span class="r">do</span>
-    proc <span class="r">do</span>
-      egonil{ <span class="pc">nil</span>.some_methods.that[<span class="sy">:do</span>].not.exist }
-    <span class="r">end</span>.should_not raise_exception
+<span class="r">class</span> <span class="cl">Symbol</span>
+  <span class="r">def</span> <span class="fu">+@</span>
+    to_s
   <span class="r">end</span>
 
-  it <span class="s"><span class="dl">'</span><span class="k">should return the nil_value if given</span><span class="dl">'</span></span> <span class="r">do</span>
-    egonil(<span class="i">9</span>){ <span class="pc">nil</span>.some_methods.that[<span class="sy">:do</span>].not.exist }.should == <span class="i">9</span>
+  <span class="r">def</span> <span class="fu">-@</span>
+    <span class="pc">self</span>
   <span class="r">end</span>
+<span class="r">end</span>
 
-  it <span class="s"><span class="dl">'</span><span class="k">should restore default behaviour after the block</span><span class="dl">'</span></span> <span class="r">do</span>
-    proc <span class="r">do</span>
-      egonil{ <span class="pc">nil</span>.some_methods.that[<span class="sy">:do</span>].not.exist }
-    <span class="r">end</span>.should_not raise_exception
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8 (+:literal not possible)</td></tr></table> <h3 title="require 'zucker/union'">union</h3>
+         <table class="cube_table"
+                id="union_cube"
+                title="require 'zucker/union'"> <tr><th>Summary</th>    <td>Easy creation of <code>Regexp.union</code>s</td></tr><tr><th>Methods/Usage</th>    <td><h5>Regexp#|, String#|</h5><pre class="usage source" style="display:block"><span class="rx"><span class="dl">/</span><span class="k">Ruby</span><span class="ch">\d</span><span class="dl">/</span></span> | <span class="rx"><span class="dl">/</span><span class="k">test</span><span class="dl">/</span><span class="mod">i</span></span> | <span class="s"><span class="dl">&quot;</span><span class="k">cheat</span><span class="dl">&quot;</span></span>
+<span class="c"># creates a Regexp similar to:</span>
+<span class="c"># /(Ruby\d|[tT][eE][sS][tT]|cheat)/</span>
+</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_union_spec">(<a href="javascript:show('union_spec')">show</a>)</span>
+         <pre class="source" id="union_spec">require <span class="s"><span class="dl">'</span><span class="k">union</span><span class="dl">'</span></span>
 
-    proc <span class="r">do</span>
-      <span class="pc">nil</span>.a_method
-    <span class="r">end</span>.should raise_exception <span class="co">NoMethodError</span>
+describe <span class="s"><span class="dl">'</span><span class="k">Regexp#|</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should create an Regexp.union of both operands</span><span class="dl">'</span></span> <span class="r">do</span>
+    (<span class="rx"><span class="dl">/</span><span class="k">hallo</span><span class="dl">/</span></span> | <span class="rx"><span class="dl">/</span><span class="ch">\d</span><span class="k">+</span><span class="dl">/</span></span> | <span class="rx"><span class="dl">/</span><span class="k">.</span><span class="dl">/</span></span>).should ==
+      <span class="co">Regexp</span>.union( <span class="co">Regexp</span>.union(<span class="rx"><span class="dl">/</span><span class="k">hallo</span><span class="dl">/</span></span>, <span class="rx"><span class="dl">/</span><span class="ch">\d</span><span class="k">+</span><span class="dl">/</span></span>), <span class="rx"><span class="dl">/</span><span class="k">.</span><span class="dl">/</span></span> )
   <span class="r">end</span>
+<span class="r">end</span>
 
-  it <span class="s"><span class="dl">'</span><span class="k">raise NoMethodError for non-nil objects</span><span class="dl">'</span></span> <span class="r">do</span>
-    proc <span class="r">do</span>
-      egonil{ <span class="i">5</span>.a_method }
-    <span class="r">end</span>.should raise_exception <span class="co">NoMethodError</span>
-  <span class="r">end</span>
-<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_egonil_source">(<a href="javascript:show('egonil_source')">show</a>)</span>
-         <pre class="source" id="egonil_source"><span class="r">def</span> <span class="fu">egonil</span>(nil_value = <span class="pc">nil</span>)
-  <span class="r">yield</span>
-<span class="r">rescue</span> <span class="co">NoMethodError</span> =&gt; e
-  <span class="r">if</span> e.message =~ <span class="rx"><span class="dl">/</span><span class="k">NilClass$</span><span class="dl">/</span></span>
-    nil_value
-  <span class="r">else</span>
-    raise <span class="co">NoMethodError</span>
+describe <span class="s"><span class="dl">'</span><span class="k">String#|</span><span class="dl">'</span></span> <span class="r">do</span>
+  it_should_behave_like <span class="s"><span class="dl">'</span><span class="k">Regexp#|</span><span class="dl">'</span></span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_union_source">(<a href="javascript:show('union_source')">show</a>)</span>
+         <pre class="source" id="union_source"><span class="r">class</span> <span class="cl">Regexp</span>
+  <span class="r">def</span> <span class="fu">|</span>(arg)
+    <span class="co">Regexp</span>.union <span class="pc">self</span>, arg.is_a?(<span class="co">Regexp</span>) ? arg : arg.to_s
   <span class="r">end</span>
 <span class="r">end</span>
 
-<span class="r">alias</span> <span class="fu">nn</span> <span class="fu">egonil</span>
+<span class="r">class</span> <span class="cl">String</span>
+  <span class="r">def</span> <span class="fu">|</span>(arg)
+    <span class="co">Regexp</span>.union <span class="pc">self</span>, arg.is_a?(<span class="co">Regexp</span>) ? arg : arg.to_s
+  <span class="r">end</span>
+<span class="r">end</span>
 
-<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table>
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9</td></tr></table>
       </div>
 <br/>
     </div>
@@ -1150,7 +1278,7 @@ describe <span class="s"><span class="dl">'</span><span class="k">egonil</span><
     <div id="smile"><a href="http://rbjl.net">J-_-L</a></div>
     This is the Ruby Zucker 1 documentation.
     The current version is always available at <a href="http://rubyzucker.info">rubyzucker.info</a>.
-    Gem source at <a href="http://github.com/janlelis/zucker">github</a>.
+    Gem source can be found at <a href="http://github.com/janlelis/zucker">github</a>.
   </div>
 
 </body>