fancy 0.7.0 → 0.8.0

data/examples/blocks.fy

@@ -1,15 +1,15 @@
 # blocks.fy
 # Examples of fancy code blocks
 
-x = { Console println: "Println from within block!" }
+x = { "Println from within block!" println }
 x call # calls x and prints: "Println from within block!"
 
-y = |x y| { Console println: $ x + y }
+y = |x y| { x + y println }
 y call: [2, 3] # calls y and prints: 5
 
 # prints numbers 0 to 20
 num = 0
 while: { num <= 20 } do: {
-  Console println: num
+  num println
   num = num + 1
 }

data/examples/distributing_proxy.fy

@@ -0,0 +1,31 @@
+class Worker {
+  def initialize: @name supervisor: @supervisor
+  def work! {
+    Thread sleep: 0.5
+    @supervisor @@ done: @name
+  }
+}
+
+class Supervisor {
+  def initialize: @amount {
+    @done = []
+    @workers = Proxies DistributingProxy new: $ (1..@amount) map: |i| { Worker new: i supervisor: self }
+  }
+
+  def start {
+    "Starting: #{(0..@amount) to_a inspect}" println
+    @amount times: {
+      @workers @@ work!
+    }
+  }
+
+  def done: worker {
+    @done << worker
+    if: (@done size == @amount) then: {
+      "Done: #{@done inspect}" println
+    }
+  }
+}
+
+Supervisor new: 10 . start
+Console readln

data/examples/future_sends.fy

@@ -0,0 +1,15 @@
+class Bar {
+  def foo {
+    Thread sleep: 5
+    42
+  }
+}
+
+b = Bar new
+f = b @ foo timeouts: <[
+  3.5 => { "3.5 secs passed!" println; System abort: "Timeout" }
+]>
+
+f value inspect println
+
+Console readln: "..."

data/examples/person.fy

@@ -3,8 +3,7 @@
 
 class City {
   read_slot: 'name
-  def initialize: @name {
-  }
+  def initialize: @name
 
   def to_s {
     "City: " ++ @name

data/lib/argv.fy

@@ -38,10 +38,4 @@ def ARGV for_options: op_names do: block {
       return true
     }
   }
-}
-
-def ARGV main?: filename {
-  if: (ARGV[0]) then: {
-    File expand_path: (ARGV[0]) . == filename
-  }
-}
+}

data/lib/array.fy

