myco 0.1.7 → 0.1.8

data/lib/myco/code_tools/parser/pegleromyces/spec/Patterns.test.my.rb

@@ -0,0 +1,334 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco::Component.new([::Myco.find_constant(:BasicSpec)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:name, [], nil, ::Myco.cscope.dup) { |*| ("Patterns")}
+  declare_meme(:new_pattern, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Patterns)::Base], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}.instance)}
+  declare_meme(:shorthand, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Patterns)::ShorthandMethods], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}.instance)}
+  __category__(:tests).component_eval {(
+    declare_meme(:"knows its name", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (self.assert_equal(
+      self.new_pattern.name,
+      :new_pattern
+    ))}
+    declare_meme(:"creates a NegativePredicate with the '!' unary operator", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = self.new_pattern
+      b = a.__send__(:!)
+      self.assert_is_a(
+        b,
+        ::Myco.find_constant(:Patterns)::NegativePredicate
+      )
+      self.assert_equal(
+        b.inner,
+        a
+      )
+    )}
+    declare_meme(:"creates a PositivePredicate with two uses of the '!' unary operator", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = self.new_pattern
+      b = a.__send__(:!).__send__(:!)
+      self.assert_is_a(
+        b,
+        ::Myco.find_constant(:Patterns)::PositivePredicate
+      )
+      self.assert_equal(
+        b.inner,
+        a
+      )
+    )}
+    declare_meme(:"creates a NegativePredicate with three uses of the '!' unary operator", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = self.new_pattern
+      b = a.__send__(:!).__send__(:!).__send__(:!)
+      self.assert_is_a(
+        b,
+        ::Myco.find_constant(:Patterns)::NegativePredicate
+      )
+      self.assert_equal(
+        b.inner,
+        a
+      )
+    )}
+    declare_meme(:"creates an OrderedChoice with the '/' operator", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = self.new_pattern
+      b = self.new_pattern
+      c = a.__send__(
+        :/,
+        b
+      )
+      self.assert_is_a(
+        c,
+        ::Myco.find_constant(:Patterns)::OrderedChoice
+      )
+      self.assert_equal(
+        c.first,
+        a
+      )
+      self.assert_equal(
+        c.second,
+        b
+      )
+    )}
+    declare_meme(:"interprets a series of OrderedChoices as a right-associative tree", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = self.new_pattern
+      b = self.new_pattern
+      c = self.new_pattern
+      d = self.new_pattern
+      e = a.__send__(
+        :/,
+        b
+      ).__send__(
+        :/,
+        c
+      ).__send__(
+        :/,
+        d
+      )
+      self.assert_is_a(
+        e,
+        ::Myco.find_constant(:Patterns)::OrderedChoice
+      )
+      self.assert_is_a(
+        e.second,
+        ::Myco.find_constant(:Patterns)::OrderedChoice
+      )
+      self.assert_is_a(
+        e.second.second,
+        ::Myco.find_constant(:Patterns)::OrderedChoice
+      )
+      self.assert_equal(
+        e.first,
+        a
+      )
+      self.assert_equal(
+        e.second.first,
+        b
+      )
+      self.assert_equal(
+        e.second.second.first,
+        c
+      )
+      self.assert_equal(
+        e.second.second.second,
+        d
+      )
+    )}
+    declare_meme(:"creates a Concatenation with the '+' operator", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = self.new_pattern
+      b = self.new_pattern
+      c = a.__send__(
+        :+,
+        b
+      )
+      self.assert_is_a(
+        c,
+        ::Myco.find_constant(:Patterns)::Concatenation
+      )
+      self.assert_equal(
+        c.first,
+        a
+      )
+      self.assert_equal(
+        c.second,
+        b
+      )
+    )}
+    declare_meme(:"interprets a series of Concatenations as a right-associative tree", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = self.new_pattern
+      b = self.new_pattern
+      c = self.new_pattern
+      d = self.new_pattern
+      e = a.__send__(
+        :+,
+        b
+      ).__send__(
+        :+,
+        c
+      ).__send__(
+        :+,
+        d
+      )
+      self.assert_is_a(
+        e,
+        ::Myco.find_constant(:Patterns)::Concatenation
+      )
+      self.assert_is_a(
+        e.second,
+        ::Myco.find_constant(:Patterns)::Concatenation
+      )
+      self.assert_is_a(
+        e.second.second,
+        ::Myco.find_constant(:Patterns)::Concatenation
+      )
+      self.assert_equal(
+        e.first,
+        a
+      )
+      self.assert_equal(
+        e.second.first,
+        b
+      )
+      self.assert_equal(
+        e.second.second.first,
+        c
+      )
+      self.assert_equal(
+        e.second.second.second,
+        d
+      )
+    )}
+    declare_meme(:"creates a OneOrMore with the '+' operator used as a 'suffix' call", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = self.new_pattern
+      b = a.__send__(:+)
+      self.assert_is_a(
+        b,
+        ::Myco.find_constant(:Patterns)::OneOrMore
+      )
+      self.assert_equal(
+        b.inner,
+        a
+      )
+      a = self.new_pattern.__send__(
+        :+,
+        self.new_pattern
+      )
+      b = a.__send__(:+)
+      self.assert_is_a(
+        b,
+        ::Myco.find_constant(:Patterns)::OneOrMore
+      )
+      self.assert_equal(
+        b.inner,
+        a
+      )
+    )}
+    declare_meme(:"creates a ZeroOrOne with the '-' operator used as a 'suffix' call", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = self.new_pattern
+      b = a.__send__(:-)
+      self.assert_is_a(
+        b,
+        ::Myco.find_constant(:Patterns)::ZeroOrOne
+      )
+      self.assert_equal(
+        b.inner,
+        a
+      )
+    )}
+    declare_meme(:"creates a ZeroOrMore with the '*' operator used as a 'suffix' call", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = self.new_pattern
+      b = a.__send__(:*)
+      self.assert_is_a(
+        b,
+        ::Myco.find_constant(:Patterns)::ZeroOrMore
+      )
+      self.assert_equal(
+        b.inner,
+        a
+      )
+    )}
+    declare_meme(:"creates a NamedCapture with the '[]' operator, given a capture name", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = self.new_pattern
+      b = a.__send__(
+        :[],
+        :foo
+      )
+      self.assert_is_a(
+        b,
+        ::Myco.find_constant(:Patterns)::NamedCapture
+      )
+      self.assert_equal(
+        b.inner,
+        a
+      )
+      self.assert_equal(
+        b.name,
+        :foo
+      )
+    )}
+    declare_meme(:"creates an AnyCharacter with the 'any' shorthand method", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = self.shorthand.any
+      self.assert_is_a(
+        a,
+        ::Myco.find_constant(:Patterns)::AnyCharacter
+      )
+    )}
+    declare_meme(:"creates a Character with the 'char' shorthand method", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = self.shorthand.char("x")
+      self.assert_is_a(
+        a,
+        ::Myco.find_constant(:Patterns)::Character
+      )
+      self.assert_equal(
+        a.code,
+        120
+      )
+    )}
+    declare_meme(:"creates a CharacterString with the 'str' shorthand method", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = self.shorthand.str("xyz")
+      self.assert_is_a(
+        a,
+        ::Myco.find_constant(:Patterns)::CharacterString
+      )
+      self.assert_equal(
+        a.codes,
+        [
+          120,
+          121,
+          122
+        ]
+      )
+    )}
+    declare_meme(:"creates a CharacterSet with the 'set' shorthand method", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = self.shorthand.set("xyz")
+      self.assert_is_a(
+        a,
+        ::Myco.find_constant(:Patterns)::CharacterSet
+      )
+      self.assert_equal(
+        a.codes,
+        [
+          120,
+          121,
+          122
+        ]
+      )
+    )}
+    declare_meme(:"creates a CharacterRange with the 'range' shorthand method", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = self.shorthand.range(
+        "x",
+        "z"
+      )
+      self.assert_is_a(
+        a,
+        ::Myco.find_constant(:Patterns)::CharacterRange
+      )
+      self.assert_equal(
+        a.start,
+        120
+      )
+      self.assert_equal(
+        a.stop,
+        122
+      )
+    )}
+    declare_meme(:"creates a Reduction with the 'r' shorthand method", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
+      a_proc = ::Myco.find_constant(:Proc).new { || nil}
+      a = self.new_pattern
+      b = self.shorthand.r(
+        a,
+        &a_proc
+      )
+      self.assert_is_a(
+        b,
+        ::Myco.find_constant(:Patterns)::Reduction
+      )
+      self.assert_equal(
+        b.inner,
+        a
+      )
+      self.assert_equal(
+        b.block,
+        a_proc
+      )
+    )}
+  )}
+)}}.instance)}}.instance

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

