there goes the module

it was ruby after all
should be reborn as twins: namespace and aspect

lib/parser/basic_types.rb

@@ -44,7 +44,7 @@ module Parser
     rule(:field) { type >> name >> (assign >> value_expression.as(:value) ).maybe}
     rule(:class_field) { keyword_field >> field }
     # and class/module names must start with capital
-    rule(:module_name) { keyword.absent? >> (match['A-Z'] >> match['a-zA-Z0-9_'].repeat).as(:module_name)  >> space? }
+    rule(:class_name) { keyword.absent? >> (match['A-Z'] >> match['a-zA-Z0-9_'].repeat).as(:class_name)  >> space? }
 
     rule(:escape)     { str('\\') >> any.as(:esc) }
     rule(:string)     { quote >> (
@@ -56,7 +56,7 @@ module Parser
 
     rule(:float) { integer >>  dot >> integer >>
                             (exponent >> sign.maybe >> digit.repeat(1,3)).maybe >> space?}
-    rule(:basic_type){ integer | name | string | float | field | module_name |
+    rule(:basic_type){ integer | name | string | float | field | class_name |
                        keyword_true | keyword_false | keyword_nil }
   end
 end

lib/parser/class_definition.rb

@@ -0,0 +1,11 @@
+module Parser
+  module ModuleDef
+    include Parslet
+
+    rule(:class_definition) do
+      keyword_class >> class_name >> (smaller >> class_name).maybe.as(:derived_name) >>
+      ( (keyword_end.absent? >> root_body).repeat()).as(:class_expressions) >> keyword_end
+    end
+
+  end
+end

lib/parser/function_definition.rb

@@ -3,7 +3,7 @@ module Parser
     include Parslet
 
     rule(:function_definition) {
-      type >> ((module_name|name).as(:receiver) >> str(".")).maybe >> #possibly qualified
+      type >> ((class_name|name).as(:receiver) >> str(".")).maybe >> #possibly qualified
                   name.as(:function_name) >> left_parenthesis >>
                   parameter_list.maybe >> right_parenthesis >> expressions_end >> space?
     }

lib/parser/module_definition.rb

@@ -1,15 +0,0 @@
-module Parser
-  module ModuleDef
-    include Parslet
-    rule(:module_definition) do
-      keyword_module >> module_name >>
-      ( (keyword_end.absent? >> root_body).repeat()).as(:module_expressions) >> keyword_end
-    end
-
-    rule(:class_definition) do
-      keyword_class >> module_name >> (smaller >> module_name).maybe.as(:derived_name) >>
-      ( (keyword_end.absent? >> root_body).repeat()).as(:class_expressions) >> keyword_end
-    end
-
-  end
-end

lib/parser/salama.rb

@@ -6,7 +6,7 @@ require_relative "control"
 require_relative "expression"
 require_relative "call_site"
 require_relative "function_definition"
-require_relative "module_definition"
+require_relative "class_definition"
 require_relative "operators"
 
 module Parser
@@ -31,7 +31,7 @@ module Parser
     include Operators
     include ModuleDef
 
-    rule(:root_body)    {(module_definition | class_definition | function_definition |
+    rule(:root_body)    {( class_definition | function_definition |
                           expression  | operator_expression | call_site  )}
     rule(:root)         { root_body.repeat.as(:expression_list) }
   end

lib/parser/transform.rb

@@ -24,7 +24,7 @@ module Parser
     rule(:field => simple(:field) , :type   => simple(:type), :name   => simple(:name) , :value => simple(:value))  {
       s(:class_field , type.to_sym , name.to_sym , value ) }
 
-    rule(:module_name   => simple(:module_name))  { s(:module,module_name.to_s) }
+    rule(:class_name   => simple(:class_name))  { s(:module,class_name.to_s) }
 
     rule(:array_constant => sequence(:array_constant) ) { s(:array , *array_constant) }
     rule(:array_element  => simple(:array_element))    { array_element  }
@@ -99,13 +99,13 @@ module Parser
     end
 
     #modules and classes are understandibly quite similar   Class < Module
-    rule( :module_name => simple(:module_name) , :derived_name => simple(:derived_name) , :class_expressions => sequence(:class_expressions) , :end=>"end") do
-      s(:class , module_name.to_s.to_sym ,
+    rule( :class_name => simple(:class_name) , :derived_name => simple(:derived_name) , :class_expressions => sequence(:class_expressions) , :end=>"end") do
+      s(:class , class_name.to_s.to_sym ,
           s(:derives, derived_name ? derived_name.to_a.first.to_sym : nil) ,
             s(:expressions, *class_expressions) )
     end
-    rule( :module_name => simple(:module_name) , :module_expressions => sequence(:module_expressions) , :end=>"end") do
-      s(:module , module_name.to_s.to_sym , s(:expressions, *module_expressions))
+    rule( :class_name => simple(:class_name) , :module_expressions => sequence(:module_expressions) , :end=>"end") do
+      s(:module , class_name.to_s.to_sym , s(:expressions, *module_expressions))
     end
 
     rule(:expression_list => sequence(:expression_list)) {