fancy 0.3.3 → 0.4.0

data/examples/actor_bunnies.fy

@@ -0,0 +1,32 @@
+# Inspired by actors example at http://www.artima.com/weblogs/viewpost.jsp?thread=328540
+
+class Bunny {
+  def initialize: @id {
+    self @@ hop
+  }
+  def hop {
+    self ++ " " print
+    self @@ hop
+    Thread sleep: 0.5
+  }
+  def stop: respond_to {
+    "Stopping #{self}" println
+    die!
+    respond_to @@ stopped
+  }
+  def to_s {
+    "Bunny(#{@id})"
+  }
+}
+
+@thread  = Thread current # save current Thread so it can be resumed
+def self stopped {
+  @amount = @amount - 1
+  { @thread run } if: (@amount == 0)
+}
+
+@amount = 10
+bunnies = (0..@amount) map: |i| { Bunny new: i }
+Console readln: "\n\nPress ENTER to stop bunnies\n\n"
+bunnies each: |b| { b @@ stop: self }
+Thread stop # wait to be resumed when all bunnies are killed

data/examples/actors.fy

@@ -0,0 +1,26 @@
+# Does the same as actors_primitive.fy but using
+# normal objects as actors by sending messages asynchronously (via @@ syntax).
+class PingPong {
+  Done = false
+  def initialize: @block {
+  }
+
+  def count: count reply: other {
+    @block call
+    if: (count > 1000) then: {
+      count println
+      Done = true
+    } else: {
+      other @@ count: (count + 1) reply: self
+    }
+  }
+}
+
+pong = PingPong new: { "-" print }
+ping = PingPong new: { "." print }
+
+ping @@ count: 1 reply: pong
+
+until: { PingPong Done } do: {
+  Thread sleep: 0.1
+}

data/examples/actors_primitive.fy

@@ -0,0 +1,27 @@
+pong = nil
+done = false
+
+ping = Actor spawn: {
+  loop: {
+    count = Actor receive
+    "." print
+    { count println; done = true; break } if: (count > 1000)
+    pong ! (count + 1)
+  }
+}
+
+pong = Actor spawn: {
+  loop: {
+    count = Actor receive
+    "-" print
+    { count println; done = true; break } if: (count > 1000)
+    ping ! (count + 1)
+  }
+}
+
+ping ! 1
+
+# Let the actors process while the main thread sleeps...
+until: { done } do: {
+  Thread sleep: 0.1
+}

data/examples/actors_ring.fy

@@ -0,0 +1,37 @@
+class Ring {
+  class Node {
+    def initialize: @next ring: @ring { }
+
+    def count: count {
+      if: @next then: {
+       "." print
+        @next @@ count: (count + 1)
+      } else: {
+        "DONE: " ++ count println
+        @ring done: true
+      }
+      die! # let this actor die to free resources
+    }
+  }
+
+  read_write_slot: 'done
+  def initialize: amount {
+    node = nil
+    amount times: {
+      node = Node new: node ring: self
+    }
+    @start = node
+    @done = false
+  }
+
+  def start {
+    @start count: 1
+  }
+}
+
+# create ring and run through it
+ring = Ring new: 4000
+ring start
+until: { ring done } do: {
+  Thread sleep: 0.1
+}

data/examples/armstrong_numbers.fy

