fancy 0.5.0 → 0.6.0

data/lib/compiler/ast/block.fy

@@ -16,28 +16,32 @@ class Fancy AST {
       @arguments required_args=(@args required_args)
 
       if: @partial then: {
-        first_expr = @body expressions first
+        @body = ExpressionList new: @line list: $ @body expressions map: |e| { convert_to_implicit_arg_send: e }
+      }
+    }
 
-        # if first expression is an identifier, use that as a 0-arg
-        # method name to send to new receiver (use a generated symbol
-        # name created in lib/parser/methods.fy / Fancy Parser#ast:partial_block:)
-        # if first expression is a message send where its receiver is
-        # an identifier, use that as the message name in a send to
-        # self and use the result as the receiver value for the rest.
-        new_receiver = Identifier from: (@args args first to_s) line: @line
-        match first_expr {
-          case Identifier ->
-            @body expressions shift()
-            @body unshift_expression: $ MessageSend new: @line message: first_expr to: (new_receiver) args: (MessageArgs new: @line args: [])
-          case MessageSend ->
-            match first_expr receiver {
-              case Self ->
-                first_expr receiver: new_receiver
-              case Identifier ->
-                first_expr receiver: $ MessageSend new: @line message: (first_expr receiver) to: (new_receiver) args: (MessageArgs new: @line args: [])
-            }
-        }
+    def convert_to_implicit_arg_send: expr {
+      # if expression is an identifier, use that as a 0-arg
+      # message name to send to new receiver (use a generated symbol
+      # name created in lib/parser/methods.fy / Fancy Parser#ast:partial_block:)
+      # if expression is a message send where its receiver is
+      # an identifier, use that as the message name in a send to
+      # self and use the result as the receiver value for the rest.
+      new_receiver = Identifier from: (@args args first to_s) line: @line
+      match expr {
+        case Identifier ->
+          expr = MessageSend new: @line message: expr to: new_receiver args: (MessageArgs new: @line args: [])
+        case MessageSend ->
+          match expr receiver {
+            case Self ->
+              expr receiver: new_receiver
+            case Identifier ->
+              expr receiver: $ MessageSend new: @line message: (expr receiver) to: (new_receiver) args: (MessageArgs new: @line args: [])
+            case MessageSend ->
+              expr receiver: $ convert_to_implicit_arg_send: $ expr receiver
+          }
       }
+      expr
     }
 
     def bytecode: g {

data/lib/compiler/ast/message_send.fy

@@ -26,11 +26,22 @@ class Fancy AST {
                        args: args
     }
 
+    def return_send? {
+      match @name {
+        case Identifier -> @name string == "return"
+        case _ -> false
+      }
+    }
+
     def bytecode: g {
       pos(g)
       if: (@receiver is_a?: Super) then: {
         SuperSend new: @line message: @name args: @args . bytecode: g
       } else: {
+        if: return_send? then: {
+          Return new: @line expr: @receiver . bytecode: g
+          return nil
+        }
 
         # check if we might have a block invocation using block(x,y) syntax.
         if: ruby_send? then: {

data/lib/contracts.fy

@@ -0,0 +1,60 @@
+class Object {
+  def require: require_block ensure: ensure_block body: body_block {
+    requirement = Contract Requirement new: require_block
+    ensurance = Contract Requirement new: ensure_block
+    retval = nil
+    requirement if_fullfilled: {
+      retval = body_block call
+    }
+    ensure_block if_fullfilled: {
+      retval
+    }
+  }
+
+  def require: require_block body: body_block {
+    requirement = Contract Requirement new: require_block
+    requirement if_fullfilled: {
+      body_block call
+    }
+  }
+
+  def ensure: ensure_block body: body_block {
+    require: ensure_block body: body_block
+  }
+}
+
+class Contract {
+  class RequirementError : RuntimeError
+  class Requirement {
+    def initialize: @block
+    def if_fullfilled: block {
+      @block call: [self]
+      block call
+    }
+    def true: expr {
+      { RequirementError new: "#{expr} not true" . raise! } unless: expr
+    }
+    def false: expr {
+      { RequirementError new: "#{expr} not false" . raise! } if: expr
+    }
+  }
+}
+
+# # usage:
+# class Fixnum {
+#   def / other {
+#     require: @{
+#       true: $ other is_a?: Fixnum
+#       true: $ other > 0
+#       # better:
+#       other class is: Fixnum
+#       other is > 0
+#
+#     } body: {
+#        "foo" println
+#     }
+#   }
+# }
+
+# f = 10 / 2
+# g = 10 / 0 # requirement error

data/lib/dynamic_slot_object.fy

@@ -0,0 +1,61 @@
+class DynamicSlotObject : BasicObject {
+  def initialize {
+    @object = Object new
+  }
+
+  def object {
+    @object
+  }
+
+  def unknown_message: m with_params: p {
+    m to_s split: ":" . each_with_index: |slotname idx| {
+      @object set_slot: slotname value: $ p[idx]
+    }
+  }
+}
+
+class DynamicKeyHash : BasicObject {
+  def initialize: @deep (false) {
+    @hash = <[]>
+  }
+
+  def hash {
+    @hash
+  }
+
+  def unknown_message: m with_params: p {
+    m to_s split: ":" . each_with_index: |slotname idx| {
+      val = p[idx]
+      if: @deep then: {
+        match val {
+          case Block -> val = val to_hash
+        }
+      }
+      @hash[slotname to_sym]: val
+    }
+  }
+}
+
+class DynamicValueArray : BasicObject {
+  def initialize {
+    @arr = []
+  }
+
+  def array {
+    @arr
+  }
+
+  def unknown_message: m with_params: p {
+    if: (p size > 0) then: {
+      subarr = []
+      m to_s split: ":" . each_with_index: |slotname idx| {
+        subarr << (slotname to_sym)
+        subarr << (p[idx])
+      }
+      @arr << subarr
+    } else: {
+      @arr << (m to_s rest to_sym) # skip leading :
+    }
+    self
+  }
+}

data/lib/enumerable.fy

@@ -1,533 +1,571 @@
-class FancyEnumerable {
-  """
-  Mixin-Class with useful methods for collections that implement an @each:@ method.
-  """
-
-  def includes?: item {
+class Fancy {
+  class Enumerable {
     """
-    @item Item to check if it's included in @self.
-    @return @true, if @item in @self, otherwise @false.
-
-    Indicates, if a collection includes a given element.
+    Mixin-Class with useful methods for collections that implement an @each:@ method.
     """
 
-    any?: |x| { item == x }
-  }
+    def each_with_index: block {
+      """
+      @block @Block@ to be called with each element and its index in the @self.
+      @return @self
 
-  def each: each_block in_between: between_block {
-    """
-    Similar to @each:@ but calls an additional @Block@ between
-    calling the first @Block@ for each element in self.
-    """
+      Iterate over all elements in @self.
+      Calls a given @Block@ with each element and its index.
+      """
 
-    between = { between = between_block }
-    each: |x| {
-      between call
-      each_block call: [x]
+      i = 0
+      each: |x| {
+        block call: [x, i]
+        i = i + 1
+      }
     }
-  }
 
-  def join: str {
-    """
-    @str Value (usually a @String@) to be used for the joined @String@.
-    @return @String@ containing all elements in @self interspersed with @str.
+    def includes?: item {
+      """
+      @item Item to check if it's included in @self.
+      @return @true, if @item in @self, otherwise @false.
 
-    Joins a collection with a @String@ between each element, returning a new @String@.
+      Indicates, if a collection includes a given element.
+      """
 
-          \"hello, world\" join: \"-\" # => \"h-e-l-l-o-,- -w-o-r-l-d\"
-    """
+      any?: |x| { item == x }
+    }
+
+    def each: each_block in_between: between_block {
+      """
+      Similar to @each:@ but calls an additional @Block@ between
+      calling the first @Block@ for each element in self.
+      """
 
-    s = ""
-    each: |c| {
-      s << c
-    } in_between: {
-      s << str
+      between = { between = between_block }
+      each: |x| {
+        between call
+        each_block call: [x]
+      }
     }
-    s
-  }
 
-  def any?: condition {
-    """
-    @condition @Block@ (or @Callable) that is used to check if any element in @self yields true for it.
-    @return @true, if @condition yields @true for any element, @false otherwise.
+    def join: str {
+      """
+      @str Value (usually a @String@) to be used for the joined @String@.
+      @return @String@ containing all elements in @self interspersed with @str.
 
-    Indicates, if any element meets the condition.
-    """
+      Joins a collection with a @String@ between each element, returning a new @String@.
+
+            \"hello, world\" join: \"-\" # => \"h-e-l-l-o-,- -w-o-r-l-d\"
+      """
 
-    each: |x| {
-      if: (condition call: [x]) then: {
-        return true
+      s = ""
+      each: |c| {
+        s << c
+      } in_between: {
+        s << str
       }
+      s
     }
-    false
-  }
 
-  def all?: condition {
-    """
-    @block Predicate @Block@ to be called for each element until it returns @false for any one of them.
-    @return @true if all elements in @self yield @true for @block, @false otherwise.
+    def any?: condition {
+      """
+      @condition @Block@ (or @Callable) that is used to check if any element in @self yields true for it.
+      @return @true, if @condition yields @true for any element, @false otherwise.
 
-    Takes condition-block and returns @true if all elements meet it.
-    """
+      Indicates, if any element meets the condition.
+      """
 
-    each: |x| {
-      unless: (condition call: [x]) do: {
-        return false
+      each: |x| {
+        if: (condition call: [x]) then: {
+          return true
+        }
       }
+      false
     }
-    true
-  }
 
-  def find: item {
-    """
-    @item Item to be found in @self.
-    @return The first element that is equal to @item or @nil, if none found.
+    def all?: condition {
+      """
+      @block Predicate @Block@ to be called for each element until it returns @false for any one of them.
+      @return @true if all elements in @self yield @true for @block, @false otherwise.
 
-    Returns @nil, if @item (or anything that returns @true when comparing to @item) isn't found.
-    Otherwise returns that element that is equal to @item.
-    """
+      Takes condition-block and returns @true if all elements meet it.
+      """
 
-    if: (item is_a?: Block) then: {
-      find_by: item
-    } else: {
       each: |x| {
-        if: (item == x) then: {
-          return x
+        unless: (condition call: [x]) do: {
+          return false
         }
       }
-      nil
+      true
     }
-  }
 
-  def find_by: block {
-    """
-    Similar to @find:@ but takes a block that is called for each element to find it.
-    """
+    def find: item {
+      """
+      @item Item to be found in @self.
+      @return The first element that is equal to @item or @nil, if none found.
+
+      Returns @nil, if @item (or anything that returns @true when comparing to @item) isn't found.
+      Otherwise returns that element that is equal to @item.
+      """
 
-    each: |x| {
-      if: (block call: [x]) then: |item| {
-        return item
+      if: (item is_a?: Block) then: {
+        find_by: item
+      } else: {
+        each: |x| {
+          if: (item == x) then: {
+            return x
+          }
+        }
+        nil
       }
     }
-    nil
-  }
 
-  def map: block {
-    """
-    @block A @Block@ that gets called with each element in @self.
-    @return An @Array@ containing all values of calling @block with each element in @self.
+    def find_by: block {
+      """
+      Similar to @find:@ but takes a block that is called for each element to find it.
+      """
 
-    Returns a new @Array@ with the results of calling a given block for every element.
-    """
+      each: |x| {
+        if: (block call: [x]) then: {
+          return x
+        }
+      }
+      nil
+    }
+
+    def map: block {
+      """
+      @block A @Block@ that gets called with each element in @self.
+      @return An @Array@ containing all values of calling @block with each element in @self.
 
-    coll = []
-    each: |x| {
-      coll << (block call: [x])
+      Returns a new @Array@ with the results of calling a given block for every element.
+      """
+
+      coll = []
+      each: |x| {
+        coll << (block call: [x])
+      }
+      coll
     }
-    coll
-  }
 
-  def select: condition {
-    """
-    @condition A @Block@ that is used as a filter on all elements in @self.
-    @return An @Array@ containing all elements in @self that yield @true when called with @condition.
+    def select: condition {
+      """
+      @condition A @Block@ that is used as a filter on all elements in @self.
+      @return An @Array@ containing all elements in @self that yield @true when called with @condition.
 
-    Returns a new @Array@ with all elements that meet the given condition block.
-    """
+      Returns a new @Array@ with all elements that meet the given condition block.
+      """
 
-    coll = []
-    each: |x| {
-      { coll << x } if: $ condition call: [x]
+      coll = []
+      each: |x| {
+        { coll << x } if: $ condition call: [x]
+      }
+      coll
     }
-    coll
-  }
 
-  def reject: condition {
-    """
-    Similar to @select:@ but inverse.
-    Returns a new @Array@ with all elements that don't meet the given condition block.
-    """
+    def reject: condition {
+      """
+      Similar to @select:@ but inverse.
+      Returns a new @Array@ with all elements that don't meet the given condition block.
+      """
 
-    coll = []
-    each: |x| {
-      { coll << x } unless: $ condition call: [x]
+      coll = []
+      each: |x| {
+        { coll << x } unless: $ condition call: [x]
+      }
+      coll
     }
-    coll
-  }
 
-  def take_while: condition {
-    """
-    @condition A @Block@ that is used as a condition for filtering.
-    @return An @Array@ of all elements from the beginning until @condition yields @false.
+    def take_while: condition {
+      """
+      @condition A @Block@ that is used as a condition for filtering.
+      @return An @Array@ of all elements from the beginning until @condition yields @false.
 
-    Returns a new @Array@ by taking elements from the beginning
-    as long as they meet the given condition block.
+      Returns a new @Array@ by taking elements from the beginning
+      as long as they meet the given condition block.
 
-    Example:
-          [1,2,3,4,5] take_while: |x| { x < 4 } # => [1,2,3]
-    """
+      Example:
+            [1,2,3,4,5] take_while: |x| { x < 4 } # => [1,2,3]
+      """
 
-    coll = []
-    each: |x| {
-      if: (condition call: [x]) then: {
-        coll << x
-      } else: {
-        return coll
+      coll = []
+      each: |x| {
+        if: (condition call: [x]) then: {
+          coll << x
+        } else: {
+          return coll
+        }
       }
+      coll
     }
-    coll
-  }
 
-  def drop_while: condition {
-    """
-    Similar to @take_while:@ but inverse.
-    Returns a new @Array@ by skipping elements from the beginning
-    as long as they meet the given condition block.
+    def drop_while: condition {
+      """
+      Similar to @take_while:@ but inverse.
+      Returns a new @Array@ by skipping elements from the beginning
+      as long as they meet the given condition block.
 
-    Example:
-          [1,2,3,4,5] drop_while: |x| { x < 4 } # => [4,5]
-    """
+      Example:
+            [1,2,3,4,5] drop_while: |x| { x < 4 } # => [4,5]
+      """
 
-    coll = []
-    drop = nil
-    first_check = true
-    each: |x| {
-      if: (drop or: first_check) then: {
-        drop = condition call: [x]
-        first_check = nil
-        # check, if we actually have to insert this one:
-        unless: drop do: {
+      coll = []
+      drop = nil
+      first_check = true
+      each: |x| {
+        if: (drop or: first_check) then: {
+          drop = condition call: [x]
+          first_check = nil
+          # check, if we actually have to insert this one:
+          unless: drop do: {
+            coll << x
+          }
+        } else: {
           coll << x
         }
-      } else: {
-        coll << x
       }
+      coll
     }
-    coll
-  }
 
-  def take: amount {
-    """
-    @amount Amount of elements to take from @self.
-    @return First @amount elements of @self in an @Array@.
+    def take: amount {
+      """
+      @amount Amount of elements to take from @self.
+      @return First @amount elements of @self in an @Array@.
 
-    Example:
-          [1,2,3,4] take: 2 # => [1,2]
-    """
+      Example:
+            [1,2,3,4] take: 2 # => [1,2]
+      """
 
-    i = 0
-    take_while: {
-      i = i + 1
-      i <= amount
+      i = 0
+      take_while: {
+        i = i + 1
+        i <= amount
+      }
     }
-  }
 
-  def drop: amount {
-    """
-    @amount Amount of elements to skip in @self.
-    @return An @Array@ of all but the first @amount elements in @self.
+    def drop: amount {
+      """
+      @amount Amount of elements to skip in @self.
+      @return An @Array@ of all but the first @amount elements in @self.
 
-    Example:
-          [1,2,3,4,5] drop: 2 # => [3,4,5]
-    """
+      Example:
+            [1,2,3,4,5] drop: 2 # => [3,4,5]
+      """
 
-    i = 0
-    drop_while: {
-      i = i + 1
-      i <= amount
+      i = 0
+      drop_while: {
+        i = i + 1
+        i <= amount
+      }
     }
-  }
 
-  def reduce: block init_val: init_val {
-    """
-    Calculates a value based on a given block to be called on an accumulator
-    value and an initial value.
+    alias_method: 'skip: for: 'drop:
 
-    Example:
-          [1,2,3] reduce: |sum val| { sum + val } init_val: 0 # => 6
-    """
+    def reduce: block init_val: init_val {
+      """
+      Calculates a value based on a given block to be called on an accumulator
+      value and an initial value.
 
-    acc = init_val
-    each: |x| {
-      acc = (block call: [acc, x])
+      Example:
+            [1,2,3] reduce: |sum val| { sum + val } init_val: 0 # => 6
+      """
+
+      acc = init_val
+      each: |x| {
+        acc = (block call: [acc, x])
+      }
+      acc
     }
-    acc
-  }
 
-  def inject: val into: block {
-    """
-    Same as reduce:init_val: but taking the initial value as first
-    and the reducing block as second parameter.
+    def inject: val into: block {
+      """
+      Same as reduce:init_val: but taking the initial value as first
+      and the reducing block as second parameter.
 
-    Example:
-          [1,2,3] inject: 0 into: |sum val| { sum + val } # => 6
-    """
+      Example:
+            [1,2,3] inject: 0 into: |sum val| { sum + val } # => 6
+      """
 
-    reduce: block init_val: val
-  }
+      reduce: block init_val: val
+    }
 
-  def uniq {
-    """
-    @return @Array@ of all unique elements in @self.
+    def uniq {
+      """
+      @return @Array@ of all unique elements in @self.
 
-    Returns a new Array with all unique values (double entries are skipped).
+      Returns a new Array with all unique values (double entries are skipped).
 
-    Example:
-          [1,2,1,2,3] uniq # => [1,2,3]
-    """
+      Example:
+            [1,2,1,2,3] uniq # => [1,2,3]
+      """
 
-    uniq_vals = []
-    each: |x| {
-      unless: (uniq_vals includes?: x) do: {
-        uniq_vals << x
+      uniq_vals = []
+      each: |x| {
+        unless: (uniq_vals includes?: x) do: {
+          uniq_vals << x
+        }
       }
+      uniq_vals
     }
-    uniq_vals
-  }
 
-  def size {
-    """
-    @return Amount of elements in @self.
+    def size {
+      """
+      @return Amount of elements in @self.
 
-    Returns the size of an Enumerable.
-    """
+      Returns the size of an Enumerable.
+      """
 
-    i = 0
-    each: |x| {
-      i = i + 1
+      i = 0
+      each: |x| {
+        i = i + 1
+      }
+      i
     }
-    i
-  }
 
-  def empty? {
-    """
-    @return @true, if size of @self is 0, @false otherwise.
+    def empty? {
+      """
+      @return @true, if size of @self is 0, @false otherwise.
 
-    Indicates, if the Enumerable is empty (has no elements).
-    """
+      Indicates, if the Enumerable is empty (has no elements).
+      """
 
-    size == 0
-  }
+      size == 0
+    }
 
-  def first {
-    """
-    @return First element in @self or @nil, if empty.
-    """
+    def first {
+      """
+      @return First element in @self or @nil, if empty.
+      """
 
-    each: |x| {
-      return x
+      each: |x| {
+        return x
+      }
+      nil
     }
-    nil
-  }
 
-  def last {
-    """
-    @return Last element in @self or @nil, if empty.
+    def last {
+      """
+      @return Last element in @self or @nil, if empty.
 
-    Returns the last element in an Enumerable.
-    """
+      Returns the last element in an Enumerable.
+      """
 
-    item = nil
-    each: |x| {
-      item = x
+      item = nil
+      each: |x| {
+        item = x
+      }
+      item
     }
-    item
-  }
 
-  def compact {
-    """
-    @return @Array@ with all non-nil elements in @self.
+    def compact {
+      """
+      @return @Array@ with all non-nil elements in @self.
 
-    Returns a new @Array@ with all values removed that are @nil ( return @true on @nil? ).
+      Returns a new @Array@ with all values removed that are @nil ( return @true on @nil? ).
 
-    Example:
-          [1,2,nil,3,nil] compact # => [1,2,3]
-    """
+      Example:
+            [1,2,nil,3,nil] compact # => [1,2,3]
+      """
 
-    reject: |x| { x nil? }
-  }
+      reject: |x| { x nil? }
+    }
 
-  def superior_by: comparison_block taking: selection_block ('identity) {
-    """
-    @comparison_block @Block@ to be used for comparison.
-    @selection_block @Block@ to be used for selecting the values to be used for comparison by @comparison_bock.
-    @return Superior element in @self in terms of @comparison_block.
-
-    Returns the superior element in the @Enumerable that has met
-    the given comparison block with all other elements,
-    applied to whatever @selection_block returns for each element.
-    @selection_block defaults to @identity.
-
-    Examples:
-          [1,2,5,3,4] superior_by: '> # => 5
-          [1,2,5,3,4] superior_by: '< # => 1
-          [[1,2], [2,3,4], [], [1]] superior_by: '> taking: 'size # => [2,3,4]
-          [[1,2], [2,3,4], [-1]] superior_by: '< taking: 'first # => [-1]
-    """
+    def superior_by: comparison_block taking: selection_block ('identity) {
+      """
+      @comparison_block @Block@ to be used for comparison.
+      @selection_block @Block@ to be used for selecting the values to be used for comparison by @comparison_bock.
+      @return Superior element in @self in terms of @comparison_block.
 
+      Returns the superior element in the @Enumerable that has met
+      the given comparison block with all other elements,
+      applied to whatever @selection_block returns for each element.
+      @selection_block defaults to @identity.
 
-    pairs = self map: |val| {
-      (val, selection_block call: [val])
-    }
+      Examples:
+            [1,2,5,3,4] superior_by: '> # => 5
+            [1,2,5,3,4] superior_by: '< # => 1
+            [[1,2], [2,3,4], [], [1]] superior_by: '> taking: 'size # => [2,3,4]
+            [[1,2], [2,3,4], [-1]] superior_by: '< taking: 'first # => [-1]
+      """
 
-    retval = pairs first
-    pairs each: |p| {
-      if: (comparison_block call: [p second, retval second]) then: {
-        retval = p
+
+      pairs = self map: |val| {
+        (val, selection_block call: [val])
       }
-    }
-    retval first
-  }
 
-  def max {
-    """
-    @return Maximum value in @self.
+      retval = pairs first
+      pairs each: |p| {
+        if: (comparison_block call: [p second, retval second]) then: {
+          retval = p
+        }
+      }
+      retval first
+    }
 
-    Returns the maximum value in the Enumerable (via the '>' comparison message).
-    """
+    def max {
+      """
+      @return Maximum value in @self.
 
-    superior_by: '>
-  }
+      Returns the maximum value in the Enumerable (via the '>' comparison message).
+      """
 
-  def min {
-    """
-    @return Minimum value in @self.
+      superior_by: '>
+    }
 
-    Returns the minimum value in the Enumerable (via the '<' comparison message).
-    """
+    def min {
+      """
+      @return Minimum value in @self.
 
-    superior_by: '<
-  }
+      Returns the minimum value in the Enumerable (via the '<' comparison message).
+      """
 
-  def sum {
-    """
-    Calculates the sum of all the elements in the @Enumerable
-    (assuming them to be @Number@s (implementing '+' & '*')).
-    """
+      superior_by: '<
+    }
 
-    reduce: '+ init_val: 0
-  }
+    def sum {
+      """
+      Calculates the sum of all the elements in the @Enumerable
+      (assuming them to be @Number@s (implementing '+' & '*')).
+      """
 
-  def product {
-    """
-    Calculates the product of all the elements in the @Enumerable
-    (assuming them to be @Number@s (implementing @+ & @*)).
-    """
+      reduce: '+ init_val: 0
+    }
 
-    reduce: '* init_val: 1
-  }
+    def product {
+      """
+      Calculates the product of all the elements in the @Enumerable
+      (assuming them to be @Number@s (implementing @+ & @*)).
+      """
 
-  def average {
-    """
-    @return Average value in @self (expecting @Number@s or Objects implementing @+ and @*).
-    """
+      reduce: '* init_val: 1
+    }
 
-    { return 0 } if: (size == 0)
-    sum to_f / size
-  }
+    def average {
+      """
+      @return Average value in @self (expecting @Number@s or Objects implementing @+ and @*).
+      """
 
-  def partition_by: block {
-    """
-    @block @Block@ that gets used to decide when to partition elements in @self.
-    @return @Array@ of @Array@s, partitioned by equal return values of calling @block with each element
+      { return 0 } if: (size == 0)
+      sum to_f / size
+    }
 
-    Example:
-          0 upto: 10 . partition_by: |x| { x < 3 }  # => [[0, 1, 2], [3, 4, 5, 6, 7, 8, 9, 10]]
-    """
-    last = block call: [first]
-    coll = []
-    tmp_coll = []
-    each: |x| {
-      tmp = block call: [x]
-      if: (tmp != last) then: {
-        coll << tmp_coll
-        tmp_coll = [x]
-      } else: {
-        tmp_coll << x
+    def partition_by: block {
+      """
+      @block @Block@ that gets used to decide when to partition elements in @self.
+      @return @Array@ of @Array@s, partitioned by equal return values of calling @block with each element
+
+      Example:
+            0 upto: 10 . partition_by: |x| { x < 3 }  # => [[0, 1, 2], [3, 4, 5, 6, 7, 8, 9, 10]]
+      """
+      last = block call: [first]
+      coll = []
+      tmp_coll = []
+      each: |x| {
+        tmp = block call: [x]
+        if: (tmp != last) then: {
+          coll << tmp_coll
+          tmp_coll = [x]
+        } else: {
+          tmp_coll << x
+        }
+        last = tmp
       }
-      last = tmp
+      coll << tmp_coll
+      coll
     }
-    coll << tmp_coll
-    coll
-  }
 
-  def random {
-    """
-    @return Random element in @self.
-    """
+    def random {
+      """
+      @return Random element in @self.
+      """
 
-    at: (rand(size))
-  }
+      at: (rand(size))
+    }
 
-  def sort_by: block {
-    """
-    @block @Block@ taking 2 arguments used to compare elements in a collection.
-    @return Sorted @Array@ of elements in @self.
+    def sort_by: block {
+      """
+      @block @Block@ taking 2 arguments used to compare elements in a collection.
+      @return Sorted @Array@ of elements in @self.
 
-    Sorts a collection by a given comparison block.
-    """
+      Sorts a collection by a given comparison block.
+      """
 
-    if: (block is_a?: Symbol) then: {
-      sort() |a b| {
-        a receive_message: block . <=> (b receive_message: block)
+      if: (block is_a?: Symbol) then: {
+        sort() |a b| {
+          a receive_message: block . <=> (b receive_message: block)
+        }
+      } else: {
+        sort(&block)
       }
-    } else: {
-      sort(&block)
     }
-  }
 
-  def in_groups_of: size {
-    """
-    @size Maximum size of each group.
-    @return @Array@ of @Array@s with a max size of @size (grouped).
+    def in_groups_of: size {
+      """
+      @size Maximum size of each group.
+      @return @Array@ of @Array@s with a max size of @size (grouped).
 
-    Example usage:
-          [1,2,3,4,5] in_groups_of: 3 # => [[1,2,3],[4,5]]
-    """
+      Example usage:
+            [1,2,3,4,5] in_groups_of: 3 # => [[1,2,3],[4,5]]
+      """
 
-    groups = []
-    tmp = []
-    enum = to_enum
+      groups = []
+      tmp = []
+      enum = to_enum
 
-    loop: {
-      size times: {
-        tmp << (enum next)
-      }
+      loop: {
+        size times: {
+          tmp << (enum next)
+        }
+
+        if: (enum ended?) then: {
+          { groups << tmp } unless: $ tmp empty?
+          break
+        }
 
-      if: (enum ended?) then: {
-        { groups << tmp } unless: $ tmp empty?
-        break
+        groups << tmp
+        tmp = []
       }
 
-      groups << tmp
-      tmp = []
+      groups
     }
 
-    groups
-  }
+    def reverse {
+      """
+      @return @self in reverse order.
 
-  def reverse {
-    """
-    @return @self in reverse order.
+      Returns @self in reverse order.
+      This only makes sense for collections that have an ordering.
+      In either case, it simply converts @self to an @Array@ and returns it in reversed order.
+      """
 
-    Returns @self in reverse order.
-    This only makes sense for collections that have an ordering.
-    In either case, it simply converts @self to an @Array@ and returns it in reversed order.
-    """
+      rev = self to_a
+      rev reverse
+    }
 
-    rev = self to_a
-    rev reverse
-  }
+    def to_hash: block {
+      """
+      @block @Block@ to be called to get the key for each element in @self.
+      @return @Hash@ of key/value pairs based on values in @self.
 
-  def reverse_each: block {
-    """
-    @block @Block@ to be called for each element in reverse order.
-    @return @self
+      Example:
+              [\"foo\", \”hello\", \"ok\", \"\"] to_hash: @{ size }
+              # => <[3 => \"foo\", 5 => \"hello\", 2 => \"ok\", 0 => \"\"]>
+      """
 
-    Runs @block for each element on reversed version of self.
-    If @self is not a sorted collection, no guarantees about the reverse order can be given.
-    """
+      h = <[]>
+      self each: |val| {
+        key = block call: [val]
+        h[key]: val
+      }
+      h
+    }
+
+    def reverse_each: block {
+      """
+      @block @Block@ to be called for each element in reverse order.
+      @return @self
 
-    reverse each: block
+      Runs @block for each element on reversed version of self.
+      If @self is not a sorted collection, no guarantees about the reverse order can be given.
+      """
+
+      reverse each: block
+    }
   }
-}
+}