@@ -0,0 +1,10 @@
+
+BasicSpec {
+  name: "Processor"
+  
+  new_processor: Processor { }
+  
+  [tests]
+  
+  it "exists": assert(new_processor)
+}

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

@@ -0,0 +1,9 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco::Component.new([::Myco.find_constant(:BasicSpec)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:name, [], nil, ::Myco.cscope.dup) { |*| ("Processor")}
+  declare_meme(:new_processor, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Processor)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}.instance)}
+  __category__(:tests).component_eval {(declare_meme(:exists, [[:it, []]], nil, ::Myco.cscope.dup) { |*| (self.assert(self.new_processor))})}
+)}}.instance)}}.instance

data/lib/myco/code_tools/parser/pegleromyces/spec/run.my

@@ -0,0 +1,20 @@
+
+import 'BasicSpec.my'
+
+import '../lib/pegleromyces.my'
+
+
+import 'Patterns.test.my'
+import 'Constructions.test.my'
+
+import 'Instructions.test.my'
+import 'Machine.test.my'
+
+import 'Processor.test.my'
+import 'Builder.test.my'
+
+import 'Grammar.test.my'
+import 'Parser.test.my'
+
+import 'BytecodeInstructions.test.my'
+import 'BytecodeParser.test.my'

data/lib/myco/code_tools/parser/pegleromyces/spec/run.my.rb