@@ -12,7 +12,7 @@ class Fixnum {
     tmp = self
     while: { tmp >= 10 } do: {
       decimals << (tmp modulo: 10)
-      tmp = (tmp div: 10)
+      tmp = tmp div: 10
     }
     decimals << tmp
     decimals

data/examples/array.fy

@@ -5,9 +5,7 @@
 arr = [1,2,3,4,5,6]
 
 # print each element squared
-arr each: |x| {
-  x squared println
-}
+arr each: @{ squared println }
 
 # display each element with its index in the array
 arr each_with_index: |x i| {
@@ -21,22 +19,22 @@ arr map: 'squared . inspect println
 arr map: 'doubled . inspect println
 
 # print array of all elements smaller than 4
-arr select: |x| { x < 4 } . inspect println
+arr select: @{ < 4 } . inspect println
 
 # print array of all elements that are not smaller than 4
-arr reject: |x| { x < 4 } . inspect println
+arr reject: @{ < 4 } . inspect println
 
 # prints: [5, 6]
-arr take_while: |x| { x < 5 } . inspect println
+arr take_while: @{ < 5 } . inspect println
 
 "testing reduce:init_val: " print
 arr reduce: |acc x| { acc * x } init_val: 1 . println # same as: 1*1*2*3*4*5*6
 
 "testing any?: " print
-arr any?: |x| { x > 3 } . println # prints: true
+arr any?: @{ > 3 } . println # prints: true
 
 "testing all?: " print
-arr all?: |x| { x < 7 } . println # prints: true
+arr all?: @{ < 7 } . println # prints: true
 
 "testing from:to: " print
 arr [[3,5]] . inspect println # prints: [4, 5, 6]
@@ -49,4 +47,4 @@ arr size println # prints: 6
 arr to_s println # prints: 123456
 
 "testing inspect: " print
-arr inspect println # prints: [1, 2, 3, 4, 5, 6] : Array
+arr inspect println # prints: [1, 2, 3, 4, 5, 6]

data/examples/async_send.fy

@@ -1,10 +1,9 @@
 def bar {
   "In bar!" println
-  yield
+  Thread sleep: 1
   "OK, done!" println
 }
 
-self @@ bar
 self @@ bar
 Thread sleep: 1
 self @@ bar

data/examples/blocks.fy

@@ -8,8 +8,8 @@ y = |x y| { Console println: $ x + y }
 y call: [2, 3] # calls y and prints: 5
 
 # prints numbers 0 to 20
-zahl = 0
-while: { zahl <= 20 } do: {
-  Console println: zahl
-  zahl = zahl + 1
+num = 0
+while: { num <= 20 } do: {
+  Console println: num
+  num = num + 1
 }

data/examples/call_with_receiver.fy

@@ -1,4 +1,4 @@
-block = { self foo }
+block = { foo }
 
 class Foo {
   def foo {

data/examples/class.fy

@@ -20,7 +20,7 @@ class Foo : Bar {
   def say_hello {
     Console print: "Hello, "
     Console println: @name
-    {@block call} if: @block
+    { @block call } if: @block
   }
   def on_hello_do: block {
     @block = block

data/examples/default_args.fy

@@ -1,7 +1,7 @@
 # default_args.fy
 # Example of fancy's default arguments
 
-def arg1: arg1 arg2: arg2 ("default_arg2") arg3: arg3 ("default_arg3") {
+def arg1: arg1 ("default_arg1") arg2: arg2 ("default_arg2") arg3: arg3 ("default_arg3") {
   "arguments are: " println
   arg1 println
   arg2 println
@@ -15,3 +15,6 @@ arg1: "hello" arg2: "world"
 
 Console newline
 arg1: "hello"
+
+Console newline
+arg1

data/examples/define_methods.fy

@@ -4,12 +4,12 @@ arr define_singleton_method: "foo" with: {
   self inspect println
 }
 
-arr send: 'foo
+arr receive_message: 'foo
 
 arr undefine_singleton_method: "foo"
 
 try {
-  arr send: 'foo
+  arr receive_message: 'foo
 } catch NoMethodError => e {
   e println
 }

data/examples/echo.fy

@@ -1,7 +1,7 @@
 # echo.fy
 # Outputs contents of files
 
-ARGV[1] if_true: |filename| {
+if: (ARGV[1]) then: |filename| {
  try {
     File open: filename modes: ['read] with: |f| {
       until: { f eof? } do: {

data/examples/factorial.fy

@@ -8,5 +8,5 @@ class Fixnum {
 }
 
 1 upto: 10 do: |i| {
-  i to_s ++ "! = " ++ (i factorial) println
+  "#{i}! = #{i factorial}" println
 }

data/examples/future_composition.fy

@@ -4,8 +4,8 @@ def do_large_computation: x {
   x upto: (x ** x)
 }
 
-# Future#&& takes a Block (or a Callable - something that implements 'call:)
-# and creates a new Future that executes the given Block with the value of the first Future
+# FutureSend#&& takes a Block (or a Callable - something that implements 'call:)
+# and creates a new FutureSend that executes the given Block with the value of the first FutureSend
 # when it has finished its computation. This makes pipelining tasks easy.
 
 f = self @ do_large_computation: 5 && @{select: 'even?} && @{inspect println}

data/examples/futures.fy

@@ -1,8 +1,3 @@
-if: (ARGV[1]) then: |n| {
-  "Using #{n} threads" println
-  Future pool: $ n to_i
-}
-
 fs = []
 100 times: |i| {
   f = { Thread sleep: 0.5; i println } @ call

data/examples/game_of_life.fy

@@ -30,7 +30,7 @@ class World {
     }
   }
 
-  def [] index {
+  def [index] {
     "Return the row for a given index."
     @matrix[index]
   }

data/examples/person.fy

@@ -2,7 +2,7 @@
 # Annotated example of fancy's classes mechanism
 
 class City {
-  read_slots: ['name]
+  read_slot: 'name
   def initialize: @name {
   }
 

data/lib/argv.fy

@@ -1,8 +1,13 @@
+ARGV documentation: """
+  ARGV is a singleton instance of @Array@ and holds all (command-line)
+  arguments passed to a Fancy programm before it starts executing.
+  """
+
 def ARGV for_option: op_name do: block {
   "Runs a given block if an option is in ARGV."
 
   ARGV index: op_name . if_true: |idx| {
-    if: (block argcount > 0) then: {
+    if: (block arity > 0) then: {
       ARGV[idx + 1] if_true: |arg| {
         block call: [arg]
         ARGV remove_at: idx
@@ -20,7 +25,7 @@ def ARGV for_options: op_names do: block {
 
   op_names size times: |i| {
     if: (ARGV index: (op_names[i])) then: |idx| {
-      if: (block argcount > 0) then: {
+      if: (block arity > 0) then: {
         if: (ARGV[idx + 1]) then: |arg| {
           block call: [arg]
           ARGV remove_at: idx

data/lib/array.fy

@@ -8,13 +8,22 @@ class Array {
   include: FancyEnumerable
 
   def Array new: size {
-    "Creates a new Array with a given size (default value is nil)."
+    """
+    @size Initial size of the @Array@ to be created (values default to @nil).
+
+    Creates a new Array with a given @size (default value is @nil).
+    """
 
     Array new: size with: nil
   }
 
   def clone {
-    "Clones (shallow copy) the Array."
+    """
+    @return A shallow copy of the @Array@.
+
+    Clones (shallow copy) the @Array@.
+    """
+
     new = []
     each: |x| {
       new << x
@@ -23,7 +32,17 @@ class Array {
   }
 
   def append: arr {
-    "Appends another Array onto this one."
+    """
+    @arr Other @Array@ to be appended to @self.
+    @return @self
+
+    Appends another @Array@ onto this one.
+
+    Example:
+        a = [1,2,3]
+        a append: [3,4,5]
+        a # => [1,2,3,3,4,5]
+    """
 
     arr each: |x| {
       self << x
@@ -31,11 +50,13 @@ class Array {
     self
   }
 
-  def [] index {
+  def [index] {
     """
-    Given an Array of 2 Numbers, it returns the sub-array between the
-    given indices.
-    If given a Number, returns the element at that index.
+    @index Index to get the value for or @Array@ of 2 indices used for a sub-array.
+    @return Element(s) stored in @self at @index, possibly @nil or an empty @Array@.
+
+    Given an @Array@ of 2 @Fixnum@s, it returns the sub-array between the given indices.
+    If given a single @Fixnum@, returns the element at that index.
     """
 
     # if given an Array, interpret it as a from:to: range subarray
@@ -47,34 +68,46 @@ class Array {
   }
 
   def first {
-    "Returns the first element in the Array."
+    """
+    @return The first element in the @Array@.
+    """
     at: 0
   }
 
   def second {
-    "Returns the second element in the Array"
+    """
+    @return The second element in the @Array@.
+    """
     at: 1
   }
 
   def third {
-    "Returns the third element in the Array"
+    """
+    @return The third element in the @Array@.
+    """
     at: 2
   }
 
   def fourth {
-    "Returns the fourth element in the Array"
+    """
+    @return The fourth element in the @Array@.
+    """
     at: 3
   }
 
   def rest {
-    "Returns all elements except the first one as a new Array."
+    """
+    @return All elements in an @Array@ after the first one.
+
+    Returns all elements except the first one as a new @Array@.
+    """
     from: 1 to: -1
   }
 
   def each: block {
     """
     @block @Block@ to be called for each element in @self.
-    @return Return value of calling @block on the last item in @self.
+    @return @self
 
     Calls a given @Block@ with each element in the @Array@.
     """
@@ -86,17 +119,26 @@ class Array {
         } catch (Fancy NextIteration) => ex {
         }
       }
-      self
+      return self
     } catch (Fancy BreakIteration) => ex {
-      ex return_value
+      ex result
     }
   }
 
+  def reverse_each: block {
+    size - 1 downto: 0 do: |i| {
+      block call: [at: i]
+    }
+    self
+  }
+
   def each_with_index: block {
     """
     @block @Block@ to be called with each element and its inde in the @Array@.
+    @return @self
 
-    Iterate over all elements in Array. Calls a given Block with each element and its index.
+    Iterate over all elements in @Array@.
+    Calls a given @Block@ with each element and its index.
     """
 
     i = 0
@@ -104,19 +146,19 @@ class Array {
       block call: [x, i]
       i = i + 1
     }
-    nil
   }
 
   def =? other {
     """
     @other Other @Array@ to compare this one to.
+    @return @true, if all elements of @other are in @self, @false otherwise.
 
     Compares two Arrays where order does not matter.
     """
 
     if: (other is_a?: Array) then: {
       if: (size != (other size)) then: {
-        nil
+        false
       } else: {
         all?: |x| { other includes?: x }
       }
@@ -188,7 +230,7 @@ class Array {
     @return Elements of @Array@ joined to a @String@.
 
     Joins all elements with the empty @String@.
-        [\"hello\", \"world\", \"!\"] join # => \"hello, world!\"
+        [\"hello\", \"world\", \"!\"] join # => \"hello,world!\"
     """
 
     join: ""
@@ -242,7 +284,9 @@ class Array {
   }
 
   def println {
-    "Prints each element on a seperate line."
+    """
+    Prints each element on a seperate line.
+    """
 
     each: |x| {
       x println
@@ -250,11 +294,41 @@ class Array {
   }
 
   def to_s {
-    "Returns @String@ representation of @Array@."
+    """
+    @return @String@ representation of @Array@.
+
+    Returns @String@ representation of @Array@.
+    """
 
     reduce: |x y| { x ++ y } init_val: ""
   }
 
+  def inspect {
+    """
+    @return Pretty-printed @String@ representation of @self.
+
+    Returns a pretty-printed @String@ representation of @self.
+    Example:
+        [1, 'foo, \"bar\", 42] inspect # => \"[1, 'foo, \\\"bar\\\", 42]\"
+    """
+
+    str = "["
+    each: |x| {
+      str = str + (x inspect)
+    } in_between: {
+      str = str + ", "
+    }
+    str + "]"
+  }
+
+  def to_a {
+    """
+    @return @self.
+    """
+
+    self
+  }
+
   def * num {
     """
     Returns a new @Array@ that contains the elements of self num times
@@ -269,13 +343,23 @@ class Array {
   }
 
   def + other_arr {
-    "Returns concatenation with another @Array@."
+    """
+    @return Concatenation of @self with another @Array@
+
+    Returns concatenation with another @Array@.
+        [1,2,3] + [3,4,5] # => [1,2,3,3,4,5]
+    """
 
     clone append: other_arr
   }
 
   def indices {
-    "Returns an @Array@ of all the indices of an @Array@."
+    """
+    @return @Array@ of all indices of @self.
+
+    Returns an @Array@ of all the indices of an @Array@.
+        [1,2,3] indices # => [0,1,2]
+    """
 
     0 upto: (size - 1)
   }
@@ -286,6 +370,7 @@ class Array {
     @return @Array@ of all indices for a given value within an @Array@ (possibly empty).
 
     Returns an Array of all indices of this item. Empty Array if item does not occur.
+        [1, 'foo, 2, 'foo] indices_of: 'foo # => [1, 3]
     """
 
     tmp = []
@@ -338,7 +423,7 @@ class Array {
 
   def select_with_index: block {
     """
-    Same as select:, just gets also called with an additional argument
+    Same as #select:, just gets also called with an additional argument
     for each element's index value.
     """
 
@@ -363,22 +448,4 @@ class Array {
       return [object] + object
     }
   }
-
-  def sum {
-    """
-    Calculates the sum of all the elements in the Enumerable
-    (assuming them to be Numbers (implementing '+' & '*')).
-    """
-
-    reduce: |x y| { x + y } init_val: 0
-  }
-
-  def product {
-    """
-    Calculates the product of all the elements in the Enumerable
-    (assuming them to be Numbers (implementing '+' & '*')).
-    """
-
-    reduce: |x y| { x * y } init_val: 1
-  }
 }