fancy 0.3.3 → 0.4.0

data/lib/message.fy

@@ -0,0 +1,6 @@
+class Fancy {
+  class Message {
+    read_slots: ('selector, 'arguments)
+    def initialize: @selector arguments: @arguments
+  }
+}

data/lib/method.fy

@@ -3,20 +3,4 @@ class Method {
   An instance of Method represents a method on a Class.
   Every method in Fancy is an instance of the Method class.
   """
-
-  def tests {
-    """
-    Returns an Array of all the FancySpec SpecTests defined for a
-    Method.
-    """
-
-    @tests if_nil: { @tests = [] }
-    @tests
-  }
-
-  def test: test_block {
-    it = FancySpec new: self
-    test_block call: [it]
-    tests << it
-  }
 }

data/lib/nil_class.fy

@@ -1,52 +1,102 @@
 class NilClass {
-  "NilClass. The class of the singleton @nil value."
+  """
+  NilClass. The class of the singleton @nil value.
+  """
 
   def NilClass new {
+    """
+    @return @nil.
+    """
+
     # always return nil singleton object when trying to create a new
     # NilClass instance
     nil
   }
 
   def if_true: block {
-    "Returns @nil."
+    """
+    @return @nil.
+    """
+
     nil
   }
 
   def if_true: then_block else: else_block {
-    "Calls @else_block."
+    """
+    @return Value of calling @else_block.
+
+    Calls @else_block.
+    """
     else_block call
   }
 
   def if_nil: block {
+    """
+    @block @Block@ to be called.
+    @return Value of calling @block with @self.
+
+    Calls @block with @self.
+    """
+
     block call: [self]
   }
 
   def if_nil: then_block else: else_block {
+    """
+    @then_block @Block@ to be called with @self.
+    @else_block Gets ignored.
+    @return Value of calling @then_block with @self.
+
+    Calls @then_block with @self.
+    """
+
     then_block call: [self]
   }
 
   def nil? {
-    "Returns @true."
+    """
+    @return @true.
+    """
+
     true
   }
 
   def to_s {
-    "Returns an empty @String@."
+    """
+    @return An empty @String@.
+    """
+
     ""
   }
 
+  alias_method: 'inspect for: 'to_s
+
   def to_a {
-    "Returns an empty @Array@."
+    """
+    @return An empty @Array@.
+    """
+
     []
   }
 
   def not {
-    "Returns @true."
+    """
+    @return @true.
+    """
+
     true
   }
 
   def inspect {
-    "Returns @nil as a @String@."
+    """
+    @return @nil as a @String@.
+    """
+
     "nil"
   }
 }
+
+nil documentation: """
+  @nil is the singleton nil value (only instance of @NilClass@).
+  NilClass##new yields @nil.
+  """

data/lib/number.fy

@@ -76,19 +76,31 @@ class Number {
   }
 
   def squared {
-    "Returns the square of a Number."
+    """
+    @return Squared value of @self.
+
+    Returns the square of a Number.
+    """
 
     self * self
   }
 
   def doubled {
-    "Returns the double value of a Number."
+    """
+    @return Doubled value of @self.
+
+    Returns the double value of a Number.
+    """
 
     self + self
   }
 
   def abs {
-    "Returns the absolute (positive) value of a Number."
+    """
+    @return Absolute (positive) value of @self.
+
+    Returns the absolute (positive) value of a Number.
+    """
 
     if: (self < 0) then: {
       self * -1
@@ -98,41 +110,56 @@ class Number {
   }
 
   def negate {
-    "Negates a Number (-1 becomes 1 and vice versa)."
+    """
+    @return Negated value of @self.
+
+    Negates a Number (-1 becomes 1 and vice versa).
+    """
 
     self * -1
   }
 
   def even? {
-    "Indicates, if a Number is even."
+    """
+    @return @true, if @self is even, @false otherwise.
+
+    Indicates, if a Number is even.
+    """
 
     modulo: 2 . == 0
   }
 
   def odd? {
-    "Indicates, if a Number is odd."
+    """
+    @return @true, if @self is odd, @false otherwise.
 
-    self even? not
-  }
+    Indicates, if a Number is odd.
+    """
 
-  def to_num {
-    self
+    self even? not
   }
-}
 
-class FancyEnumerable {
-  def sum {
-    """Calculates the sum of all the elements in the @Enumerable
-      (assuming them to be @Number@s (implementing '+' & '*'))."""
+  def max: other {
+    """
+    @return Maximum value of @self and @other.
+    """
 
-    reduce: |x y| { x + y } init_val: 0
+    if: (self < other) then: {
+      other
+    } else: {
+      self
+    }
   }
 
-  def product {
-    """Calculates the product of all the elements in the @Enumerable
-      (assuming them to be @Number@s (implementing @+ & @*))."""
+  def min: other {
+    """
+    @return Minimum value of @self and @other.
+    """
 
-    reduce: |x y| { x * y } init_val: 1
+    if: (self < other) then: {
+      self
+    } else: {
+      other
+    }
   }
-}
-
+}

data/lib/object.fy

@@ -12,140 +12,205 @@ class Object {
     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)."
-    block loop
+    """
+    @block @Block@ to be called endlessly (loop).
+
+    Infinitely calls the block (loops).
+    """
+
+    { true } while_true: block
   }
 
   def println {
-    "Same as Console println: self. Prints the object on STDOUT, followed by a newline."
+    """
+    Same as:
+        Console println: self
+
+    Prints @self on @STDOUT, followed by a newline.
+    """
+
     Console println: to_s
   }
 
   def print {
-    "Same as Console print: self. Prints the object on STDOUT."
+    """
+    Same as:
+        Console print: self
+
+    Prints @self on STDOUT.
+    """
+
     Console print: to_s
   }
 
   def != other {
-    "Indicates, if two objects are unequal."
+    """
+    @other Other object to compare against.
+    @return @true if @self is not equal to @other, @false otherwise.
+
+    Indicates, if two objects are not equal.
+    """
+
     self == other not
   }
 
   def if_true: block {
-    "Calls the @block if @true? returns @true"
+    """
+    @block @Block@ to be called.
+    @return Value of calling @block with @self.
+
+    Calls the @block (default behaviour).
+    """
+
     block call: [self]
   }
 
   def if_true: then_block else: else_block {
-    "Calls the @then_block if @true? returns @true - otherwise @else_block is called"
+    """
+    @then_block @Block@ to be called.
+    @else_block Does not get called (default behaviour).
+
+    @return Value of calling @then_block with @self.
+
+    Calls the @then_block (default behaviour).
+    """
+
     then_block call: [self]
   }
 
   def if_false: block {
-    "Calls the @block if @false? returns @true@"
+    """
+    @return @nil
+
+    Does nothing (default behaviour).
+    """
     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
-  }
+    """
+    @then_block Does not get called (default behaviour).
+    @else_block @Block@ to be called.
+    @return Value of calling @else_block.
 
