myco 0.1.6 → 0.1.7

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/BytecodeHelpers.my

@@ -38,7 +38,7 @@ BytecodeHelpers < BasicObject {
     g.push_subject; g.push_idx; g.send(:chr_at, 1)
   
   push_new_hash:
-    g.push_cpath_top; g.find_const(:"Hash"); g.send(:new, 0)
+    g.push_cpath_top; g.find_const(:Hash); g.send(:new, 0)
   
   # Set the memo ivar to a new hash if it doesn't already exist
   memo_or_eq_new_hash: |name| {
@@ -54,7 +54,7 @@ BytecodeHelpers < BasicObject {
   
   # Copy the top two values into the memo ivar for |name| at the current idx.
   copy_result_to_memo: |name| {
-    g.dup
+    g.dup_top
     g.push_captures
     g.make_array(2) # [result_idx, result_captures]
     
@@ -74,7 +74,7 @@ BytecodeHelpers < BasicObject {
     g.push_memo_for(name)
       g.push_idx
     g.send(:"[]", 1)
-    g.dup # dup the result to retain after goto test
+    g.dup_top # dup the result to retain after goto test
     g.goto_if_nil(skip_label)
     
     # Shift result_idx onto the stack and swap with array

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/BytecodeHelpers.my.rb

@@ -82,7 +82,7 @@
     memo_exists_label.__send__(:set!)
   )}
   declare_meme(:copy_result_to_memo, [], nil, ::Myco.cscope.dup) { |name| (
-    self.g.dup
+    self.g.dup_top
     self.g.push_captures
     self.g.make_array(2)
     self.g.push_memo_for(name)
@@ -103,7 +103,7 @@
       :[],
       1
     )
-    self.g.dup
+    self.g.dup_top
     self.g.goto_if_nil(skip_label)
     self.g.shift_array
     self.g.swap

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/BytecodeInstructions.my

@@ -49,42 +49,42 @@ BytecodeInstructions < BasicObject {
     
     NegativePredicate << { bytecode: |m|
       m.neg_predicate(
-        Proc.new { inner.bytecode(m) }
+        &{ inner.bytecode(m) }
         inner.bytecode_can_capture
       )
     }
     PositivePredicate << { bytecode: |m|
       m.pos_predicate(
-        Proc.new { inner.bytecode(m) }
+        &{ inner.bytecode(m) }
         inner.bytecode_can_capture
       )
     }
     OneOrMore << { bytecode: |m|
       m.many(
-        Proc.new { inner.bytecode(m); inlaid.?call }
+        &{ inner.bytecode(m); inlaid.?call }
         inner.bytecode_can_capture
       )
     }
     ZeroOrOne << {
       bytecode: |m| {
         m.choice(
-          Proc.new { inner.bytecode(m) }
-          Proc.new { }
+          &{ inner.bytecode(m) }
+          &{ }
           inner.bytecode_can_capture
         )
       }
     }
     ZeroOrMore << { bytecode: |m|
       m.kleene(
-        Proc.new { inner.bytecode(m); inlaid.?call }
+        &{ inner.bytecode(m); inlaid.?call }
         inner.bytecode_can_capture
       )
     }
     OrderedChoice << {
       bytecode: |m| {
         m.choice(
-          Proc.new { first.bytecode(m) }
-          Proc.new { second.bytecode(m) }
+          &{ first.bytecode(m) }
+          &{ second.bytecode(m) }
           first.bytecode_can_capture
         )
       }
@@ -96,7 +96,7 @@ BytecodeInstructions < BasicObject {
     NamedCapture << {
       bytecode: |m| {
         (inner.is_a?(OneOrMore) || inner.is_a?(ZeroOrMore)) &? (
-          inner.inlaid = Proc.new { m.capture(:m_split, captargs) }
+          inner.inlaid = &{ m.capture(:m_split, captargs) }
           m.capture(:m_start)
           inner.bytecode(m)
           m.capture(:m_end, captargs)

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/BytecodeInstructions.my.rb

@@ -17,35 +17,35 @@
         m.set(codes.map(&:chr).join)
       )})}
       ::Myco.find_constant(:NegativePredicate).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (m.neg_predicate(
-        ::Myco.find_constant(:Proc).new { || (self.inner.bytecode(m))},
+        ::Proc.new { || (self.inner.bytecode(m))},
         self.inner.bytecode_can_capture
       ))})}
       ::Myco.find_constant(:PositivePredicate).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (m.pos_predicate(
-        ::Myco.find_constant(:Proc).new { || (self.inner.bytecode(m))},
+        ::Proc.new { || (self.inner.bytecode(m))},
         self.inner.bytecode_can_capture
       ))})}
       ::Myco.find_constant(:OneOrMore).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (m.many(
-        ::Myco.find_constant(:Proc).new { || (
+        ::Proc.new { || (
           self.inner.bytecode(m)
           (self.inlaid.respond_to?(:call).false? ? ::Myco::Void : self.inlaid.call)
         )},
         self.inner.bytecode_can_capture
       ))})}
       ::Myco.find_constant(:ZeroOrOne).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (m.choice(
-        ::Myco.find_constant(:Proc).new { || (self.inner.bytecode(m))},
-        ::Myco.find_constant(:Proc).new { || nil},
+        ::Proc.new { || (self.inner.bytecode(m))},
+        ::Proc.new { || nil},
         self.inner.bytecode_can_capture
       ))})}
       ::Myco.find_constant(:ZeroOrMore).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (m.kleene(
-        ::Myco.find_constant(:Proc).new { || (
+        ::Proc.new { || (
           self.inner.bytecode(m)
           (self.inlaid.respond_to?(:call).false? ? ::Myco::Void : self.inlaid.call)
         )},
         self.inner.bytecode_can_capture
       ))})}
       ::Myco.find_constant(:OrderedChoice).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (m.choice(
-        ::Myco.find_constant(:Proc).new { || (self.first.bytecode(m))},
-        ::Myco.find_constant(:Proc).new { || (self.second.bytecode(m))},
+        ::Proc.new { || (self.first.bytecode(m))},
+        ::Proc.new { || (self.second.bytecode(m))},
         self.first.bytecode_can_capture
       ))})}
       ::Myco.find_constant(:Concatenation).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (
@@ -61,7 +61,7 @@
       )}) {(
         self.inner.__send__(
           :inlaid=,
-          ::Myco.find_constant(:Proc).new { || (m.capture(
+          ::Proc.new { || (m.capture(
             :m_split,
             self.captargs
           ))}

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/BytecodeParser.my

@@ -53,7 +53,7 @@ BytecodeParser < BasicObject {
   
   save_prototype: |filename| {
     code = compile_code(:__script__, :"(snippet)") |g| {
-      g.push_cpath_top; g.find_const(:"Class")
+      g.push_cpath_top; g.find_const(:Class)
       g.create_block(compile_generator(:__block__, :"(snippet)") |g| {
         prototype.instance_methods.each |name| {
           code = prototype.instance_method(name).executable
@@ -120,7 +120,7 @@ BytecodeParser < BasicObject {
       self.error_col = pos.last
       self.error_string = \
       "Unexpected character near line: "error_row", column: "error_col".\n" \
-        string.each_line.to_a[error_row]"" \
+        string.each_line.to_a[error_row - 1]"" \
         (' ' * [(error_col - 1), 0].max)"^"
     }
     self.result

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/BytecodeParser.my.rb

@@ -205,7 +205,10 @@
         :error_string=,
         "Unexpected character near line: #{self.error_row}, column: #{self.error_col}.\n#{string.each_line.to_a.__send__(
           :[],
-          self.error_row
+          self.error_row.__send__(
+            :-,
+            1
+          )
         )}#{" ".__send__(
           :*,
           [

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Grammar.my

@@ -13,8 +13,7 @@ Grammar < BasicObject, Patterns::ShorthandMethods {
     bytecode_can_capture: true
   }
   
-  var rule_table: Hash.new
-  var rule_table: Hash.new
+  var rule_table: ::Ruby::Hash.new
   
   # Force evaluation of the rule tree in a way that
   # doesn't get stuck in an infinite recursion.
@@ -37,7 +36,7 @@ Grammar < BasicObject, Patterns::ShorthandMethods {
   token: Decorator {
     apply: |meme| {
       orig_meme = meme.dup
-      meme.body = Proc.new { orig_meme.result.token(:"t_"meme.name"") }
+      meme.body = &{ orig_meme.result.token(:"t_"meme.name"") }
     }
     [transforms]
     cache: true

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Grammar.my.rb

@@ -22,8 +22,7 @@
     declare_meme(:bytecode_can_capture, [], nil, ::Myco.cscope.dup) { |*| (true)}
   )}}
   .tap { |__c__| __c__.__name__ = :RuleReference }
-  declare_meme(:rule_table, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Hash).new)}
-  declare_meme(:rule_table, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Hash).new)}
+  declare_meme(:rule_table, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Ruby::Hash.new)}
   declare_meme(:construct_all_rules, [], nil, ::Myco.cscope.dup) { |*| (
     self.rules.root.construct_rule
     seen_keys = []
@@ -49,7 +48,7 @@
         orig_meme = meme.dup
         meme.__send__(
           :body=,
-          ::Myco.find_constant(:Proc).new { || (orig_meme.result.token(:"t_#{meme.name}"))}
+          ::Proc.new { || (orig_meme.result.token(:"t_#{meme.name}"))}
         )
       )}
       __category__(:transforms).component_eval {(declare_meme(:cache, [], nil, ::Myco.cscope.dup) { |*| (true)})}

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Machine.my

@@ -23,7 +23,7 @@ Machine < BasicObject, Instructions {
   var subject: []
   
   # The sequence of instructions to execute for each rule name
-  var sequence_table: Hash.new
+  var sequence_table: ::Ruby::Hash.new
   
   
   # Execute the root rule instruction sequence over the given subject

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Machine.my.rb

@@ -11,7 +11,7 @@
   declare_meme(:stack, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
   declare_meme(:captures, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
   declare_meme(:subject, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
-  declare_meme(:sequence_table, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Hash).new)}
+  declare_meme(:sequence_table, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Ruby::Hash.new)}
   declare_meme(:execute, [], nil, ::Myco.cscope.dup) { |*| (self.loop { || (::Myco.branch_op(:"??", ::Myco.branch_op(:"|?", self.ip) {self.handle_fail}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.ip.__send__(
     :==,
     true

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Processor.my

@@ -40,7 +40,7 @@ Processor < BasicObject {
   
   # Given a string, return a map of indices of newline positions to line numbers
   memoize line_map_for: |string| {
-    idx_hash = ::Hash.new
+    idx_hash = ::Ruby::Hash.new
     idx_hash[0] = 0
     count = 0
     idx = 0
@@ -56,13 +56,13 @@ Processor < BasicObject {
   # Given an index and string, return the row (line) and column numbers
   position_of: |idx, string| {
     nl_idx = string.rindex("\n", idx) || 0
-    row = line_map_for(string).fetch(nl_idx) + 1
+    row = line_map_for(string).fetch(nl_idx) + 2
     col = idx - nl_idx
     [row, col]
   }
   
   # Push or pop a layer to/from the capture stack
-  push_layer: capt_stack.push(::Hash.new)
+  push_layer: capt_stack.push(::Ruby::Hash.new)
   pop_layer:  capt_stack.pop
   
   setup:
@@ -70,7 +70,7 @@ Processor < BasicObject {
   
   final_captures:
     pop_layer
-      .select |k,v| { k.is_a?(::Symbol) }
+      .select |k,v| { k.is_a?(Symbol) }
       .map    |k,v| { [k,v.last] }
       .to_h
   
@@ -185,7 +185,7 @@ Processor < BasicObject {
     # Try to find a group of "anonymous" captures by index first
     value = []
     captures.each |k,v| {
-      (k.is_a?(::Fixnum) && k<=idx && k>start_idx) && (
+      (k.is_a?(Fixnum) && k<=idx && k>start_idx) && (
         loc = v.first
         (loc.first>=start_idx) && (
           value.push(v.last)

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Processor.my.rb

@@ -48,7 +48,7 @@
   declare_meme(:ridx_stack, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
   declare_meme(:capt_stack, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
   declare_meme(:line_map_for, [[:memoize, []]], nil, ::Myco.cscope.dup) { |string| (
-    idx_hash = ::Hash.new
+    idx_hash = ::Ruby::Hash.new
     idx_hash.__send__(
       :[]=,
       0,
@@ -84,7 +84,7 @@
     )) {0}
     row = self.line_map_for(string).fetch(nl_idx).__send__(
       :+,
-      1
+      2
     )
     col = idx.__send__(
       :-,
@@ -95,12 +95,12 @@
       col
     ]
   )}
-  declare_meme(:push_layer, [], nil, ::Myco.cscope.dup) { |*| (self.capt_stack.push(::Hash.new))}
+  declare_meme(:push_layer, [], nil, ::Myco.cscope.dup) { |*| (self.capt_stack.push(::Ruby::Hash.new))}
   declare_meme(:pop_layer, [], nil, ::Myco.cscope.dup) { |*| (self.capt_stack.pop)}
   declare_meme(:setup, [], nil, ::Myco.cscope.dup) { |*| (self.push_layer)}
   declare_meme(:final_captures, [], nil, ::Myco.cscope.dup) { |*| (self.pop_layer.select { |k, v| (k.__send__(
     :is_a?,
-    ::Symbol
+    ::Myco.find_constant(:Symbol)
   ))}.map { |k, v| ([
     k,
     v.last
@@ -254,7 +254,7 @@
     value = []
     captures.each { |k, v| (::Myco.branch_op(:"&&", ::Myco.branch_op(:"&&", ::Myco.branch_op(:"&&", k.__send__(
       :is_a?,
-      ::Fixnum
+      ::Myco.find_constant(:Fixnum)
     )) {k.__send__(
       :<=,
       idx

data/lib/myco/command.my

@@ -8,7 +8,7 @@ BasicCommand {
   
   run: |*argv| {
     files = options_parse(*argv)
-    files && files.uniq.each |file| { Myco.eval_file(file, [::Dir.pwd]) }
+    files && files.uniq.each |file| { Myco.eval_file(file, [Dir.pwd]) }
   }
   
   [options]

data/lib/myco/command.my.rb

@@ -10,7 +10,7 @@
       files = self.options_parse(*argv)
       ::Myco.branch_op(:"&&", files) {files.uniq.each { |file| (::Myco.find_constant(:Myco).eval_file(
         file,
-        [::Dir.pwd]
+        [::Myco.find_constant(:Dir).pwd]
       ))}}
     )}
     __category__(:options).component_eval {(

data/lib/myco/core/BasicDecorators.my

@@ -16,6 +16,8 @@
     cache: true # Enable caching of the value to act as storage
   }
   
+  # TODO: add const decorator to make all of these decorators 'thunks'
+  
   # The 'var' decorator creates an instance variable getter and setter:
   var: Decorator {
     [transforms]
@@ -28,8 +30,8 @@
     cache: true
   }
   
-  # The 'sclass' decorator makes the component's singleton class the target
-  sclass: Decorator {
+  # The 'static' decorator makes the component's singleton class the target
+  static: Decorator {
     [transforms]
     target: |meme| meme.target.singleton_class
   }
@@ -39,7 +41,7 @@
     apply: |meme| {
       orig_meme = meme.target.memes[meme.name]
       wrap_meme = meme.dup
-      meme.body = Proc.new |*a,&b| {
+      meme.body = &|*a,&b| {
         wrap_meme.result_for(self,*a,&b)
         orig_meme.result_for(self,*a,&b)
       }
@@ -51,7 +53,7 @@
     apply: |meme| {
       orig_meme = meme.target.memes[meme.name]
       wrap_meme = meme.dup
-      meme.body = Proc.new |*a,&b| {
+      meme.body = &|*a,&b| {
         result = \
         orig_meme.result_for(self,*a,&b)
         wrap_meme.result_for(self,*a,&b)
@@ -65,7 +67,7 @@
     apply: |meme| {
       orig_meme = meme.target.memes[meme.name]
       wrap_meme = meme.dup
-      meme.body = Proc.new |*a,&b| {
+      meme.body = &|*a,&b| {
         new_a = \
         wrap_meme.result_for(self,*a)
         orig_meme.result_for(self,*new_a,&b)
@@ -78,7 +80,7 @@
     apply: |meme| {
       orig_meme = meme.target.memes[meme.name]
       wrap_meme = meme.dup
-      meme.body = Proc.new |*a,&b| {
+      meme.body = &|*a,&b| {
         result = \
         orig_meme.result_for(self,*a,&b)
         wrap_meme.result_for(self,result)
@@ -90,7 +92,7 @@
   setter: Decorator {
     apply: |meme| {
       wrap_meme = meme.dup
-      meme.setter = Proc.new |orig_value| {
+      meme.setter = &|orig_value| {
         wrap_meme.result_for(self,orig_value)
       }
     }
@@ -100,7 +102,7 @@
   getter: Decorator {
     apply: |meme| {
       wrap_meme = meme.dup
-      meme.getter = Proc.new |orig_value| {
+      meme.getter = &|orig_value| {
         wrap_meme.result_for(self,orig_value)
       }
     }

data/lib/myco/core/BasicDecorators.my.rb

@@ -15,7 +15,7 @@
   .tap { |__c__| __c__.__last__ = __c__.component_eval {(__category__(:transforms).component_eval {(declare_meme(:var, [], nil, ::Myco.cscope.dup) { |*| (true)})})}}.instance)}
   declare_meme(:memoize, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
   .tap { |__c__| __c__.__last__ = __c__.component_eval {(__category__(:transforms).component_eval {(declare_meme(:cache, [], nil, ::Myco.cscope.dup) { |*| (true)})})}}.instance)}
-  declare_meme(:sclass, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  declare_meme(:static, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
   .tap { |__c__| __c__.__last__ = __c__.component_eval {(__category__(:transforms).component_eval {(declare_meme(:target, [], nil, ::Myco.cscope.dup) { |meme| (meme.target.singleton_class)})})}}.instance)}
   declare_meme(:before, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
   .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:apply, [], nil, ::Myco.cscope.dup) { |meme| (
@@ -26,7 +26,7 @@
     wrap_meme = meme.dup
     meme.__send__(
       :body=,
-      ::Myco.find_constant(:Proc).new { |*a, &b| (
+      ::Proc.new { |*a, &b| (
         wrap_meme.result_for(
           self,
           *a,
@@ -49,7 +49,7 @@
     wrap_meme = meme.dup
     meme.__send__(
       :body=,
-      ::Myco.find_constant(:Proc).new { |*a, &b| (
+      ::Proc.new { |*a, &b| (
         result = orig_meme.result_for(
           self,
           *a,
@@ -73,7 +73,7 @@
     wrap_meme = meme.dup
     meme.__send__(
       :body=,
-      ::Myco.find_constant(:Proc).new { |*a, &b| (
+      ::Proc.new { |*a, &b| (
         new_a = wrap_meme.result_for(
           self,
           *a
@@ -95,7 +95,7 @@
     wrap_meme = meme.dup
     meme.__send__(
       :body=,
-      ::Myco.find_constant(:Proc).new { |*a, &b| (
+      ::Proc.new { |*a, &b| (
         result = orig_meme.result_for(
           self,
           *a,
@@ -113,7 +113,7 @@
     wrap_meme = meme.dup
     meme.__send__(
       :setter=,
-      ::Myco.find_constant(:Proc).new { |orig_value| (wrap_meme.result_for(
+      ::Proc.new { |orig_value| (wrap_meme.result_for(
         self,
         orig_value
       ))}
@@ -124,7 +124,7 @@
     wrap_meme = meme.dup
     meme.__send__(
       :getter=,
-      ::Myco.find_constant(:Proc).new { |orig_value| (wrap_meme.result_for(
+      ::Proc.new { |orig_value| (wrap_meme.result_for(
         self,
         orig_value
       ))}

data/lib/myco/core/BasicObject.my

@@ -3,20 +3,51 @@
   # Basic conditional handling
   if:     |cond, &blk| cond && blk.call
   unless: |cond, &blk| cond || blk.call
-  switch: |input,comparator=:"=="|
+  case: |input, *rest| {
+    # If there is a final strategy with no test value, use it as the else case
+    use_strategy = rest.size.odd? && rest.pop
+    # Iterate over the pairs of test_values and strategies,
+    # selecting the first matching pair's strategy as the one to use.
+    rest.each_slice(2).detect |test_value, strategy| {
+      (test_value == input) && (
+        use_strategy = strategy
+        true
+      )
+    }
+    # Call or return the selected strategy or error if none
+    use_strategy &? (use_strategy.?call(input) ?? use_strategy)
+                 ?? raise("No match for case("input")")
+  }
+  cond: |*rest| {
+    # If there is a final strategy with no test value, use it as the else case
+    use_strategy = rest.size.odd? && rest.pop
+    # Iterate over the pairs of test_values and strategies,
+    # selecting the first matching pair's strategy as the one to use.
+    rest.each_slice(2).detect |test_value, strategy| {
+      (test_value.?call ?? test_value) && (
+        use_strategy = strategy
+        true
+      )
+    }
+    # Call or return the selected strategy or error if none
+    use_strategy &? (use_strategy.?call ?? use_strategy)
+                 ?? raise("No match for cond")
+  }
+  
+  switch: |input,comparator=:"=="| # TODO: remove deprecated switch
     Switch.new(input:input, comparator:comparator)
   
   # TODO: alias more efficiently
-  # alias(::Kernel, :raise) raise
-  # alias(::Kernel, :loop) loop
-  raise: |*args| ::Kernel.instance_method(:raise).bind(self).call(*args)
-  loop: |&block| ::Kernel.instance_method(:loop).bind(self).call(&block)
-  break: raise(::StopIteration)
+  # alias(::Ruby::Kernel, :raise) raise
+  # alias(::Ruby::Kernel, :loop) loop
+  raise: |*args| ::Ruby::Kernel.instance_method(:raise).bind(self).call(*args)
+  loop: |&block| ::Ruby::Kernel.instance_method(:loop).bind(self).call(&block)
+  break: raise(::Ruby::StopIteration)
   
   puts: |*args| STDOUT.puts(*args)
   p:    |*args| STDOUT.puts(args.map |a| { a.inspect }.join(', '))
   
-  ruby_require: |arg| Object.send(:require, arg)
+  ruby_require: |arg| ::Ruby.send(:require, arg)
 }
 
 # Because ::Myco::Instance is a ::BasicObject, we must shadow ::BasicObject here

data/lib/myco/core/BasicObject.my.rb

@@ -8,16 +8,35 @@
   .tap { |__c__| __c__.__last__ = __c__.component_eval {(
     declare_meme(:if, [], nil, ::Myco.cscope.dup) { |cond, &blk| (::Myco.branch_op(:"&&", cond) {blk.call})}
     declare_meme(:unless, [], nil, ::Myco.cscope.dup) { |cond, &blk| (::Myco.branch_op(:"||", cond) {blk.call})}
+    declare_meme(:case, [], nil, ::Myco.cscope.dup) { |input, *rest| (
+      use_strategy = ::Myco.branch_op(:"&&", rest.size.__send__(:odd?)) {rest.pop}
+      rest.each_slice(2).detect { |test_value, strategy| (::Myco.branch_op(:"&&", test_value.__send__(
+        :==,
+        input
+      )) {(
+        use_strategy = strategy
+        true
+      )})}
+      ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", use_strategy) {::Myco.branch_op(:"??", (use_strategy.respond_to?(:call).false? ? ::Myco::Void : use_strategy.call(input))) {use_strategy}}) {self.raise("No match for case(#{input})")}
+    )}
+    declare_meme(:cond, [], nil, ::Myco.cscope.dup) { |*rest| (
+      use_strategy = ::Myco.branch_op(:"&&", rest.size.__send__(:odd?)) {rest.pop}
+      rest.each_slice(2).detect { |test_value, strategy| (::Myco.branch_op(:"&&", ::Myco.branch_op(:"??", (test_value.respond_to?(:call).false? ? ::Myco::Void : test_value.call)) {test_value}) {(
+        use_strategy = strategy
+        true
+      )})}
+      ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", use_strategy) {::Myco.branch_op(:"??", (use_strategy.respond_to?(:call).false? ? ::Myco::Void : use_strategy.call)) {use_strategy}}) {self.raise("No match for cond")}
+    )}
     declare_meme(:switch, [], nil, ::Myco.cscope.dup) { |input, comparator=:==| (::Myco.find_constant(:Switch).new({
       :input => input,
       :comparator => comparator
     }))}
-    declare_meme(:raise, [], nil, ::Myco.cscope.dup) { |*args| (::Kernel.instance_method(:raise).bind(self).call(*args))}
-    declare_meme(:loop, [], nil, ::Myco.cscope.dup) { |&block| (::Kernel.instance_method(:loop).bind(self).call(&block))}
-    declare_meme(:break, [], nil, ::Myco.cscope.dup) { |*| (self.raise(::StopIteration))}
+    declare_meme(:raise, [], nil, ::Myco.cscope.dup) { |*args| (::Ruby::Kernel.instance_method(:raise).bind(self).call(*args))}
+    declare_meme(:loop, [], nil, ::Myco.cscope.dup) { |&block| (::Ruby::Kernel.instance_method(:loop).bind(self).call(&block))}
+    declare_meme(:break, [], nil, ::Myco.cscope.dup) { |*| (self.raise(::Ruby::StopIteration))}
     declare_meme(:puts, [], nil, ::Myco.cscope.dup) { |*args| (::Myco.find_constant(:STDOUT).puts(*args))}
     declare_meme(:p, [], nil, ::Myco.cscope.dup) { |*args| (::Myco.find_constant(:STDOUT).puts(args.map { |a| (a.inspect)}.join(", ")))}
-    declare_meme(:ruby_require, [], nil, ::Myco.cscope.dup) { |arg| (::Myco.find_constant(:Object).send(
+    declare_meme(:ruby_require, [], nil, ::Myco.cscope.dup) { |arg| (::Ruby.send(
       :require,
       arg
     ))}

data/lib/myco/tools/BasicCommand.my

@@ -7,7 +7,7 @@ BasicCommand < Object {
   options_parse: |*argv| {
     command = argv.first && self.commands.memes[argv.first.to_sym]
     command
-      &? (command.result.run(*argv.slice(::Range.new(1, -1))); null)
+      &? (command.result.run(*argv.slice(Range.new(1, -1))); null)
       ?? options_parser.parse(argv)
   }
   

data/lib/myco/tools/BasicCommand.my.rb

@@ -11,7 +11,7 @@
       argv.first.to_sym
     )}
     ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", command) {(
-      command.result.run(*argv.slice(::Range.new(
+      command.result.run(*argv.slice(::Myco.find_constant(:Range).new(
         1,
         -1
       )))

data/lib/myco/version.rb

@@ -1,6 +1,6 @@
 
 module Myco
-  MYCO_VERSION = '0.1.6'
+  MYCO_VERSION = '0.1.7'
   
   MYCO_REQUIRED_GEMS = [
     ['rubinius-toolset',   '~> 2.3'],

data/lib/myco.rb

@@ -11,6 +11,9 @@ require_relative 'myco/backtrace'
 require_relative 'myco/bootstrap'
 
 
+# TODO: remove this hack after 0.1.7 gem release
+::Ruby = ::Object
+
 # Detect whether a second pass is necessary (when no bytecode is available)
 # TODO: recursively check mtime for all rbc files as well,
 #   to be sure that core implementation files don't need to be recompiled.