fancy 0.3.0

data/examples/project-euler/01.fy

@@ -0,0 +1,8 @@
+# Problem 1
+# If we list all the natural numbers below 10 that are multiples of 3
+# or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.
+# Find the sum of all the multiples of 3 or 5 below 1000.
+
+0 upto: 999 .
+  select: |x| { x % 3 == 0 or: (x % 5 == 0) } .
+  sum println

data/examples/project-euler/02.fy

@@ -0,0 +1,21 @@
+# Problem 2
+# Each new term in the Fibonacci sequence is generated by adding the
+# previous two terms. By starting with 1 and 2, the first 10 terms will
+# be:
+# 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...
+# Find the sum of all the even-valued terms in the sequence which do
+# not exceed four million.
+
+fibs = [1, 2]
+
+# insert into fibs as long as the sum of the last two numbers doesn't
+# exceed 4000000
+while: { fibs[-1] + (fibs[-2]) <= 4000000 } do: {
+  fibs << (fibs last: 2 . sum)
+}
+
+"fibonacci sequence:" println
+fibs inspect println
+
+"sum: " print
+fibs select: 'even? . sum println

data/examples/project-euler/28.fy

@@ -0,0 +1,33 @@
+# Problem 28
+# What is the sum of the numbers on the diagonals in a 1001 by 1001 spiral
+# formed in the same way?
+
+# Starting with the number 1 and moving to the right in a clockwise
+# direction a 5 by 5 spiral is formed as follows:
+#
+# 21 22 23 24 25
+# 20  7  8  9 10
+# 19  6  1  2 11
+# 18  5  4  3 12
+# 17 16 15 14 13
+#
+# It can be verified that the sum of the numbers on the diagonals is 101.
+
+taille = 1001
+pas = taille - 1
+number = taille ** 2
+coins = 1
+sum = number
+
+while: { pas > 0 } do: {
+  number = number - pas
+  sum = sum + number
+  if: (coins == 4) then: {
+    coins = 1
+    pas = pas - 2
+  } else: {
+    coins = coins + 1
+  }
+}
+
+"The sum of the numbers of the diagonals of the matrix is: " ++ sum println

data/examples/rbx/and_or.fy

@@ -0,0 +1,7 @@
+true and: nil . inspect println
+nil and: true . inspect println
+true and: true . inspect println
+
+nil or: nil . inspect println
+nil or: true . inspect println
+true or: nil . inspect println

data/examples/rbx/blocks.fy

@@ -0,0 +1,22 @@
+2 times: |i| {
+  i println
+}
+
+1 upto: 4 do_each: |i| {
+  i println
+}
+
+x = 0
+while: { x < 4 } do: {
+  "in while_true, with x = " ++ x println
+  x = x + 1
+}
+
+b = |x, y| {
+   "x is: " ++ (x inspect) println
+   "y is: " ++ (y inspect) println
+   x + y println
+}
+
+b call: [1,2]
+

data/examples/rbx/classes.fy

@@ -0,0 +1,32 @@
+class Person {
+  @@a_classvar = "foo"
+  def initialize: name {
+    @name = name
+  }
+
+  def to_s {
+    "Person with name: " ++ @name
+  }
+
+  def Person class_var {
+    @@a_classvar
+  }
+}
+
+p = Person new: "Christopher"
+p println
+Person class_var println
+
+class PersonWithAge : Person {
+  def initialize: name age: age {
+    @name = name
+    @age = age
+  }
+
+  def to_s {
+    super to_s ++ " and age: " ++ @age
+  }
+}
+
+p2 = PersonWithAge new: "Christopher" age: 23
+p2 println

data/examples/rbx/hello.fy

@@ -0,0 +1,8 @@
+"Hello from Fancy, " + "Rubinius!!" println
+44 + 323.2323 println
+
+def foo: x {
+  x + x println
+}
+
+foo: 10

data/examples/rbx/include.fy

@@ -0,0 +1,12 @@
+class Hello {
+  def hello {
+    "Hello " ++ @name println
+  }
+}
+
+class World {
+  include: Hello
+  def initialize { @name = "World" }
+}
+
+World new hello

data/examples/rbx/inherit.fy

@@ -0,0 +1,11 @@
+class Hello {
+  def hello {
+    "Hello " ++ (self name) . println
+  }
+}
+
+class World : Hello {
+  def name { "World" }
+}
+
+World new hello

data/examples/rbx/methods.fy

@@ -0,0 +1,15 @@
+# A simple example of one method calling another in self.
+def hello {
+  "Hello " ++ (self world)
+}
+
+def world { "World" }
+
+
+self hello println
+
+def hello_to: obj {
+  "Hello, " ++ obj println
+}
+
+hello_to: "World!"

data/examples/rbx/nested_classes.fy

@@ -0,0 +1,9 @@
+class Outer {
+  class Inner {
+    def foo: bar {
+      "foo got: " ++ bar println
+    }
+  }
+}
+
+Outer::Inner new foo: "yay!"