-  def if_nil: block {
-    "Calls the @block if @nil? returns @true@"
-    nil
-  }
+    Calls @else_block (default behaviour).
+    """
 
-  def if_nil: then_block else: else_block {
-    "Calls the @then_block if @nil? returns @true - otherwise @else_block is called"
     else_block call
   }
 
+  alias_method: 'if_nil: for: 'if_false:
+  alias_method: 'if_nil:else: for: 'if_false:else:
+
   def nil? {
-    "Returns @false."
+    """
+    @return @false.
+    """
+
     false
   }
 
   def false? {
-    "Returns @false."
-    false
-  }
+    """
+    @return @false.
+    """
 
-  def true? {
-    "Returns @false."
     false
   }
 
-  def or_take: other {
-    "Returns self if it's non-nil, otherwise returns the given object."
-
-    if: nil? then: {
-      other
-    } else: {
-      self
-    }
-  }
+  def true? {
+    """
+    @return @false.
+    """
 
-  def to_num {
-    0
+    false
   }
 
   def to_a {
+    """
+    @return @Array@ representation of @self.
+    """
+
     [self]
   }
 
   def to_i {
+    """
+    @return @Fixnum@ representation of @self.
+    """
+
     0
   }
 
   def to_enum {
+    """
+    @return @FancyEnumerator@ for @self using 'each: for iteration.
+    """
+
     FancyEnumerator new: self
   }
 
   def to_enum: iterator {
+    """
+    @iterator Message to use for iteration on @self.
+    @return @FancyEnumerator@ for @self using @iterator for iteration.
+    """
+
     FancyEnumerator new: self with: iterator
   }
 
   def and: other {
     """
+    @other Object or @Block@ (for short-circuit evaluation) to compare @self to.
+    @return @other if both @self and @other are true-ish, @self otherwise.
+
     Boolean conjunction.
-    Returns @other if @self and @other are true-ish, otherwise @false.
+    If @self and @other are both true-ish (non-nil, non-false), returns @other.
+    If @other is a @Block@, calls it and returns its return value.
     """
 
     if_true: {
       { other = other call } if: (other is_a?: Block)
-      return other
+      other
+    } else: {
+      self
     }
-    return self
   }
 
   def or: other {
     """