@@ -0,0 +1,16 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:"BasicSpec.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"../lib/pegleromyces.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"Patterns.test.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"Constructions.test.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"Instructions.test.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"Machine.test.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"Processor.test.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"Builder.test.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"Grammar.test.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"Parser.test.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"BytecodeInstructions.test.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"BytecodeParser.test.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+)}}.instance

data/lib/myco/core/BasicDecorators.my

@@ -1,10 +1,18 @@
 
-::Myco::BasicDecorators < ::Myco::EmptyObject {
+::Myco::BasicDecorators << {
   [decorators]
   
+  # The 'const' decorator evaluates immediately and creates a thunk method
+  const: ConstDecorator
+  ConstDecorator: Decorator {
+    apply: |meme| {
+      meme.body = Rubinius::Thunk.new(meme.result)
+    }
+  }
+  
   # The 'storage' decorator acts like a set of var decorators
   # TODO: consolidate with 'var'
-  storage: Decorator {
+  const storage: Decorator {
     # Create a corresponding "writer" meme to go with this "reader" meme
     apply: |meme| {
       meme.target.declare_meme(:""meme.name"=") |new_value, *args| {
@@ -19,25 +27,25 @@
   # TODO: add const decorator to make all of these decorators 'thunks'
   
   # The 'var' decorator creates an instance variable getter and setter:
-  var: Decorator {
+  const var: Decorator {
     [transforms]
     var: true
   }
   
   # The 'memoize' decorator enables caching of the result
-  memoize: Decorator {
+  const memoize: Decorator {
     [transforms]
     cache: true
   }
   
   # The 'static' decorator makes the component's singleton class the target
-  static: Decorator {
+  const static: Decorator {
     [transforms]
     target: |meme| meme.target.singleton_class
   }
   
   # The 'before' decorator defines a wrapper that runs before the existing meme
-  before: Decorator {
+  const before: Decorator {
     apply: |meme| {
       orig_meme = meme.target.memes[meme.name]
       wrap_meme = meme.dup
@@ -49,7 +57,7 @@
   }
   
   # The 'after' decorator defines a wrapper that runs after the existing meme
-  after: Decorator {
+  const after: Decorator {
     apply: |meme| {
       orig_meme = meme.target.memes[meme.name]
       wrap_meme = meme.dup
@@ -63,7 +71,7 @@
   }
   
   # The 'pre' decorator defines a wrapper that pre-processes arguments
-  pre: Decorator {
+  const pre: Decorator {
     apply: |meme| {
       orig_meme = meme.target.memes[meme.name]
       wrap_meme = meme.dup
@@ -76,7 +84,7 @@
   }
   
   # The 'post' decorator defines a wrapper that post-processes return value
-  post: Decorator {
+  const post: Decorator {
     apply: |meme| {
       orig_meme = meme.target.memes[meme.name]
       wrap_meme = meme.dup
@@ -89,7 +97,7 @@
   }
   
   # The 'setter' decorator defines a setter that pre-processes the given value
-  setter: Decorator {
+  const setter: Decorator {
     apply: |meme| {
       wrap_meme = meme.dup
       meme.setter = &|orig_value| {
@@ -99,7 +107,7 @@
   }
   
   # The 'getter' decorator defines a getter that post-processes the return value
-  getter: Decorator {
+  const getter: Decorator {
     apply: |meme| {
       wrap_meme = meme.dup
       meme.getter = &|orig_value| {

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

@@ -1,8 +1,13 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco::BasicDecorators = ::Myco::Component.new([::Myco::EmptyObject], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(__category__(:decorators).component_eval {(
-  declare_meme(:storage, [], 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 {(::Myco::BasicDecorators.component_eval {(__category__(:decorators).component_eval {(
+  declare_meme(:const, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:ConstDecorator))}
+  ::Myco.cscope.for_method_definition::ConstDecorator = (::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| (meme.__send__(
+    :body=,
+    ::Myco.find_constant(:Rubinius)::Thunk.new(meme.result)
+  ))})}}.instance)
+  declare_meme(:storage, [[:const, []]], 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| (meme.target.declare_meme(:"#{meme.name}=") { |new_value, *args| (meme.set_result_for(
       self,
@@ -11,13 +16,13 @@
     ))})}
     __category__(:transforms).component_eval {(declare_meme(:cache, [], nil, ::Myco.cscope.dup) { |*| (true)})}
   )}}.instance)}
-  declare_meme(:var, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  declare_meme(:var, [[:const, []]], 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(: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__)
+  declare_meme(:memoize, [[:const, []]], 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(:static, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  declare_meme(:static, [[:const, []]], 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__)
+  declare_meme(:before, [[:const, []]], 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| (
     orig_meme = meme.target.memes.__send__(
       :[],
@@ -26,7 +31,7 @@
     wrap_meme = meme.dup
     meme.__send__(
       :body=,
-      ::Proc.new { |*a, &b| (
+      ::Object::Proc.new { |*a, &b| (
         wrap_meme.result_for(
           self,
           *a,
@@ -40,7 +45,7 @@
       )}
     )
   )})}}.instance)}
-  declare_meme(:after, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  declare_meme(:after, [[:const, []]], 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| (
     orig_meme = meme.target.memes.__send__(
       :[],
@@ -49,7 +54,7 @@
     wrap_meme = meme.dup
     meme.__send__(
       :body=,
-      ::Proc.new { |*a, &b| (
+      ::Object::Proc.new { |*a, &b| (
         result = orig_meme.result_for(
           self,
           *a,
@@ -64,7 +69,7 @@
       )}
     )
   )})}}.instance)}
-  declare_meme(:pre, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  declare_meme(:pre, [[:const, []]], 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| (
     orig_meme = meme.target.memes.__send__(
       :[],
@@ -73,7 +78,7 @@
     wrap_meme = meme.dup
     meme.__send__(
       :body=,
-      ::Proc.new { |*a, &b| (
+      ::Object::Proc.new { |*a, &b| (
         new_a = wrap_meme.result_for(
           self,
           *a
@@ -86,7 +91,7 @@
       )}
     )
   )})}}.instance)}
-  declare_meme(:post, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  declare_meme(:post, [[:const, []]], 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| (
     orig_meme = meme.target.memes.__send__(
       :[],
@@ -95,7 +100,7 @@
     wrap_meme = meme.dup
     meme.__send__(
       :body=,
-      ::Proc.new { |*a, &b| (
+      ::Object::Proc.new { |*a, &b| (
         result = orig_meme.result_for(
           self,
           *a,
@@ -108,27 +113,26 @@
       )}
     )
   )})}}.instance)}
-  declare_meme(:setter, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  declare_meme(:setter, [[:const, []]], 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| (
     wrap_meme = meme.dup
     meme.__send__(
       :setter=,
-      ::Proc.new { |orig_value| (wrap_meme.result_for(
+      ::Object::Proc.new { |orig_value| (wrap_meme.result_for(
         self,
         orig_value
       ))}
     )
   )})}}.instance)}
-  declare_meme(:getter, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  declare_meme(:getter, [[:const, []]], 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| (
     wrap_meme = meme.dup
     meme.__send__(
       :getter=,
-      ::Proc.new { |orig_value| (wrap_meme.result_for(
+      ::Object::Proc.new { |orig_value| (wrap_meme.result_for(
         self,
         orig_value
       ))}
     )
   )})}}.instance)}
-)})}}
-.tap { |__c__| __c__.__name__ = :BasicDecorators })}}.instance
+)})})}}.instance

data/lib/myco/core/BasicObject.my

@@ -1,5 +1,5 @@
 
-::Myco::BasicObject < ::Myco::EmptyObject, ::Myco::BasicDecorators {
+::Myco::BasicObject << {
   # Basic conditional handling
   if:     |cond, &blk| cond && blk.call
   unless: |cond, &blk| cond || blk.call
@@ -40,16 +40,21 @@
   # TODO: alias more efficiently
   # 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)
+  raise: |*args| ::Ruby.__send__(:raise, *args)
+  loop: |&block| ::Ruby.__send__(:loop, &block)
   break: raise(::Ruby::StopIteration)
   
+  send: |*args, &block| __send__(*args, &block)
+  
+  kind_of?: |mod| __kind_of__(mod)
+  is_a?:    |mod| __kind_of__(mod)
+  
+  class: __class__ # TODO: consider removing
+  
+  dup: __dup__ # TODO: remove
+  
   puts: |*args| STDOUT.puts(*args)
   p:    |*args| STDOUT.puts(args.map |a| { a.inspect }.join(', '))
   
   ruby_require: |arg| ::Ruby.send(:require, arg)
 }
-
-# Because ::Myco::Instance is a ::BasicObject, we must shadow ::BasicObject here
-::Myco::Instance::BasicObject: ::Myco::BasicObject
-