data/examples/rbx/require.fy

@@ -0,0 +1,3 @@
+require: "hello.fy"
+
+"Now executing from require.fy!" println

data/examples/rbx/strings.fy

@@ -0,0 +1,5 @@
+"foo bar baz" split: " " . each: |x| {
+  x println
+}
+
+"hello \t world" println

data/examples/regex.fy

@@ -0,0 +1,7 @@
+regex = /[a-z]+[A-Z]*foo/
+str = "heLLofoo"
+
+if: (str =~ regex) then: |idx| {
+  "match at index: #{idx} with character: " print
+  str[idx] inspect println
+}

data/examples/require.fy

@@ -0,0 +1,7 @@
+# require.fy
+# Examples of fancy code reusing and evaluation facilities
+
+require: "arithmetic.fy"
+
+"in require.fnc!" println
+ARGV println # prints any given command-line arguments as an array

data/examples/retry.fy

@@ -0,0 +1,12 @@
+y = 0
+x = 0
+try {
+  x = 10 / y
+} catch ZeroDivisionError {
+  y println
+  x println
+  y = 2
+  retry
+}
+y println
+x println

data/examples/return.fy

@@ -0,0 +1,13 @@
+def foo: block {
+  1 upto: 10 do_each: |i| {
+    val = block call: [i]
+    if: (block call: [i]) then: {
+      return i # non-local return from "foo:"
+    }
+  }
+  return "yay"
+}
+
+foo: |x| { x == 6 } . println
+foo: |x| { x == 0 } . println
+foo: |x| { return_local true } . println # local return

data/examples/ruby_require.fy

@@ -0,0 +1,7 @@
+# ruby_require.fy
+# Example of Ruby code reusing and evaluation from inside fancy
+
+require("examples/ruby_file")
+
+obj = RubyClass new
+obj ruby_method("foo", "bar")

data/examples/ruby_send.fy

@@ -0,0 +1,3 @@
+[3, 2, 1] reverse() each() |a| { puts(a) }
+"Hello" sub("ll", "y") println
+[3, 2, 1] map() |a| { a * 2 } inject(0) |s i| { s + i } println

data/examples/singleton_methods.fy

@@ -0,0 +1,21 @@
+def self singleton_method {
+  "in singleton_method" println
+}
+
+self singleton_method
+
+arr = [1,2,3]
+
+def arr foobar {
+  self each: |x| {
+    "foobar: " ++ x println
+  }
+}
+
+arr foobar
+
+def Array empty! {
+  []
+}
+
+Array empty! inspect println

data/examples/stupid_quicksort.fy

@@ -0,0 +1,12 @@
+def quicksort: arr {
+  match arr size -> {
+    case (0..1) -> arr
+    case _ ->
+      piv = arr at: $ rand(arr size)
+      (quicksort: $ arr select: |x| { x < piv }) + (quicksort: $ arr select: |x| { x >= piv })
+  }
+}
+
+arr = 0 upto: 10 . map: { rand(100) }
+arr inspect println
+quicksort: arr . inspect println

data/examples/threads.fy

@@ -0,0 +1,18 @@
+# threads.fy
+# Example of threads in fancy
+
+threads = []
+10 times: |i| {
+  t = Thread new: {
+    "Running Thread #" ++ i println
+    i times: {
+      "." print
+      System sleep: 1500 # sleep 1,5 sec
+    }
+  }
+  threads << t
+}
+
+"Waiting for all Threads to end..." print
+threads each: 'join
+

data/examples/tuple.fy

@@ -0,0 +1,8 @@
+# tuple.fy
+
+tuple = (1,2,3)
+tuple size println
+
+(1,"foo",'bar) [0] inspect println
+
+(1, "foo", 'bar) == (1, "foo", 'bar) println

data/examples/webserver/webserver.fy

@@ -0,0 +1,18 @@
+# webserver.fy
+# Example of a simple webserver written in fancy, using Ruby socket library
+
+require("socket")
+host = "127.0.0.1"
+port = 3000
+webserver = TCPServer new(host, port)
+"Webserver running at: #{host}:#{port}" println
+loop: {
+  session = webserver accept
+  session print: "HTTP/1.1 200/OK\r\nContent-type:text/html\r\n\r\n"
+  request = session readln
+  filename = "examples/webserver/index.html"
+  displayfile = File open(filename, "r")
+  content = displayfile read
+  session print: content
+  session close
+}

data/lib/argv.fy

@@ -0,0 +1,36 @@
+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| {
+    if: (block argcount > 0) then: {
+      ARGV[idx + 1] if_do: |arg| {
+        block call: [arg]
+        ARGV remove_at: idx
+        ARGV remove_at: idx
+      }
+    } else: {
+      block call
+      ARGV remove_at: idx
+    }
+  }
+}
+
+def ARGV for_options: op_names do: block {
+  "Runs a given block if any of the given options is in ARGV."
+
+  op_names size times: |i| {
+    if: (ARGV index: (op_names[i])) then: |idx| {
+      if: (block argcount > 0) then: {
+        if: (ARGV[idx + 1]) then: |arg| {
+          block call: [arg]
+          ARGV remove_at: idx
+          ARGV remove_at: idx
+        }
+      } else: {
+        block call
+        ARGV remove_at: idx
+      }
+      return true
+    }
+  }
+}