+    @other Object or @Block@ (for short-circuit evaluation) to compare @self to.
+    @return @self if @self is true-ish, @other otherwise.
+
     Boolean disjunction.
-    Returns true if either @self or other is true, otherwise nil.
+    If @self is true-ish (non-nil, non-false) returns @self.
+    Otherwise returns @other (if @other is a @Block@, calls it first and returns its return value)
     """
+
     if_true: {
-      return self
+      self
     } else: {
       { other = other call } if: (other is_a?: Block)
-      return other
+      other
     }
   }
 
-  def or: other {
+  def xor: other {
     """
-    Boolean disjunction.
-    Returns true if either @self or other is true, otherwise nil.
+    @other @Object@ to compare @self against.
+    @return @true if only one of @self and @other is true, @false otherwise.
     """
-    unless: self do: {
-      { other = other call } if: (other is_a?: Block)
-      return other
+
+    if_true: {
+      other not
+    } else: {
+      other not not
     }
-    return self
   }
 
   alias_method: ':&& for: 'and:
@@ -156,6 +221,7 @@ class Object {
     Same as:
         cond if_true: block
     """
+
     cond if_true: block
   }
 
@@ -164,6 +230,7 @@ class Object {
     Same as:
         cond if_true: then_block else: else_block
     """
+
     cond if_true: then_block else: else_block
   }
 
@@ -185,6 +252,26 @@ class Object {
     cond_block until_do: body_block
   }
 
+  def do: body_block while: cond_block {
+    """
+    @body_block @Block@ to be called at least once and as long as @cond_block yields a true-ish value.
+    @cond_block Condition @Block@ used to determine if @body_block@ should be called again.
+    """
+
+    body_block call: [nil]
+    cond_block while_do: body_block
+  }
+
+  def do: body_block until: cond_block {
+    """
+    @body_block @Block@ to be called at least once and as long as @cond_block yields a false-ish value.
+    @cond_block Condition @Block@ used to determine if @body_block@ should be called again.
+    """
+
+    body_block call
+    cond_block until_do: body_block
+  }
+
   def unless: cond do: block {
     """
     Same as:
@@ -194,24 +281,51 @@ class Object {
     cond if_true: { nil } else: block
   }
 
+  def unless: cond do: block else: else_block {
+    """
+    Same as:
+      cond if_true: else_block else: block
+    """
+
+    cond if_true: else_block else: block
+  }
+
   def method: method_name {
-    "Returns the method with a given name for self, if defined."
+    """
+    @return @Method@ with @method_name defined for @self, or @nil.
+    Returns the method with a given name for self, if defined.
+    """
 
     method(message_name: method_name)
   }
 
   def documentation {
-    "Returns the documentation string for an Object."
-    Fancy Documentation for: self . to_s
+    """
+    @return @Fancy::Documentation@ object for @self.
+
+    Returns the @Fancy::Documentation@ object for an Object.
+    """
+
+    Fancy Documentation for: self
   }
 
-  def documentation: str {
-    "Sets the documentation string for an Object."
-    Fancy Documentation for: self is: str
+  def documentation: docstring {
+    """
+    @docstring New docstring for @self.
+
+    Sets the documentation string for an Object.
+    """
+
+    Fancy Documentation for: self is: docstring
   }
 
   def identity {
-    "The identity method simply returns self."
+    """
+    @return @self.
+
+    The identity method simply returns self.
+    """
+
     self
   }
 
@@ -268,38 +382,230 @@ class Object {
   }
 
   def ? future {
+    """
+    @future Future object to get the value from.
+    @return Result of calling #value on @future.
+
+    Calls #value on @future. Shortcut method.
+    """
+
     future value
   }
 
   def yield {
+    """
+    Same as Fiber##yield.
+    """
+
     Fiber yield
   }
 
   def yield: values {
-    Fiber yield: values
-  }
+    """
+    Same as Fiber##yield:
+    """
 
-  def wait: seconds {
-    Fiber yield: [seconds]
+    Fiber yield: values
   }
 
   def next {
-    "Skip to the next iteration"
+    """
+    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!
+    """
+    @value Value for next iteration.
+
+    Returns @value for current iteration and skip to the next one.
+    """
+
+    Fancy NextIteration new: value . raise!
   }
 
   def break {
-    "Stop iterating"
+    """
+    Breaks / Stops current iteration.
+    """
+
     Fancy BreakIteration new raise!
   }
 
   def break: value {
-    "Return value from iteration"
-    (Fancy BreakIteration new: value) raise!
+    """
+    @value Value to return from iteration.
+
+    Returns @value from iteratioen.
+    """
+
+    Fancy BreakIteration new: value . raise!
+  }
+
+  def __spawn_actor__ {
+    @__actor__active__ = true
+    Actor spawn: {
+      __actor__loop__
+    }
+  }
+
+  def __actor__loop__ {
+    while: { @__actor__active__ } do: {
+      sender = nil
+      try {
+        type, msg, sender = Actor receive
+        msg, params = msg
+        match type {
+          case 'async ->
+            self receive_message: msg with_params: params
+          case 'future ->
+            val = self receive_message: msg with_params: params
+            sender completed: val
+        }
+      } catch Exception => e {
+        { sender failed: e } if: sender
+        die!
+        e raise!
+      }
+    }
+  }
+
+  def __actor__die!__ {
+    @__actor__active__ = false
+    @__actor__ = nil
+  }
+
+  def __actor__ {
+    @__actor__ = @__actor__ || { __spawn_actor__ }
+    @__actor__
+  }
+
+  protected: [ '__spawn_actor__, '__actor__loop__, '__actor__die!__, '__actor__ ]
+
+  def die! {
+    """
+    Tells an object to let its actor to die (quit running).
+    """
+
+    __actor__die!__
+  }
+
+  def actor {
+    """
+    Returns the Object's actor.
+    If none exists at this moment, a new one will be created
+    and starts running in the background.
+    """
+
+    __actor__
+  }
+
+  def send_future: message with_params: params ([]) {
+    """
+    @message Message to be sent as a @FutureSend@.
+    @params @Array@ of parameters of the @FutureSend@.
+    @return @FutureSend@ object that will hold the return value of @message with @params on @self.
+
+    Creates a @FutureSend@ object (a Future / Promise) that will hold the value of sending @message to @self.
+    """
+
+    FutureSend new: __actor__ receiver: self message: message with_params: params
+  }
+
+  def send_async: message with_params: params ([]) {
+    """
+    @message Message to be sent asynchronously to @self.
+    @params @Array@ of parameters as part of sending @message asynchronously to @self.
+    @return @nil
+
+    Sends @message with @params to @self asynchronously and immediately returns @nil.
+    """
+
+    __actor__ ! ('async, (message, params), nil)
+    nil
+  }
+
+  def synchronized: block {
+    """
+    @block @Block@ to be run only by one Thread at a time.
+
+    Runs a given @Block@ in a synchronized fashion if called by multiple Threads.
+    Uses a @Mutex@ in the background for synchronization (created on demand for each @Object@).
+    """
+
+    @__mutex__ = @__mutex__ || { Mutex new() }
+    @__mutex__ synchronize(&block)
+  }
+
+  def copy_slots: slots from: object {
+    slots each: |s| {
+      set_slot: s value: (object get_slot: s)
+    }
+  }
+
+  def get_slots: slots {
+    """
+    @slots @Array@ of slot names to retrieve from @self.
+    @return @Array@ of slot values of slot names passed in via @slots.
+    """
+
+    slots map: |s| {
+      get_slot: s
+    }
+  }
+
+  def <=> other {
+    """
+    @other Other object to compare against.
+    @return -1 if @self is smaller, 0 if @self is equal or 1 if @self is greater or equal compared to @other.
+    """
+
+    { return -1 } if: (self < other)
+    { return 0 } if: (self == other)
+    return 1 # greater or equal to other
+  }
+
+  def do: block {
+    """
+    @block @Block@ to be called in the context of @self.
+
+    Helper method that calls @block with @self as the receiver.
+    This allows message cascading like code, e.g.:
+
+        some_complex_object do: {
+          method_1: arg1
+          method_2: arg2
+          method_3: arg3
+        }
+
+        # this is the same as:
+        some_complex_object method_1: arg1
+        some_complex_object method_2: arg2
+        some_complex_object method_3: arg3
+    """
+
+    block call_with_receiver: self
+  }
+
+  def slots {
+    """
+    @return @Set@ of slot names that @self has.
+    """
+
+    Set new: $ instance_variables map: |s| {
+      s rest to_sym
+    }
+  }
+
+  def sleep: seconds {
+    """
+    @seconds Amount of seconds to sleep.
+
+    Sets the current Thread (in which self is running) for a given amount to sleep.
+    """
+
+    Thread sleep: seconds
   }
-}
+}