fancy 0.3.0 → 0.3.1

data/lib/fancy_spec.fy

@@ -86,14 +86,14 @@ class FancySpec {
         any_failure = true
         Console newline
         "> FAILED: " ++ test_obj ++ " " ++ @info_str print
-        self print_failed_positive
+        print_failed_positive
       }
 
       if: (@@failed_negative size > 0) then: {
         any_failure = true
         Console newline
         "> FAILED: " ++ test_obj ++ " " ++ @info_str print
-        self print_failed_negative
+        print_failed_negative
       }
 
       { "." print } unless: any_failure

data/lib/fdoc.fy

@@ -92,11 +92,11 @@ class Fancy FDoc {
 
     def to_json: obj {
       # Reimplement now we have pattern matching dispatch.
-      match obj -> {
-        case Hash -> self hash_to_json: obj
-        case Array -> self array_to_json: obj
-        case Symbol -> self symbol_to_json: obj
-        case String -> self string_to_json: obj
+      match obj {
+        case Hash -> hash_to_json: obj
+        case Array -> array_to_json: obj
+        case Symbol -> symbol_to_json: obj
+        case String -> string_to_json: obj
         case Numeric -> obj
         case nil -> "null"
         case _ -> "Dont know how to convert " ++ (obj inspect) ++ " to JSON" raise!
@@ -171,8 +171,8 @@ class Fancy FDoc {
 
 
     def write: filename call: name ("fancy.fdoc") {
-      map = self generate_map
-      json = self to_json: map
+      map = generate_map
+      json = to_json: map
       js = "(function() { " ++ name ++ "(" ++ json ++ "); })();"
       File open: filename modes: ['write] with: |out| { out print: js }
     }

data/lib/fiber.fy

@@ -0,0 +1,11 @@
+class Fiber {
+  def sleep: seconds {
+    @sleep_end = Time now + seconds
+  }
+
+  def asleep? {
+    if: @sleep_end then: {
+      Time now < @sleep_end
+    }
+  }
+}

data/lib/fiber_pool.fy

@@ -0,0 +1,78 @@
+class FiberPool {
+  def initialize {
+    @pool = []
+    @scheduling = false
+    @mutex = Mutex new()
+  }
+
+  def size {
+    @mutex synchronize() {
+      @pool size
+    }
+  }
+
+  def add: fiber {
+    @mutex synchronize() {
+      @pool << fiber
+    }
+  }
+
+  def remove: fiber {
+    @mutex synchronize() {
+      @pool remove: fiber
+    }
+  }
+
+  def scheduling? {
+    @scheduling
+  }
+
+  def pool {
+    @mutex synchronize() {
+      pool = @pool
+    }
+  }
+
+  def cleanup_pool {
+    @mutex synchronize() {
+      @pool select!: 'alive?
+    }
+  }
+
+  def schedule {
+    @scheduling = true
+    Thread new: {
+      loop: {
+        while: {pool size > 0} do: {
+          pool each: |f| {
+            unless: (f asleep?) do: {
+              sleep_time = f resume
+              { f sleep: sleep_time } if: sleep_time
+            }
+          }
+          cleanup_pool
+        }
+        Thread sleep: 1
+      }
+    }
+  }
+}
+
+class Scheduler {
+  @@pool = FiberPool new
+  def Scheduler add: fiber {
+    @@pool add: fiber
+    unless: (@@pool scheduling?) do: {
+      schedule
+    }
+    nil
+  }
+
+  def Scheduler remove: fiber {
+    @@pool remove: fiber
+  }
+
+  def Scheduler schedule {
+    @@pool schedule
+  }
+}

data/lib/file.fy

@@ -37,7 +37,7 @@ class File {
     """
 
     write: x
-    self newline
+    newline
   }
 
   def print: x {

data/lib/future.fy

@@ -0,0 +1,32 @@
+class Future {
+  @@thread_pool = nil
+  @@pool_size = 10
+  WaitInterval = 0.1
+
+  def Future pool: n {
+    @@pool_size = match n {
+      case 0 -> 10
+      case _ -> n
+    }
+  }
+
+  def Future join! {
+    @@thread_pool join
+  }
+
+  def initialize: @block {
+    { @@thread_pool = ThreadPool new: @@pool_size } unless: @@thread_pool
+    @@thread_pool execute: @block
+  }
+
+  def when_done: block {
+    value if_do: |v| {
+      block call: [v]
+    }
+  }
+
+  def value {
+    { Thread sleep: WaitInterval } until: { @block complete? }
+    @block completed_value
+  }
+}

data/lib/hash.fy

@@ -16,11 +16,11 @@ class Hash {
     "Calls a given Block with each key and value."
 
     if: (block argcount == 1) then: {
-      self keys each: |key| {
+      keys each: |key| {
         block call: [[key, at: key]]
       }
     } else: {
-      self keys each: |key| {
+      keys each: |key| {
         block call: [key, at: key]
       }
     }
@@ -29,7 +29,7 @@ class Hash {
   def each_key: block {
     "Calls a given Block with each key."
 
-    self keys each: |key| {
+    keys each: |key| {
       block call: [key]
     }
   }
@@ -37,7 +37,7 @@ class Hash {
   def each_value: block {
     "Calls a given Block with each value."
 
-    self values each: |val| {
+    values each: |val| {
       block call: [val]
     }
   }
@@ -51,6 +51,6 @@ class Hash {
   def to_s {
     "Returns a string representation of a Hash."
 
-    self to_a to_s
+    to_a to_s
   }
 }

data/lib/lazy_array.fy

@@ -0,0 +1,23 @@
+require: "rbx/fiber"
+class LazyArray {
+  def initialize: generator {
+    @generator = Fiber new: generator
+  }
+
+  def each: block {
+    while: (@generator resume) do: |val| {
+      block call: [val]
+    }
+  }
+
+  def map: block {
+    LazyArray new: block
+  }
+}
+
+l1 = LazyArray new: |i| { i doubled }
+l2 = l1 map: |x| { x squared }
+
+l2 each: |x| {
+  x inspect println
+}

data/lib/main.fy

@@ -1,31 +1,32 @@
 # main.fy
 # This file gets run directly from bin/fancy.
-# It loads up all the necessary auto-load files by loading lib/boot.fy
-# and handles any given ARGV options.
-# Finally, if any .fy source filename is passed in via ARGV, it is
-# loaded and executed.
+# It handles any given built-in ARGV options.
+# If any .fy source filename is passed in via ARGV, it is loaded and
+# executed, otherwise ifancy, Fancy's REPL, gets loaded.
 
-ARGV for_options: ["-v", "--version"] do: {
-  "Fancy " ++ FANCY_VERSION println
-  "(C) 2010, 2011 Christopher Bertels <chris@fancy-lang.org>" println
-  System exit
-}
+if: (ARGV size == 1) then: {
+  ARGV for_options: ["-v", "--version"] do: {
+    "Fancy " ++ FANCY_VERSION println
+    "(C) 2010, 2011 Christopher Bertels <chris@fancy-lang.org>" println
+    System exit
+  }
 
-ARGV for_options: ["--help", "-h"] do: {
-  ["Usage: fancy [option] [programfile] [arguments]",
-   "  --help                  Print this output",
-   "  -h                      Print this output",
-   "  --version               Print Fancy's version number",
-   "  -v                      Print Fancy's version number",
-   "  -I directory            Add directory to Fancy's LOAD_PATH",
-   "  -e 'command'            One line of Fancy code that gets evaluated immediately",
-   "  -c [filenames]          Compile given files to Rubinius bytecode",
-   "  -cv [filenames]         Compile given files to Rubinius bytecode verbosely (outputting the generated bytecode).",
-   "",
-   "Fancy package management:",
-   "  install   [packagename] Install a Fancy package with a given name to $FANCYPACK_DIR",
-   "  uninstall [packagename] Uninstall a Fancy package with a given name from $FANCYPACK_DIR"] println
-  System exit # quit when running --help
+  ARGV for_options: ["--help", "-h"] do: {
+    ["Usage: fancy [option] [programfile] [arguments]",
+     "  --help                  Print this output",
+     "  -h                      Print this output",
+     "  --version               Print Fancy's version number",
+     "  -v                      Print Fancy's version number",
+     "  -I directory            Add directory to Fancy's LOAD_PATH",
+     "  -e 'command'            One line of Fancy code that gets evaluated immediately",
+     "  -c [filenames]          Compile given files to Rubinius bytecode",
+     "  -cv [filenames]         Compile given files to Rubinius bytecode verbosely (outputting the generated bytecode).",
+     "",
+     "Fancy package management:",
+     "  install   [packagename] Install a Fancy package with a given name to $FANCYPACK_DIR",
+     "  uninstall [packagename] Uninstall a Fancy package with a given name from $FANCYPACK_DIR"] println
+    System exit # quit when running --help
+  }
 }
 
 ARGV for_option: "-I" do: |path| {
@@ -67,12 +68,21 @@ ARGV for_option: "uninstall" do: |package_name| {
   System exit
 }
 
+ARGV for_option: "list-packages" do: {
+  Fancy Package list_packages
+  System exit
+}
+
 # push package install dir to load_path
 Fancy Package add_to_loadpath
 
 # Load a source file, if any given:
 ARGV first if_do: |file| {
-  Fancy CodeLoader load_compiled_file: file
+  try {
+    Fancy CodeLoader load_compiled_file: file
+  } catch Fancy Parser ParseError => e {
+    e message println
+  }
 }
 
 ARGV empty? if_do: {

data/lib/method.fy

@@ -17,6 +17,6 @@ class Method {
   def test: test_block {
     it = FancySpec new: self
     test_block call: [it]
-    self tests << it
+    tests << it
   }
 }

data/lib/nil_class.fy

@@ -53,4 +53,8 @@ class NilClass {
   def not {
     true
   }
+
+  def inspect {
+    "nil"
+  }
 }

data/lib/object.fy

@@ -4,6 +4,17 @@ class Object {
   All classes inherit from Object.
   """
 
+  def ++ other {
+    """
+    @other Other object to concatenate its @String value with.
+    @return @String concatenation of @String values of @self and @other.
+
+    Returns the @String concatenation of @self and @other.
+    Calls to_s on @self and @other and concatenates the results to a new @String.
+    """
+    to_s + (other to_s)
+  }
+
   def loop: block {
     "Infinitely calls the block (loops)."
     { true } while_true: {
@@ -13,12 +24,12 @@ class Object {
 
   def println {
     "Same as Console println: self. Prints the object on STDOUT, followed by a newline."
-    Console println: $ self to_s
+    Console println: to_s
   }
 
   def print {
     "Same as Console print: self. Prints the object on STDOUT."
-    Console print: $ self to_s
+    Console print: to_s
   }
 
   def != other {
@@ -54,7 +65,7 @@ class Object {
   def if_do: block {
     "If the object is non-nil, it calls the given block with itself as argument."
 
-    match self -> {
+    match self {
       case nil -> nil
       case false -> nil
       case _ -> block call: [self]
@@ -65,7 +76,7 @@ class Object {
     """If the object is non-nil, it calls the given then_block with itself as argument.
        Otherwise it calls the given else_block."""
 
-    match self -> {
+    match self {
       case nil -> else_block call: [self]
       case false -> else_block call: [self]
       case _ -> then_block call: [self]
@@ -75,7 +86,7 @@ class Object {
   def or_take: other {
     "Returns self if it's non-nil, otherwise returns the given object."
 
-    if: (self nil?) then: {
+    if: nil? then: {
       other
     } else: {
       self
@@ -95,8 +106,12 @@ class Object {
   }
 
   def || other {
-    "Same as Object#or:"
-    or: other
+    "Returns @ self if self is true-ish, otherwise returns @other"
+    self if_do: {
+      return self
+    } else: {
+      return other
+    }
   }
 
   def && other {
@@ -167,4 +182,41 @@ class Object {
     "The identity method simply returns self."
     self
   }
+
+  def returning: value do: block {
+    """
+    @value Value that gets returned at the end.
+    @block A @Block@ that gets called with @value before returning @value.
+    @return @value
+
+    Returns @value after calling @block with it.
+    Useful for returning some object after using it, e.g.:
+
+        # this will return [1,2]
+        returning: [] do: |arr| {
+          arr << 1
+          arr << 2
+        }
+    """
+
+    val = value
+    block call: [val]
+    val
+  }
+
+  def ? future {
+    future value
+  }
+
+  def yield {
+    Fiber yield
+  }
+
+  def yield: values {
+    Fiber yield: values
+  }
+
+  def wait: seconds {
+    Fiber yield: [seconds]
+  }
 }