data/lib/array.fy

@@ -0,0 +1,207 @@
+class Array {
+  """
+  Array class.
+  Arrays are dynamically resizable containers with a constant-time
+  index-based access to members.
+  """
+
+  include: FancyEnumerable
+
+  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.
+    """
+
+    # if given an Array, interpret it as a from:to: range subarray
+    if: (index is_a?: Array) then: {
+      from: (index[0]) to: (index[1])
+    } else: {
+      at: index
+    }
+  }
+
+  def rest {
+    "Returns all elements except the first one as a new Array."
+    from: 1 to: -1
+  }
+
+  def =? other {
+    """
+    @other Other @Array@ to compare this one to.
+
+    Compares two Arrays where order does not matter.
+    """
+
+    if: (other is_a?: Array) then: {
+      if: (self size != (other size)) then: {
+        nil
+      } else: {
+        all?: |x| { other includes?: x }
+      }
+    }
+  }
+
+  def find: item {
+    """
+    @item @Object@ / Element to find in the @Array@.
+    @return @item if, it's found in the @Array@, otherwise @nil.
+
+    Returns the item, if it's in the Array or nil (if not found).
+    """
+
+    if: (item is_a?: Block) then: {
+      find_by: item
+    } else: {
+      if: (index: item) then: |idx| {
+        at: idx
+      }
+    }
+  }
+
+  def find_by: block {
+    """
+    @block @Block@ to be called for each element in the @Array@.
+    @return The first element, for which @block yields @true.
+
+    Like find: but takes a block that gets called with each element to find it.
+    """
+
+    self each: |x| {
+      if: (block call: [x]) then: {
+        return x
+      }
+    }
+  }
+
+  def values_at: idx_arr {
+    """
+    @idx_arr @Array@ of indices.
+    @return @Array@ of all the items with the given indices in @idx_arr.
+
+    Returns new @Array@ with elements at given indices.
+    """
+
+    values = []
+    idx_arr each: |idx| {
+      values << (at: idx)
+    }
+    values
+  }
+
+  def >> other_arr {
+    """
+    @other_arr @Array@ to be appended to @self.
+    @return New @Array@ with @other_arr and @self appended.
+
+    Returns new Array with elements of other_arr appended to these.
+    """
+
+    arr = self clone
+    arr append: other_arr
+  }
+
+  def join {
+    """
+    @return Elements of @Array@ joined to a @String@.
+
+    Joins all elements with the empty @String@.
+        [\"hello\", \"world\", \"!\"] join # => \"hello, world!\"
+    """
+
+    join: ""
+  }
+
+  def select!: condition {
+    """
+    @condition A condition @Block@ (or something @Callable) for selecting items from @self.
+    @return @self, but changed with all elements removed that don't yield @true for @condition.
+
+    Removes all elements in place, that don't meet the condition.
+    """
+
+    reject!: |x| { condition call: [x] . not }
+    return self
+  }
+
+  def compact! {
+    """
+    @return @self
+
+    Removes all nil-value elements in place.
+    """
+
+    reject!: |x| { x nil? }
+    return self
+  }
+
+  def remove: obj {
+    """
+    @obj Object to be removed within @self.
+    @return @self, with all occurances of @obj removed.
+
+    Removes all occurances of obj in the Array.
+    """
+
+    remove_at: (indices_of: obj)
+  }
+
+  def remove_if: condition {
+    """
+    @condition @Block@ (or @Callable) that indicates, if an element should be removed from @self.
+    @return @self, with all elements removed for which @condition yields true.
+
+    Like @Array#remove:@, but taking a condition @Block@.
+    Removes all elements that meet the given condition @Block@.
+    """
+
+    remove_at: (select_with_index: |x i| { condition call: [x] } .
+                map: 'second)
+  }
+
+  def println {
+    "Prints each element on a seperate line."
+
+    each: |x| {
+      x println
+    }
+  }
+
+  def to_s {
+    "Returns @String@ representation of @Array@."
+
+    reduce: |x y| { x ++ y } init_val: ""
+  }
+
+  def * num {
+    """
+    Returns a new @Array@ that contains the elements of self num times
+    in a row.
+    """
+
+    arr = []
+    num times: {
+      arr append: self
+    }
+    arr
+  }
+
+  def + other_arr {
+    "Returns concatenation with another @Array@."
+
+    self clone append: other_arr
+  }
+
+  def indices {
+    "Returns an @Array@ of all the indices of an @Array@."
+
+    0 upto: (self size - 1)
+  }
+
+  def Array === object {
+    if: (object is_a?: Array) then: {
+      return [object] + object
+    }
+  }
+}