@@ -98,22 +98,18 @@ class Array {
   def each: block {
     """
     @block @Block@ to be called for each element in @self.
-    @return @self
+    @return @self.
 
     Calls a given @Block@ with each element in the @Array@.
     """
 
-    try {
-      size times: |i| {
-        try {
-          block call: [at: i]
-        } catch (Fancy NextIteration) => ex {
-        }
+    size times: |i| {
+      try {
+        block call: [at: i]
+      } catch Fancy NextIteration {
       }
-      return self
-    } catch (Fancy BreakIteration) => ex {
-      ex result
     }
+    self
   }
 
   def reverse_each: block {
@@ -375,7 +371,7 @@ class Array {
   def from: from to: to {
     """
     @from Start index for sub-array.
-    @to End index ofr sub-array.
+    @to End index for sub-array.
 
     Returns sub-array starting at from: and going to to:
     """

data/lib/block.fy

@@ -203,4 +203,19 @@ class Block {
 
     DynamicValueArray new do: self . array
   }
+
+  def * iterations {
+    """
+    @iterations @Fixnum@ of amount of iterations to run @self.
+
+    Runs @self @iteration times.
+    Same as: `iterations times: self`
+
+    Example:
+          { \"Hello, World\" println } * 2
+          # => prints \"Hello, World\" 2 times
+    """
+
+    iterations times: self
+  }
 }

data/lib/boot.fy

@@ -18,6 +18,7 @@ require: "class"
 require: "true_class"
 require: "nil_class"
 require: "false_class"
+require: "exception"
 require: "number"
 require: "enumerable"
 require: "string"
@@ -35,8 +36,7 @@ require: "hash"
 require: "set"
 require: "symbol"
 require: "stack"
-require: "proxy"
-require: "thread_pool"
+require: "proxies"
 require: "fiber"
 require: "future"
 require: "struct"
@@ -50,5 +50,6 @@ require: "vars"
 require: "system"
 
 require: "documentation"
-
 require: "package"
+require: "contracts"
+require: "matchers"

data/lib/class.fy

@@ -8,6 +8,112 @@ class Class {
 
   forwards_unary_ruby_methods
 
+  alias_method: '__private__: for: 'private:
+  alias_method: '__protected__: for: 'protected:
+  alias_method: '__public__: for: 'public:
+
+  def private: private_methods {
+    """
+    @private_methods @Block@ or @Fancy::Enumerable@ of method names to be private.
+
+    Sets any given method names to private on this @Class@.
+
+    Example:
+          class MyClass {
+            def foo {}
+            def bar {}
+
+            private: 'foo
+            private: 'bar
+
+            # same as:
+            private: ('foo, 'bar)
+
+            # same as:
+            private: {
+              def foo {}
+              def bar {}
+            }
+          }
+    """
+
+    __private__: $ match private_methods {
+      case Block ->
+        methods = instance_methods: false
+        private_methods call
+        instance_methods: false - methods
+      case _ -> private_methods
+    }
+  }
+
+  def protected: protected_methods {
+    """
+    @protected_methods @Block@ or @Fancy::Enumerable@ of method names to be protected.
+
+    Sets any given method names to protected on this @Class@.
+
+    Example:
+          class MyClass {
+            def foo {}
+            def bar {}
+
+            protected: 'foo
+            protected: 'bar
+
+            # same as:
+            protected: ('foo, 'bar)
+
+            # same as:
+            protected: {
+              def foo {}
+              def bar {}
+            }
+          }
+    """
+
+    __protected__: $ match protected_methods {
+      case Block ->
+        methods = instance_methods: false
+        protected_methods call
+        instance_methods: false - methods
+      case _ -> protected_methods
+    }
+  }
+
+  def public: public_methods {
+    """
+    @public_methods @Block@ or @Fancy::Enumerable@ of method names to be public.
+
+    Sets any given method names to public on this @Class@.
+
+    Example:
+          class MyClass {
+            def foo {}
+            def bar {}
+
+            public: 'foo
+            public: 'bar
+
+            # same as:
+            public: ('foo, 'bar)
+
+            # same as:
+            public: {
+              def foo {}
+              def bar {}
+            }
+          }
+    """
+
+    __public__: $ match public_methods {
+      case Block ->
+        methods = instance_methods: false
+        public_methods call
+        instance_methods: false - methods
+      case _ -> public_methods
+    }
+  }
+
   def define_slot_reader: slotname {
     """
     @slotname Name of the slot to define a getter method for.
@@ -125,6 +231,23 @@ class Class {
     }
   }
 
+  def remove_slot_accessors_for: slotnames {
+    """
+    @slotnames Name of slot or @Array@ of slotnames to remove accessor methods for.
+
+    Removes both reader and writer methods for slots in @slotnames.
+    """
+
+    slotnames to_a each: |s| {
+      try {
+        undefine_method: s
+      } catch NameError {}
+      try {
+        undefine_method: "#{s}:"
+      } catch NameError {}
+    }
+  }
+
   def subclass?: class_obj {
     """
     @class_obj Class object to check for, if @self is a subclass of @class_obj.
@@ -193,16 +316,11 @@ class Class {
           }
       }
 
-      mdef = "def #{message_with_args}"
-
-      mdef << " {\n"
-      mdef << "@#{slotname} #{message_with_args}"
-
-      mdef << "\n}"
-
-      class_eval: {
-        mdef eval
+      class_eval: """
+      def #{message_with_args} {
+        @#{slotname} #{message_with_args}
       }
+      """
     }
   }
 
@@ -221,4 +339,230 @@ class Class {
       name
     }
   }
-}
+
+  def fancy_instance_methods {
+    """
+    @return @Array@ of all instance methods defined in Fancy.
+    """
+
+    instance_methods select: @{ includes?: ":" }
+  }
+
+  def ruby_instance_methods {
+    """
+    @return @Array@ of all instance methods defined in Ruby.
+    """
+
+    instance_methods - fancy_instance_methods
+  }
+
+  # dummy methods, get replaced at end of startup in lib/contracts.fy
+  def provides_interface: methods {
+    @provided_interface_methods = @provided_interface_methods to_a append: (methods to_a)
+  }
+
+  def expects_interface_on_inclusion: methods {
+    @expected_interface_methods = methods to_a
+  }
+  alias_method: 'expects_interface: for: 'expects_interface_on_inclusion:
+
+  def before_method: method_name run: block_or_method_name {
+    """
+    @method_name Name of @Method@ to run another @Method@ or @Block@ before, when called.
+    @block_or_method_name @Block@ or name of other @Method@ to be called before @method_name.
+
+    Runs / Calls @block_or_method everytime before running @method_name.
+
+    Example:
+          Array before_method: 'inspect run: 'compact!
+          [1, nil, 2, nil, 3] inspect # => \"[1, 2, 3]\"
+
+          # Or pass a Block:
+          Array before_method: 'inspect run: @{ compact! }
+    """
+
+    define_calling_chain: [block_or_method_name, method_name] for_method: method_name
+  }
+
+  def after_method: method_name run: block_or_method_name {
+    """
+    @method_name Name of @Method@ to run another @Method@ or @Block@ after, when called.
+    @block_or_method_name @Block@ or name of other @Method@ to be called after @method_name.
+
+    Runs / Calls @block_or_method_name everytime after running @method_name.
+
+    Example:
+          Array after_method: 'inspect run: 'compact!
+          x = [1, nil, 2, nil, 3]
+          x inspect # => \"[1, nil, 2, nil, 3]\"
+          x inspect # => \"[1, 2, 3]\"
+
+          # Or pass a Block:
+          Array after_method: 'inspect run: @{ compact! }
+    """
+
+    define_calling_chain: [method_name, block_or_method_name] for_method: method_name
+  }
+
+  def around_method: method_name run: block_or_method_name {
+    """
+    @method_name Name of @Method@ to run another @Method@ or @Block@ before & after, when called.
+    @block_or_method_name @Block@ or name of other @Method@ to be called before & after @method_name.
+
+    Runs / Calls @block_or_method_name everytime before & after running @method_name.
+
+    Example:
+          class MyController {
+            def do_stuff {
+              \"Doing stuff\" println
+            }
+
+            def log_data {
+              \"Log data\" println
+            }
+
+            around_method: 'do_stuff run: 'log_data
+          }
+
+          controller = MyController new
+          controller do_stuff
+
+          # which will print:
+          # Log data
+          # Doing stuff
+          # Log data
+
+          # Or pass a Block:
+          MyController around_method: 'do_stuff run: { \"Log data\" println }
+    """
+
+    define_calling_chain: [block_or_method_name, method_name, block_or_method_name] for_method: method_name
+  }
+
+  def define_calling_chain: blocks_or_method_names for_method: method_name {
+    """
+    @blocks_or_method_names @Array@ of either method names or @Block@s to be called in order.
+    @method_name Name of method to define calling chain for.
+
+    Example:
+          class Foo {
+            def foo { 'foo println }
+            def bar { 'bar println }
+            def baz { 'baz println }
+
+            define_calling_chain: ['foo, 'bar, 'baz] for_method: 'foo
+          }
+
+          Foo new foo
+          # prints:
+          # foo
+          # bar
+          # baz
+
+          # You can also pass in Blocks:
+          Foo define_calling_chain: [@{ foo }, @{ bar }, @{ baz }] for_method: 'bar
+
+          Foo new bar
+          # prints:
+          # foo
+          # bar
+          # baz
+    """
+
+    # optimize for methods if all arguments are symbols (generate code instead of using dynamic #call: messages)
+    if: (blocks_or_method_names all?: @{ is_a?: Symbol }) then: {
+      return define_method_calling_chain: blocks_or_method_names for_method: method_name
+    }
+
+    method = instance_method: method_name
+
+    define_method: (method_name message_name) with: |args1| {
+      bound_method = method bind(self)
+
+      new_method_body = |args2| {
+        match bound_method arity {
+          case 0 -> args2 = []
+          case 1 -> args2 = [args2]
+        }
+
+        args_with_self = args2 dup unshift: self
+        return_val = nil
+        blocks_or_method_names each: |block| {
+          match block {
+            case method_name -> return_val = bound_method call: args2
+            case _ -> block call: args_with_self
+          }
+        }
+        return_val
+      }
+
+      # define new method body and run it afterwards as we lazily
+      # define the method the first time it's called for each new
+      # instance of this class
+      metaclass define_method: (method_name message_name) with: new_method_body
+
+      match method arity {
+        case 0 -> args1 = []
+        case 1 -> args1 = [args1]
+      }
+
+      new_method_body call: args1
+    }
+  }
+
+  def define_method_calling_chain: method_names for_method: method_name {
+    orig_method_name = "__original__#{method_name}"
+    alias_method: orig_method_name for: (method_name message_name)
+
+    method = instance_method: (method_name message_name)
+    orig_method = instance_method: orig_method_name
+
+    before_methods = method_names take_while: |m| { m != method_name }
+    _orig_method, *after_methods = method_names drop_while: |m| { m != method_name }
+
+    before_methods = before_methods map: |m| { instance_method: m . selector_with_args } . join: ";"
+    after_methods = after_methods map: |m| { instance_method: m . selector_with_args } . join: ";"
+
+    class_eval: """
+      def #{method selector_with_args} {
+        #{before_methods}
+        return_val = #{orig_method selector_with_args}
+        #{after_methods}
+        return_val
+      }
+    """
+  }
+
+  def rebind_instance_method: method_name with: rebind_callable within: within_block receiver: receiver (self) {
+    """
+    @method_name Name of instance method to rebind in @self.
+    @rebind_callable Name of method or @Block@ to rebind @method_name to.
+    @within_block @Block@ to be called with @receiver or @self.
+    @receiver Argument to @within_block. Defaults to @self.
+    @return Value of calling @within_block with @receiver.
+
+    Rebinds @method_name to @rebind_callable within @within_block.
+    If @within_block takes an argument, it will be called with @receiver (defaults to @self).
+    """
+
+    try {
+      old_method = nil
+      try {
+        old_method = instance_method: method_name
+      } catch NameError {}
+
+      match rebind_callable {
+        case Symbol -> alias_method: method_name for: rebind_callable
+        case _ -> define_method: method_name with: rebind_callable
+      }
+
+      return within_block call: [receiver]
+    } finally {
+      if: old_method then: {
+        define_method: method_name with: old_method
+      } else: {
+        undefine_method: method_name
+      }
+    }
+  }
+}