fancy 0.3.2 → 0.3.3

data/README.md

@@ -133,9 +133,12 @@ Ruby method invocation supports passing a block variable to Ruby as a proc.
   - Calling, using and extending arbitrary Ruby classes and methods
     (including C-extensions), as well as passing blocks and splat
     arguments to Ruby methods.
+  - Futures (`future = object @ message`)
+  - Async message sends (`object @@ message`)
+
 
 ##What's still missing?
-  - Concurrency stuff (Actor-model based concurrency, Futures etc)
+  - Some concurrency stuff (e.g. language syntax for actors)
   - Some more advanced stuff, e.g. runtime inspection of method calls
     via MethodContext etc. (saved for later)
 

data/Rakefile

@@ -255,6 +255,14 @@ task :test do
   *Dir.glob(_("tests/*.fy"))
 end
 
+task :tests do
+  task(:test).invoke
+end
+
+task "tests/" do
+  task(:test).invoke
+end
+
 task :bootstrap => ["compiler:bootstrap"]
 
 task :default => [:bootstrap_if_needed, :compile]

data/bin/fyi

@@ -1,25 +1,30 @@
 #!/usr/bin/env fancy
 # -*- fancy -*-
 
-if: (ARGV[1]) then: |ident| {
-  "Documentation for: '#{ident}' :" println;
-  if: (ident includes?: "#") then: {
-    parts = ident split: "#"
-    obj = parts[0] eval
-    if: (parts[1]) then: |method_name| {
-      method = obj instance_method: $ parts[1]
-      method documentation println
-      System exit
+try {
+  if: (ARGV[1]) then: |ident| {
+    documentation = nil
+    if: (ident includes?: "#") then: {
+      parts = ident split: "#"
+      obj = parts[0] eval
+      if: (parts[1]) then: |method_name| {
+        method = obj instance_method: $ parts[1]
+        documentation = method documentation
+      }
     }
+    # just print documentation for class here
+    obj = ident eval
+    documentation = obj documentation
+    "Documentation for: '#{ident}':" println
+    documentation println
+  } else: {
+    ["Prints the documentation string for a given object or one if its methods",
+     "Usage:",
+     "fyi [ObjectIdentifier]",
+     "fyi [ObjectIdentifier]#[MethodName]",
+     "",
+     "Example: fyi Array#each:"] println
   }
-  # just print documentation for class here
-  obj = ident eval
-  obj documentation println
-} else: {
-  ["Prints the documentation string for a given object or one if its methods",
-   "Usage:",
-   "fyi [ObjectIdentifier]",
-   "fyi [ObjectIdentifier]#[MethodName]",
-   "",
-   "Example: fyi Array#each:"] println
-}
+} catch Exception => e {
+  "ERROR: #{e message}" println
+}

data/bin/ifancy

@@ -6,6 +6,9 @@ require("readline")
 ["Welcome to the (still very simple) Fancy REPL",
  "Fancy " ++ FANCY_VERSION] println
 
+HISTORY_FILE = File expand_path("~/.fancy_history")
+HISTORY = []
+
 ARGV rest each: |file| {
   "LOADING: " ++ file println
   require: file
@@ -14,26 +17,55 @@ ARGV rest each: |file| {
 # handle SIGINT
 trap("INT") {
   "Quitting." println
+  save_history
   System exit
 }
 
 Console newline;
 
 def double_or_empty?: line {
-  (line =~ /^\s*$/) or: (Readline HISTORY to_a[-2] == line)
+  (line =~ /^\s*$/) or: (HISTORY [-2] == line)
+}
+
+def load_history {
+  if: (File exists?: HISTORY_FILE) then: {
+    File open: HISTORY_FILE modes: ['read] with: |f| {
+      f readlines each: |l| {
+        l = l strip()
+        Readline HISTORY <<(l)
+        HISTORY << l
+      }
+    }
+  } else: {
+    File touch: HISTORY_FILE
+  }
 }
 
+def save_history {
+  puts("saving history")
+  unless: @history_saved do: {
+    File open: HISTORY_FILE modes: ['write] with: |f| {
+      HISTORY each: |l| {
+        f writeln: l
+      }
+    }
+    @history_saved = true
+  }
+}
+
+load_history
 
 try {
   bnd = binding()
 
-  { Readline readline(">> ", true) } while_do: |line| {
-
-    double_or_empty?: line . if_true: {
+  while: { Readline readline(">> ", true) } do: |line| {
+    HISTORY << line
+    if: (double_or_empty?: line) then: {
       Readline::HISTORY pop()
+      HISTORY pop()
     }
 
-    line =~ /^\s*$/ if_false: {
+    unless: (line =~ /^\s*$/) do: {
       try {
         Fancy eval: line binding: bnd . inspect println
       } catch Exception => e {
@@ -41,6 +73,8 @@ try {
       }
     }
   }
+  save_history
 } catch Interrupt => e {
+  save_history
   System exit
 }

data/{extconf.rb → boot/extconf.rb}

@@ -2,6 +2,6 @@ base = File.dirname(__FILE__)
 puts "Fancy hasn't been bootstrapped yet. Doing that now.\n\n"
 File.open("Makefile", "w") do |f|
   f.puts "install:"
-  f.puts "				rbx -S rake clean && rbx -S rake"
+  f.puts "				cd ../ && rbx -S rake clean && rbx -S rake"
 end
 exit 0

data/boot/fancy_ext/block_env.rb

@@ -2,12 +2,6 @@
 Block = Rubinius::BlockEnvironment
 
 class Block
-  define_method("while_true:") do |block|
-    while tmp = self.call
-      block.call(tmp)
-    end
-  end
-
   # call without arguments
   alias_method :":call", :call
 
@@ -22,12 +16,4 @@ class Block
       call *args
     end
   end
-
-  define_method("call_with_receiver:") do |obj|
-    call_under obj, method.scope
-  end
-
-  define_method("call:with_receiver:") do |args, obj|
-    call_under obj, method.scope, *args
-  end
 end

data/boot/fancy_ext/kernel.rb

@@ -1,6 +1,10 @@
 module Kernel
-
-  alias_method :":metaclass", :metaclass
+  begin
+    alias_method ":metaclass", :metaclass
+  rescue
+    alias_method :":metaclass", :singleton_class
+    alias_method :metaclass, :singleton_class
+  end
 
   def fancy_require(file, compile = false)
     if compile

data/examples/actor.fy

@@ -0,0 +1,37 @@
+require("actor")
+class Actor {
+  alias_method: '! for_ruby: '<<
+}
+
+# Execute with Rubinius: rbx ex1.rb
+
+def error_loop: block{
+  try {
+    loop: block
+  } catch Exception => ex {
+    ex message println
+    ex backtrace join: "\n"
+  }
+}
+
+pong = nil
+ping = Actor spawn() {
+  error_loop: {
+    count = Actor receive()
+    "." print
+    { return count println } if: (count > 1000)
+    pong ! (count + 1)
+  }
+}
+pong = Actor.spawn() {
+  error_loop: {
+    count = Actor receive()
+    "-" print
+    { return count println } if: (count > 1000)
+    ping ! (count + 1)
+  }
+}
+ping ! 1
+
+# Let the actors process while the main thread sleeps...
+Thread sleep: 1

data/examples/armstrong_numbers.fy

@@ -28,6 +28,6 @@ class Fixnum {
 }
 
 # output alls Armstrong Numbers between 0 and 10000
-0 upto: 10000 do_each: |i| {
+0 upto: 10000 do: |i| {
   { i println } if: $ i armstrong?
 }

data/examples/curl_async.fy

@@ -0,0 +1,37 @@
+def async curl: url {
+  out = System pipe: "curl #{url}"
+  return out read # return string of html
+}
+
+def async curl_urls: urls {
+  results = []
+  urls each: |url| {
+    # await means it will suspend the current context until the curl: has finished
+    # and will resume with the line below
+    data = await curl: url
+    results << data
+  }
+  return results
+}
+
+URLS = ["http://www.backtype.com", "http://www.fancy-lang.org", "http://tech.backtype.com"]
+
+# usage (runs it asynchronously and returns a future that will hold the data when its done)
+f = curl_urls: URLS
+
+# do something else...
+# then after some time access the data:
+
+f value each: |html| {
+  html println
+}
+
+# or hook it up with something to do when its done:
+curl_urls: URLS && |data| {
+  data each: |html| { 
+    html println
+  }
+}
+
+# shorter version of above:
+curl_urls: URLS && @{each: 'println}

data/examples/echo.fy

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

data/examples/factorial.fy

@@ -7,6 +7,6 @@ class Fixnum {
   }
 }
 
-1 upto: 10 do_each: |i| {
+1 upto: 10 do: |i| {
   i to_s ++ "! = " ++ (i factorial) println
 }

data/examples/future_composition.fy

@@ -0,0 +1,20 @@
+# example of composing futures:
+
+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
+# when it has finished its computation. This makes pipelining tasks easy.
+
+f = self @ do_large_computation: 5 && @{select: 'even?} && @{inspect println}
+"computing .. " println
+f value
+
+#the above is the same as:
+# f = self @ do_large_computation: 5
+# f = f when_done: @{select: 'even?}
+# f = f when_done: @{inspect println}
+# "computing .. " println
+# f value

data/examples/game_of_life.fy

@@ -72,7 +72,7 @@ class World {
   def was_alive?: pos {
     "Indicates, if a cell ([row,column]) was alive in the last generation."
 
-    @last_alive[pos[0]] if_do: |row| {
+    @last_alive[pos[0]] if_true: |row| {
       row[pos[1]] == 1
     }
   }
@@ -115,7 +115,7 @@ class World {
     column = pos[1]
 
     neighbors = @offsets map: |o| {
-      @matrix[row + (o[0])] if_do: |r| {
+      @matrix[row + (o[0])] if_true: |r| {
         r[column + (o[1])]
       }
     }

data/examples/person.fy

@@ -2,9 +2,8 @@
 # Annotated example of fancy's classes mechanism
 
 class City {
-  read_slots: ['city]
-  def initialize: name {
-    @name = name
+  read_slots: ['name]
+  def initialize: @name {
   }
 
   def to_s {
@@ -24,10 +23,7 @@ class Person {
   # method but having initialize: replaced by new:.
   # So in this case: Person##new:age:city:
   # which calls this instance method internally
-  def initialize: name age: age city: city {
-    @name = name
-    @age = age
-    @city = city
+  def initialize: @name age: @age city: @city {
   }
 
   def go_to: city {
@@ -50,7 +46,7 @@ class Person {
   }
 
   def to_s {
-    "Person: " ++ @name ++ ", " ++ @age ++ " years old, living in " ++ @city
+    "Person: #{@name}, #{@age} years old, living in #{@city}"
   }
 }
 

data/examples/rbx/blocks.fy

@@ -2,7 +2,7 @@
   i println
 }
 
-1 upto: 4 do_each: |i| {
+1 upto: 4 do: |i| {
   i println
 }
 

data/examples/return.fy

@@ -1,5 +1,5 @@
 def foo: block {
-  1 upto: 10 do_each: |i| {
+  1 upto: 10 do: |i| {
     val = block call: [i]
     if: (block call: [i]) then: {
       return i # non-local return from "foo:"

data/examples/struct.fy

@@ -0,0 +1,9 @@
+S = Struct new: ['foo, 'bar, 'baz]
+s = S new: (1,2,3)
+s println
+
+s foo: 10
+s bar: 20
+s baz: 30
+
+s println

data/lib/argv.fy

@@ -1,9 +1,9 @@
 def ARGV for_option: op_name do: block {
   "Runs a given block if an option is in ARGV."
 
-  ARGV index: op_name . if_do: |idx| {
+  ARGV index: op_name . if_true: |idx| {
     if: (block argcount > 0) then: {
-      ARGV[idx + 1] if_do: |arg| {
+      ARGV[idx + 1] if_true: |arg| {
         block call: [arg]
         ARGV remove_at: idx
         ARGV remove_at: idx

data/lib/array.fy

@@ -7,6 +7,30 @@ class Array {
 
   include: FancyEnumerable
 
+  def Array new: size {
+    "Creates a new Array with a given size (default value is nil)."
+
+    Array new: size with: nil
+  }
+
+  def clone {
+    "Clones (shallow copy) the Array."
+    new = []
+    each: |x| {
+      new << x
+    }
+    new
+  }
+
+  def append: arr {
+    "Appends another Array onto this one."
+
+    arr each: |x| {
+      self << x
+    }
+    self
+  }
+
   def [] index {
     """
     Given an Array of 2 Numbers, it returns the sub-array between the
@@ -47,6 +71,42 @@ class 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.
+
+    Calls a given @Block@ with each element in the @Array@.
+    """
+
+    try {
+      size times: |i| {
+        try {
+          block call: [at: i]
+        } catch (Fancy NextIteration) => ex {
+        }
+      }
+      self
+    } catch (Fancy BreakIteration) => ex {
+      ex return_value
+    }
+  }
+
+  def each_with_index: block {
+    """
+    @block @Block@ to be called with each element and its inde in the @Array@.
+
+    Iterate over all elements in Array. Calls a given Block with each element and its index.
+    """
+
+    i = 0
+    each: |x| {
+      block call: [x, i]
+      i = i + 1
+    }
+    nil
+  }
+
   def =? other {
     """
     @other Other @Array@ to compare this one to.
@@ -93,6 +153,7 @@ class Array {
         return x
       }
     }
+    nil
   }
 
   def values_at: idx_arr {
@@ -219,9 +280,105 @@ class Array {
     0 upto: (size - 1)
   }
 
+  def indices_of: item {
+    """
+    @item Item/Value for which a list of indices is requested within an @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.
+    """
+
+    tmp = []
+    each_with_index: |obj, idx| {
+      if: (item == obj) then: {
+        tmp << idx
+      }
+    }
+    tmp
+  }
+
+  def from: from to: to {
+    """
+    @from Start index for sub-array.
+    @to End index ofr sub-array.
+
+    Returns sub-array starting at from: and going to to:
+    """
+
+    if: (from < 0) then: {
+      from = size + from
+    }
+    if: (to < 0) then: {
+      to = size + to
+    }
+    subarr = []
+    from upto: to do: |i| {
+      subarr << (at: i)
+    }
+    subarr
+  }
+
+  def select: block {
+    """
+    @block Predicate @Block@ to be used as filter.
+    @return @Array@ of all the elements for which @block doesn't yield @false or @nil.
+
+    Returns a new Array with all the elements in self that yield a
+    true-ish value when called with the given Block.
+    """
+
+    tmp = []
+    each: |x| {
+      if: (block call: [x]) then: {
+        tmp << x
+      }
+    }
+    return tmp
+  }
+
+  def select_with_index: block {
+    """
+    Same as select:, just gets also called with an additional argument
+    for each element's index value.
+    """
+
+    tmp = []
+    each_with_index: |obj idx| {
+      if: (block call: [obj, idx]) then: {
+        tmp << [obj, idx]
+      }
+    }
+    tmp
+  }
+
   def Array === object {
+    """
+    @object Object to match @self against.
+    @return @nil, if no match, matched values (in an @Array) otherwise.
+
+    Matches an @Array against another object.
+    """
+
     if: (object is_a?: Array) then: {
       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
+  }
 }