fancy 0.7.0 → 0.8.0

data/examples/constant_access.fy

@@ -1,15 +0,0 @@
-class Foo {
- class Bar {
-   def self name { 'bar }
- }
-}
-
-Foo Bar name println
-
-class Foo Baz {  }
-
-Foo Baz == Foo::Baz println
-
-def Foo Baz name { 'baz }
-
-Foo Baz name println

data/examples/default_args.fy

@@ -1,20 +0,0 @@
-# default_args.fy
-# Example of fancy's default arguments
-
-def arg1: arg1 ("default_arg1") arg2: arg2 ("default_arg2") arg3: arg3 ("default_arg3") {
-  "arguments are: " println
-  arg1 println
-  arg2 println
-  arg3 println
-}
-
-arg1: "hello" arg2: "world" arg3: "how are you?"
-
-Console newline
-arg1: "hello" arg2: "world"
-
-Console newline
-arg1: "hello"
-
-Console newline
-arg1

data/examples/define_methods.fy

@@ -1,15 +0,0 @@
-arr = [1,2,3]
-arr define_singleton_method: "foo" with: {
-  "in foo!" println
-  self inspect println
-}
-
-arr receive_message: 'foo
-
-arr undefine_singleton_method: "foo"
-
-try {
-  arr receive_message: 'foo
-} catch NoMethodError => e {
-  e println
-}

data/examples/dynamic_output.fy

@@ -1,15 +0,0 @@
-# *stdout* refers to STDOUT
-File open: "/tmp/foo.txt" modes: ['write] with: |f| {
-  let: '*stdout* be: f in: {
-    # *stdout* refers to f
-    # "foo" will be written to /tmp/foo.txt
-    # and not STDOUT
-    "foo" println
-  }
-}
-File open: "/tmp/foo.txt" modes: ['read] with: |f| {
-  let: '*stdin* be: f in: {
-    *stdin* readln println # => prints "foo" to *stdout*
-  }
-}
-# *stdout* refers to STDOUT

data/examples/empty_catch.fy

@@ -1,4 +0,0 @@
-try {
-  "Empty catch" println
-} catch StdError => e {
-}

data/examples/exception.fy

@@ -1,9 +0,0 @@
-try {
-  "Hola" println
-  StdError new: "Hello" . raise!
-  "Hi" println
-} catch StdError => e {
-  e println
-} finally {
-  "Adios" println
-}

data/examples/files.fy

@@ -1,23 +0,0 @@
-# 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

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

data/examples/future.fy

@@ -1,30 +0,0 @@
-def foo {
-  Thread sleep: 3
-  "FOO"
-}
-
-def + other {
-  Thread sleep: 1.5
-  "PLUS"
-}
-
-def baz: num {
-  Thread sleep: (num * 0.5)
-  "BAZ"
-}
-
-"Start" println
-
-f = self @ foo
-f println  # print future object
-?f println # access and print the future's value
-
-f = self @ + 10
-f println
-?f println
-
-f = self @ baz: 10
-f println
-?f println
-
-"End" println

data/examples/future_composition.fy

@@ -1,20 +0,0 @@
-# example of composing futures:
-
-def do_large_computation: x {
-  x upto: (x ** x)
-}
-
-# 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}
-"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/futures.fy

@@ -1,9 +0,0 @@
-fs = []
-100 times: |i| {
-  f = { Thread sleep: 0.5; i println } @ call
-  fs << f
-}
-
-"Waiting" println
-fs each: 'value
-"Done" println

data/examples/game_of_life.fy

@@ -1,148 +0,0 @@
-# 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| {
-      Thread sleep: 0.5 # 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_true: |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_true: |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/html_generator.fy

@@ -1,84 +0,0 @@
-# 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 initialize {
-    @buf = ""
-  }
-
-  def initialize: block {
-    initialize
-    block call_with_receiver: self
-    self
-  }
-
-  def open_tag: name attrs: attrs (<[]>) {
-    @buf << "<" << (name but_last)
-    unless: (attrs empty?) do: {
-      @buf << " "
-      attrs each: |k v| {
-        @buf << k << "=" << (v inspect)
-      } in_between: {
-        @buf << " "
-      }
-    }
-    @buf << ">"
-  }
-
-  def close_tag: name {
-    @buf << "</" << (name but_last) << ">"
-  }
-
-  def html_block: tag body: body attrs: attrs (<[]>) {
-    open_tag: tag attrs: attrs
-    match body first {
-      case Block -> @buf << (body first call)
-      case _ -> @buf << (body first)
-    }
-    close_tag: tag
-  }
-
-  def unknown_message: m with_params: p {
-    match m to_s {
-      case /with:$/ ->
-        tag = m to_s substitute: /with:$/ with: ""
-        html_block: tag body: (p rest) attrs: (p first)
-      case _ ->
-        html_block: (m to_s) body: p
-    }
-    nil
-  }
-
-  def to_s {
-    @buf
-  }
-}
-
-# lets generate some simple HTML output :)
-HTML new: |h| {
-  html: {
-    body: <['id => "body id" ]> with: {
-      div: {
-        "hello, world!"
-      }
-      div: {
-        p: {
-          "OKIDOKI"
-        }
-      }
-      div: {
-        h3: {
-          "oh no!"
-        }
-      }
-    }
-  }
-} . println

data/examples/implicit_return.fy

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

data/examples/matchers.fy

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

data/examples/nested_try.fy

@@ -1,9 +0,0 @@
-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

@@ -1,12 +0,0 @@
-# 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