fancy 0.3.0

data/examples/files.fy

@@ -0,0 +1,23 @@
+# files.fy
+# File handling examples
+
+{
+  Directory create: "tmp/"
+} unless: $ Directory exists?: "tmp/"
+
+File open: "tmp/Hello-World.txt" modes: ['write] with: |f| {
+  f writeln: "Hello, world"
+}
+
+File delete: "tmp/Hello-World.txt"
+
+arr = [1,2,3,4]
+File open: "tmp/Array-Test.txt" modes: ['write] with: |f| {
+  arr each: |x| {
+    f writeln: x
+  }
+}
+
+File delete: "tmp/Array-Test.txt"
+
+Directory delete: "tmp/"

data/examples/finally.fy

@@ -0,0 +1,5 @@
+try {
+  "Hello" println
+} finally {
+  "World" println
+}

data/examples/game_of_life.fy

@@ -0,0 +1,148 @@
+# game_of_life.fy
+# Conway's Game of Life in Fancy :)
+
+class World {
+  read_write_slots: ['matrix]
+
+  def World with_height: height and_width: width {
+    World new: [height, width]
+  }
+
+  def initialize {
+    # the offsets are the positions to check for neighbors relative to
+    # each position (e.g. [-1,-1] points to the upper left neighbor of
+    # each cell)
+    @offsets = [[-1, -1], [-1, 0], [-1, 1],
+                [0, -1],           [0, 1],
+                [1, -1],  [1, 0],  [1, 1]]
+  }
+
+  def initialize: size {
+    "Initialize a World with a given size ([height, width])."
+
+    self initialize
+    height = size[0]
+    width = size[1]
+    @last_alive = []
+    @matrix = Array new: height
+    height times: |i| {
+      @matrix at: i put: (Array new: width with: 0)
+    }
+  }
+
+  def [] index {
+    "Return the row for a given index."
+    @matrix[index]
+  }
+
+  def simulate: amount_generations {
+    "Simulate the World for a given amount of iterations (generations)."
+
+    display: 0
+    amount_generations times: |i| {
+      System sleep: 500 # sleep 500 ms
+      self simulate
+      display: (i + 1)
+    }
+  }
+
+  def display {
+    "Display the World (print on Screen)."
+
+    @matrix each: |row| {
+      row each: |entry| {
+        if: (entry == 0) then: {
+          "  " print
+        } else: {
+          ". " print
+        }
+      }
+      "" println
+    }
+  }
+
+  def display: iteration {
+    "Display the World (print on Screen) with the current iteration count."
+
+    Console clear
+    "Generation: " ++ iteration println
+    self display
+  }
+
+  def was_alive?: pos {
+    "Indicates, if a cell ([row,column]) was alive in the last generation."
+
+    @last_alive[pos[0]] if_do: |row| {
+      row[pos[1]] == 1
+    }
+  }
+
+  def live: pos {
+    "Sets the given cell ([row,column]) alive."
+    (@matrix[pos[0]]) at: (pos[1]) put: 1
+  }
+
+  def die: pos {
+    "Sets the given cell ([row,column]) dead."
+    (@matrix[pos[0]]) at: (pos[1]) put: 0
+  }
+
+  def simulate {
+    "Simulates the world one iteration."
+
+    @last_alive = @matrix map: |row| { row select_with_index: |c| { c == 1 } }
+    @matrix each_with_index: |row i| {
+      row each_with_index: |column j| {
+        # check amount of neighbors
+        n_neighbors = neighbors_of: [i, j]
+        if: (was_alive?: [i,j]) then: {
+          if: ({n_neighbors <= 1} || {n_neighbors >= 4}) then: {
+            die: [i,j]
+          } else: {
+            live: [i,j]
+          }
+        } else: {
+          if: (n_neighbors == 3) then: {
+            live: [i,j]
+          }
+        }
+      }
+    }
+  }
+
+  def neighbors_of: pos {
+    row = pos[0]
+    column = pos[1]
+
+    neighbors = @offsets map: |o| {
+      @matrix[row + (o[0])] if_do: |r| {
+        r[column + (o[1])]
+      }
+    }
+    neighbors select: |x| { x != 0 } . size
+  }
+}
+
+X = 1
+PULSAR = [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+          [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+          [0, 0, 0, 0, X, X, X, 0, 0, 0, X, X, X, 0, 0, 0],
+          [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+          [0, 0, X, 0, 0, 0, 0, X, 0, X, 0, 0, 0, 0, X, 0],
+          [0, 0, X, 0, 0, 0, 0, X, 0, X, 0, 0, 0, 0, X, 0],
+          [0, 0, X, 0, 0, 0, 0, X, 0, X, 0, 0, 0, 0, X, 0],
+          [0, 0, 0, 0, X, X, X, 0, 0, 0, X, X, X, 0, 0, 0],
+          [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+          [0, 0, 0, 0, X, X, X, 0, 0, 0, X, X, X, 0, 0, 0],
+          [0, 0, X, 0, 0, 0, 0, X, 0, X, 0, 0, 0, 0, X, 0],
+          [0, 0, X, 0, 0, 0, 0, X, 0, X, 0, 0, 0, 0, X, 0],
+          [0, 0, X, 0, 0, 0, 0, X, 0, X, 0, 0, 0, 0, X, 0],
+          [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+          [0, 0, 0, 0, X, X, X, 0, 0, 0, X, X, X, 0, 0, 0],
+          [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+          ]
+
+w = World new
+w matrix: PULSAR
+
+w simulate: 20

data/examples/hashes.fy

@@ -0,0 +1,7 @@
+h = <['foo => 'bar, 'bar => 'baz, 'baz => 42.5]>
+h at: 'foo . println
+h['bar] println
+h['baz] println
+
+h = <[ 2 + 2 => 5 ]>
+h[4] println

data/examples/hello_world.fy

@@ -0,0 +1,6 @@
+# hello_world.fy
+# The classic "hello world" program in fancy
+
+Console println: "Hello, World!"
+# another way of doing this:
+"Hello, World again!" println

data/examples/html_generator.fy

@@ -0,0 +1,54 @@
+# html_generator.fy
+# Simple HTML generator written in fancy
+
+class String {
+  def but_last {
+    # same as:  self from: 0 to: -2
+    # and:      self from: 0 to: (self size - 2)
+    self[[0,-2]]
+  }
+}
+
+class HTML {
+  def open_tag: name {
+    "<" ++ (name but_last) ++ ">"
+  }
+
+  def close_tag: name {
+    "</" ++ (name but_last) ++ ">"
+  }
+
+  def unknown_message: name with_params: params {
+    name = name to_s
+    str = open_tag: name
+
+    body = params first call
+    if: (body is_a?: Array) then: {
+      body = body join
+    }
+
+    str ++ body ++ (close_tag: name)
+  }
+}
+
+# lets generate some simple HTML output )
+h = HTML new
+h html: {
+  h body: {
+    [
+     h div: {
+       "hello, world!"
+     },
+     h div: {
+       h p: {
+         "OKIDOKI"
+       }
+     },
+     h div: {
+       h h3: {
+         "oh no!"
+       }
+     }
+    ]
+  }
+} . println

data/examples/implicit_return.fy

@@ -0,0 +1,3 @@
+# Methods implicitly return the last expression.
+def hello { "Hello!" }
+self hello println

data/examples/matchers.fy

@@ -0,0 +1,6 @@
+# matchers.fy
+
+match "foobarbaz" -> {
+  case /foo([a-z]+)baz/ -> |matcher|
+    matcher[1] println  # => bar
+}

data/examples/methods.fy

@@ -0,0 +1,29 @@
+# methods.fy
+# Examples of methods definitions, and method overriding in fancy
+
+class Foo {
+  def bar {
+    Console println: "version 1"
+  }
+}
+
+f = Foo new
+f bar # prints: version 1
+
+# redefine Foo#bar
+class Foo {
+  def bar {
+    Console println: "version 2"
+  }
+}
+
+f bar # prints: version 2
+
+# redefine Foo#bar again
+class Foo {
+  def bar {
+    Console println: "version 3"
+  }
+}
+
+f bar # prints: version 3

data/examples/nested_classes.fy

@@ -0,0 +1,27 @@
+# nested_classes.fy
+# Example of nested classes in fancy
+
+class Outer {
+  class Inner {
+    def to_s {
+      "Outerr::Inner"
+    }
+  }
+
+  def to_s {
+    "Outer"
+  }
+}
+
+
+o = Outer new
+o println
+i = Outer::Inner new
+i println
+
+class Outer InnerTwo {
+  def to_s { "Outer InnerTwo" }
+}
+
+i = Outer InnerTwo new
+i println

data/examples/nested_try.fy

@@ -0,0 +1,9 @@
+try {
+  try {
+    StdError new: "Propagated exception" . raise!
+  } catch String => not_matched {
+    "Should not enter here" println
+  }
+} catch Object => anything {
+  anything println
+}

data/examples/numbers.fy

@@ -0,0 +1,12 @@
+# numbers.fy
+# Examples of fancy's number objects
+
+-10 abs println # prints: 10
+10 abs println # prints: 10
+0 abs println # prints: 0
+
+"" println
+
+-10 negate println # prints: 10
+10 negate println # prints: -10
+0 negate println # prints: 0

data/examples/pattern_matching.fy

@@ -0,0 +1,40 @@
+# pattern_matching.fy
+# Examples of pattern matching facilities in fancy
+
+class PatternMatching {
+  def match_it: obj {
+    match obj -> {
+      case String -> "It's a String!" println
+      case Fixnum -> "It's a Number!" println
+      case _ -> "Aything else!" println
+    }
+  }
+
+  def match_with_extract: str {
+    match str -> {
+      # m holds the MatchData object, m1 & m2 the first and second matches
+      case /^(.*) : (.*)$/ -> |m, m1, m2|
+        "First match: #{m1}" println
+        "Second match: #{m2}" println
+    }
+  }
+}
+
+pm = PatternMatching new
+pm match_it: "foo"
+pm match_it: 42
+pm match_it: 'foo
+
+pm match_with_extract: "Hello : World!"
+
+# more pattern matching:
+
+def do_it: num {
+  (num, num * num)
+}
+
+match do_it: 10 -> {
+  case Tuple -> |_, x, y| # first arg is a Tuple MatchData object (not used here).
+    x inspect println # 10
+    y inspect println # 100
+}

data/examples/person.fy

@@ -0,0 +1,65 @@
+# person.fy
+# Annotated example of fancy's classes mechanism
+
+class City {
+  read_slots: ['city]
+  def initialize: name {
+    @name = name
+  }
+
+  def to_s {
+    "City: " ++ @name
+  }
+}
+
+class Person {
+  # creates getters & setters for slots
+  read_write_slots: ['name, 'age, 'city]
+
+  # Person constructor method for creating a new person with a name,
+  # age and city.
+  # A method that starts with initialize: will cause a class factory
+  # method being generated, that calls this method when being called.
+  # The name of the class factory method is the same as the instance
+  # 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 go_to: city {
+    # The .-operator (dot) manages left associativity and treats
+    # everything left of it as one expression and everything right of
+    # it as a method_call to the left. In this case the following line
+    # of code is equivalent to:
+    ## (city is_a?: City) if_true: { ... }
+
+    # While using parentheses would definately work, the dot-operator
+    # makes left-grouping of expressions much easier.
+    # In contrast to e.g. Smalltalk, Fancy isn't compiled but
+    # interpreted so there usually is not some predefined knowledge of
+    # which methods exist etc., which makes it impossible to determine
+    # if we're dealing with a two-argument method call or a chained
+    # method call ('is_a?:if_true:' vs. '(is_a?: ..) if_true: ..')
+    city is_a?: City . if_true: {
+      @city = city
+    }
+  }
+
+  def to_s {
+    "Person: " ++ @name ++ ", " ++ @age ++ " years old, living in " ++ @city
+  }
+}
+
+# usage example:
+osna = City new: "Osnabrück"
+p = Person new: "Christopher" age: 23 city: osna
+p println
+
+berlin = City new: "Berlin"
+p go_to: berlin # => p city will then be set to berlin
+
+p println