fancy 0.3.2 → 0.3.3

data/lib/iteration.fy

@@ -0,0 +1,60 @@
+class Fancy {
+  class BreakIteration : StdError {
+    read_slots: ['return_value]
+    def initialize: @return_value {}
+  }
+
+  class NextIteration : StdError {
+    read_slots: ['return_value]
+    def initialize: @return_value {}
+  }
+
+  class StopIteration : StdError {
+    """
+    Raised to stop the iteration, in particular by Enumerator#next.
+    It is rescued by Block#loop.
+
+    Example:
+      {
+        'Hello println
+        StopIteration new raise!
+        'World println
+      } loop
+      'Done! println
+
+    Produces:
+
+      Hello
+      Done!
+    """
+
+    def initialize { @result = nil }
+    def initialize: @result { }
+
+    def result {
+      """
+      Returns the return value of the iterator.
+
+        o = Object new
+        def o each: block {
+          block call: 1
+          block call: 2
+          block call: 3
+          100
+        }
+
+        e = o to_enum
+        e next p #=> 1
+        e next p #=> 2
+        e next p #=> 3
+        try {
+          e next
+        } catch Fancy StopIteration => ex {
+          ex result p #=> 100
+        }
+      """
+
+      @result
+    }
+  }
+}

data/lib/main.fy

@@ -39,7 +39,7 @@ ARGV for_option: "-e" do: |eval_string| {
 }
 
 ARGV for_option: "-c" do: {
-  ARGV index: "-c" . if_do: |idx| {
+  ARGV index: "-c" . if_true: |idx| {
     ARGV[[idx + 1, -1]] each: |filename| {
       "Compiling " ++ filename println
       Fancy Compiler compile_file: filename to: nil line: 1 print: false
@@ -49,7 +49,7 @@ ARGV for_option: "-c" do: {
 }
 
 ARGV for_option: "-cv" do: {
-  ARGV index: "-cv" . if_do: |idx| {
+  ARGV index: "-cv" . if_true: |idx| {
     ARGV[[idx + 1, -1]] each: |filename| {
       "Compiling " ++ filename println
       Fancy Compiler compile_file: filename to: nil line: 1 print: true
@@ -77,7 +77,7 @@ ARGV for_option: "list-packages" do: {
 Fancy Package add_to_loadpath
 
 # Load a source file, if any given:
-ARGV first if_do: |file| {
+ARGV first if_true: |file| {
   try {
     Fancy CodeLoader load_compiled_file: file
   } catch Fancy Parser ParseError => e {
@@ -85,6 +85,6 @@ ARGV first if_do: |file| {
   }
 }
 
-ARGV empty? if_do: {
+ARGV empty? if_true: {
   require: "../bin/ifancy"
 }

data/lib/nil_class.fy

@@ -1,5 +1,5 @@
 class NilClass {
-  "NilClass. The class of the singleton nil value."
+  "NilClass. The class of the singleton @nil value."
 
   def NilClass new {
     # always return nil singleton object when trying to create a new
@@ -7,54 +7,46 @@ class NilClass {
     nil
   }
 
-  def if_true: then_block else: else_block {
-    "Calls else_block."
-    else_block call
-  }
-
   def if_true: block {
-    "Returns nil."
+    "Returns @nil."
     nil
   }
 
-  def if_false: block {
-    "Calls the block."
-    block call
+  def if_true: then_block else: else_block {
+    "Calls @else_block."
+    else_block call
   }
 
   def if_nil: block {
-    "Calls the block."
-    block call
+    block call: [self]
   }
 
-  def nil? {
-    "Returns true."
-    true
+  def if_nil: then_block else: else_block {
+    then_block call: [self]
   }
 
-  def false? {
-    "Returns true."
+  def nil? {
+    "Returns @true."
     true
   }
 
-  def true? {
-    "Returns nil."
-    false
-  }
-
   def to_s {
+    "Returns an empty @String@."
     ""
   }
 
   def to_a {
+    "Returns an empty @Array@."
     []
   }
 
   def not {
+    "Returns @true."
     true
   }
 
   def inspect {
+    "Returns @nil as a @String@."
     "nil"
   }
 }

data/lib/number.fy

@@ -5,6 +5,14 @@ class Number {
   """
 
   def upto: num {
+    """
+    @num @Number@ to create an @Array@ up to.
+    @return @Array@ containing numbers from @self to @num.
+
+    Returns an Array with Numbers starting at @self and going up to @num.
+    Expects @num to be greater or equal to @self.
+    """
+
     i = self
     arr = []
     while: { i <= num } do: {
@@ -14,7 +22,32 @@ class Number {
     arr
   }
 
+  def upto: num do: block {
+    """
+    @num Maximum @Number@ to call @block with.
+    @block A @Block@ that should be called with each @Number@ between @self and @num.
+    @return @self
+
+    Calls @block with each @Number@ between @self and @num.
+    Expects @num to be greater or equal to @self.
+    """
+    i = self
+    while: { i <= num } do: {
+      block call: [i]
+      i = i + 1
+    }
+    self
+  }
+
   def downto: num {
+    """
+    @num @Number@ to create an @Array@ down to.
+    @return @Array@ containing numbers from @self down to @num.
+
+    Returns an Array with Numbers starting at @self and going down to @num.
+    Expects @num to be smaller or equal to @self.
+    """
+
     i = self
     arr = []
     while: { i >= num } do: {
@@ -24,6 +57,24 @@ class Number {
     arr
   }
 
+  def downto: num do: block {
+    """
+    @num Minimum @Number@ to call @block with.
+    @block A @Block@ that should be called with each @Number@ between @self and @num.
+    @return @self
+
+    Calls @block with each @Number@ between @self and @num.
+    Expects @num to be smaller or equal to @self.
+    """
+
+    i = self
+    while: { i >= num } do: {
+      block call: [i]
+      i = i - 1
+    }
+    self
+  }
+
   def squared {
     "Returns the square of a Number."
 

data/lib/object.fy

@@ -17,9 +17,7 @@ class Object {
 
   def loop: block {
     "Infinitely calls the block (loops)."
-    { true } while_true: {
-      block call
-    }
+    block loop
   }
 
   def println {
@@ -37,50 +35,49 @@ class Object {
     self == other not
   }
 
-  def if_false: block {
-    "Calls the block."
-    nil
+  def if_true: block {
+    "Calls the @block if @true? returns @true"
+    block call: [self]
   }
 
-  def if_nil: block {
-    "Returns nil."
-    nil
+  def if_true: then_block else: else_block {
+    "Calls the @then_block if @true? returns @true - otherwise @else_block is called"
+    then_block call: [self]
   }
 
-  def nil? {
-    "Returns nil."
+  def if_false: block {
+    "Calls the @block if @false? returns @true@"
     nil
   }
 
-  def false? {
-    "Returns nil."
-    nil
+  def if_false: then_block else: else_block {
+    "Calls the @then_block if @false? returns @true - otherwise @else_block is called"
+    else_block call
   }
 
-  def true? {
-    "Returns nil."
+  def if_nil: block {
+    "Calls the @block if @nil? returns @true@"
     nil
   }
 
-  def if_do: block {
-    "If the object is non-nil, it calls the given block with itself as argument."
+  def if_nil: then_block else: else_block {
+    "Calls the @then_block if @nil? returns @true - otherwise @else_block is called"
+    else_block call
+  }
 
-    match self {
-      case nil -> nil
-      case false -> nil
-      case _ -> block call: [self]
-    }
+  def nil? {
+    "Returns @false."
+    false
   }
 
-  def if_do: then_block else: else_block {
-    """If the object is non-nil, it calls the given then_block with itself as argument.
-       Otherwise it calls the given else_block."""
+  def false? {
+    "Returns @false."
+    false
+  }
 
-    match self {
-      case nil -> else_block call: [self]
-      case false -> else_block call: [self]
-      case _ -> then_block call: [self]
-    }
+  def true? {
+    "Returns @false."
+    false
   }
 
   def or_take: other {
@@ -105,34 +102,69 @@ class Object {
     0
   }
 
-  def || other {
-    "Returns @ self if self is true-ish, otherwise returns @other"
-    self if_do: {
+  def to_enum {
+    FancyEnumerator new: self
+  }
+
+  def to_enum: iterator {
+    FancyEnumerator new: self with: iterator
+  }
+
+  def and: other {
+    """
+    Boolean conjunction.
+    Returns @other if @self and @other are true-ish, otherwise @false.
+    """
+
+    if_true: {
+      { other = other call } if: (other is_a?: Block)
+      return other
+    }
+    return self
+  }
+
+  def or: other {
+    """
+    Boolean disjunction.
+    Returns true if either @self or other is true, otherwise nil.
+    """
+    if_true: {
       return self
     } else: {
+      { other = other call } if: (other is_a?: Block)
       return other
     }
   }
 
-  def && other {
-    "Same as Object#and:"
-    and: other
+  def or: other {
+    """
+    Boolean disjunction.
+    Returns true if either @self or other is true, otherwise nil.
+    """
+    unless: self do: {
+      { other = other call } if: (other is_a?: Block)
+      return other
+    }
+    return self
   }
 
+  alias_method: ':&& for: 'and:
+  alias_method: ':|| for: 'or:
+
   def if: cond then: block {
     """
     Same as:
-        cond if_do: block
+        cond if_true: block
     """
-    cond if_do: block
+    cond if_true: block
   }
 
   def if: cond then: then_block else: else_block {
     """
     Same as:
-        cond if_do: then_block else: else_block
+        cond if_true: then_block else: else_block
     """
-    cond if_do: then_block else: else_block
+    cond if_true: then_block else: else_block
   }
 
   def while: cond_block do: body_block {
@@ -156,10 +188,10 @@ class Object {
   def unless: cond do: block {
     """
     Same as:
-      cond if_do: { nil } else: block
+      cond if_true: { nil } else: block
     """
 
-    cond if_do: { nil } else: block
+    cond if_true: { nil } else: block
   }
 
   def method: method_name {
@@ -204,6 +236,37 @@ class Object {
     val
   }
 
+  def if_responds? {
+    """
+    @return RespondsToProxy for @self
+
+    Returns a @RespondsToProxy@ for @self that forwards any messages
+    only if @self responds to them.
+
+    Example usage:
+
+        # only send 'some_message: if object responds to it:
+        object if_responds? some_message: some_parameter
+    """
+
+    RespondsToProxy new: self
+  }
+
+  def backtick: str {
+    """
+    This is the default implementation for backtick: which gets called when using the backtick syntax.
+    For example:
+        `cat README`
+    Gets translated to the following message send:
+        self backtick: \"cat README\"
+    Which allows for custom implementations of the backtick: method, if needed.
+    This default implementation works the same way as in Ruby, Perl or Bash.
+    It returns the output of running the given string on the command line as a @String@.
+    """
+
+    System pipe: str . read
+  }
+
   def ? future {
     future value
   }
@@ -219,4 +282,24 @@ class Object {
   def wait: seconds {
     Fiber yield: [seconds]
   }
+
+  def next {
+    "Skip to the next iteration"
+    Fancy NextIteration new raise!
+  }
+
+  def next: value {
+    "Return value for this iteration and skip to the next one"
+    (Fancy NextIteration new: value) raise!
+  }
+
+  def break {
+    "Stop iterating"
+    Fancy BreakIteration new raise!
+  }
+
+  def break: value {
+    "Return value from iteration"
+    (Fancy BreakIteration new: value) raise!
+  }
 }