fancy 0.7.0 → 0.8.0

data/examples/rbx/and_or.fy

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

@@ -1,22 +0,0 @@
-2 times: |i| {
-  i println
-}
-
-1 upto: 4 do: |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

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

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

data/examples/rbx/include.fy

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

data/examples/rbx/inherit.fy

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

data/examples/rbx/methods.fy

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

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

data/examples/rbx/require.fy

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

data/examples/rbx/strings.fy

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

data/examples/require.fy

@@ -1,7 +0,0 @@
-# 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/return.fy

@@ -1,13 +0,0 @@
-def foo: block {
-  1 upto: 10 do: |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/singleton_methods.fy

@@ -1,21 +0,0 @@
-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/threads.fy

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

data/examples/tuple.fy

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

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

data/lib/proxy.fy

@@ -1,86 +0,0 @@
-class ProxyReceiver : Fancy BasicObject {
-  """
-  A ProxyReceiver is an object which proxies all message sends to it to 2 other objects.
-  It will send each message first to its @proxy instance variable and then to the @obj instance variable.
-  """
-
-  def initialize: @proxy for: @obj {
-    """
-    @proxy Proxy receiver for @obj.
-    @obj Original receiver object.
-
-    Initializes a new ProxyReceiver with @proxy for @obj.
-    """
-
-    self
-  }
-
-  def unknown_message: msg with_params: params {
-    """
-    @msg Incoming message name.
-    @params Paremeters of incoming message send.
-
-    Forwards all incoming messages to @self to @@proxy and then @@obj.
-    """
-
-    @proxy receive_message: msg with_params: params
-    @obj receive_message: msg with_params: params
-  }
-}
-
-Proxy = ProxyReceiver
-
-class RespondsToProxy : Fancy BasicObject {
-  """
-  A RespondsToProxy is a Proxy that forwards any message sent to it to it's @target instance variable
-  only if it responds to that message. Any messages that @target doesn't respond to simply won't be sent
-  and @nil will be returned.
-  """
-
-  def initialize: @target {
-    """
-    @target Target receiver object.
-
-    Initializes a new RespondsToProxy for @target.
-    """
-
-    self
-  }
-
-  def unknown_message: msg with_params: params {
-    """
-    @msg Incoming message name.
-    @params Paremeters of incoming message send.
-
-    Forwards all incoming message to @self to @@target
-    only if @@target responds to them.
-    """
-
-    if: (@target responds_to?: msg) then: {
-      @target receive_message: msg with_params: params
-    }
-  }
-}
-
-class ActorProxy : Fancy BasicObject {
-  """
-  A ActorProxy is a Proxy that forwards any message sent to it to it's
-  @target instance variable as a future send by default.
-  If explicitly sent an async message, it will forward the async send
-  to @target, returning nil instead of a @FutureSend@, as expected.
-  """
-
-  def initialize: @target
-
-  def send_future: m with_params: p {
-    @target send_future: m with_params: p
-  }
-
-  def send_async: m with_params: p {
-    @target send_async: m with_params: p
-  }
-
-  def unknown_message: m with_params: p {
-    @target send_future: m with_params: p
-  }
-}

data/lib/thread_pool.fy

@@ -1,102 +0,0 @@
-# This ThreadPool class is adapted from the Ruby code at:
-# https://github.com/fizx/thread_pool/
-
-class ThreadPool {
-  class Executor {
-    read_slot: 'active
-
-    def initialize: queue mutex: mutex {
-      @thread = Thread new: {
-        loop: {
-          mutex synchronize() { @tuple = queue shift() }
-          if: @tuple then: {
-            args, block = @tuple
-            @active = true
-            val = nil
-            try {
-              val = block call: args
-            } catch Exception => e {
-              e message println
-              e backtrace() join: "\n" . println
-            }
-            block complete: true
-            block completed_value: val
-          } else: {
-            @active = false
-            Thread sleep: 0.1
-          }
-        }
-      }
-    }
-
-    def close {
-      @thread exit
-    }
-  }
-
-  read_write_slot: 'queue_limit
-
-  # Initialize with number of threads to run
-  def initialize: @count limit: @queue_limit (0) {
-    @mutex = Mutex new()
-    @executors = []
-    @queue = []
-    @count times: { @executors << (Executor new: @queue mutex: @mutex) }
-  }
-
-  # Runs the block at some time in the near future
-  def execute: block with_args: args ([]) {
-    init_completable: block
-
-    if: (@queue_limit > 0) then: {
-      { Thread sleep: 0.1 } until: { @queue size < @queue_limit }
-    }
-
-    @mutex synchronize() {
-      @queue << [args, block]
-    }
-  }
-
-  # Runs the block at some time in the near future, and blocks until complete
-  def execute_synchronous: block with_args: args ([]) {
-    execute: block with_args: args
-    { Thread sleep: 0.1 } until: { block complete? }
-    block completed_value
-  }
-
-  # Size of the task queue
-  def waiting {
-    @queue size
-  }
-
-  # Size of the thread pool
-  def size {
-    @count
-  }
-
-  # Kills all threads
-  def close {
-    @executors each: @{ close }
-  }
-
-  # Sleeps and blocks until the task queue is finished executing
-  def join {
-    { Thread sleep: 0.1 } until: { { @queue empty? } && { @executors all?: @{ active not } } }
-  }
-
-  class Completable {
-    read_write_slot: 'completed_value
-    def complete: @complete {
-    }
-
-    def complete? {
-      @complete not not
-    }
-  }
-
-  def init_completable: block {
-    block extend(Completable)
-    block complete: false
-  }
-  protected: 'init_completable:
-}