code-ruby 0.4.0 → 0.5.1

data/lib/code/object/function.rb

@@ -1,15 +1,15 @@
 class Code
   class Object
     class Function < ::Code::Object
-      def initialize(arguments:, body:)
-        @arguments = arguments
+      def initialize(parameters:, body:)
+        @parameters = parameters
         @body = body
       end
 
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
-        globals = args.multi_fetch(*::Code::GLOBALS)
+        globals = multi_fetch(args, *::Code::GLOBALS)
 
         if operator.nil? || operator == "call"
           call_function(args: arguments, globals: globals)
@@ -28,39 +28,36 @@ class Code
 
       private
 
-      attr_reader :arguments, :body
+      attr_reader :parameters, :body
 
       def call_function(args:, globals:)
-        new_context = globals[:context].deep_dup
+        new_context = deep_dup(globals[:context])
 
-        arguments.each.with_index do |argument, index|
-          if argument.regular?
-            if argument.splat?
-              new_context[argument.name] = ::Code::Object::List.new(
-                args.select(&:regular?).map(&:value),
+        parameters.each.with_index do |parameter, index|
+          if parameter.regular?
+            if parameter.regular_splat?
+              new_context[parameter.name] = ::Code::Object::List.new(
+                args.select(&:regular?).map(&:value)
               )
-            elsif argument.keyword_splat?
-              new_context[argument.name] = ::Code::Object::Dictionnary.new(
-                args.select(&:keyword?).map(&:name_value).to_h,
+            elsif parameter.keyword_splat?
+              new_context[parameter.name] = ::Code::Object::Dictionnary.new(
+                args.select(&:keyword?).map(&:name_value).to_h
               )
             else
               arg = args[index]&.value
-              arg = argument.evaluate(**globals) if arg.nil?
-              new_context[argument.name] = arg
+              arg = parameter.evaluate(**globals) if arg.nil?
+              new_context[parameter.name] = arg
             end
-          elsif argument.keyword?
-            arg = args.detect { |arg| arg.name == argument.name }&.value
-            arg = argument.evaluate(**globals) if arg.nil?
-            new_context[argument.name] = arg
+          elsif parameter.keyword?
+            arg = args.detect { |arg| arg.name == parameter.name }&.value
+            arg = parameter.evaluate(**globals) if arg.nil?
+            new_context[parameter.name] = arg
           else
             raise NotImplementedError
           end
         end
 
-        body.evaluate(
-          **globals,
-          context: new_context,
-        )
+        body.evaluate(**globals, context: new_context)
       end
     end
   end

data/lib/code/object/global.rb

@@ -6,7 +6,8 @@ class Code
         arguments = args.fetch(:arguments, [])
         context = args.fetch(:context)
         io = args.fetch(:io)
-        globals = args.multi_fetch(*::Code::GLOBALS)
+        globals = multi_fetch(args, *::Code::GLOBALS)
+        value = arguments.first&.value
 
         if operator == "print"
           io.print(*arguments.map(&:value))
@@ -15,11 +16,11 @@ class Code
           io.puts(*arguments.map(&:value))
           ::Code::Object::Nothing.new
         elsif operator == "context"
-          sig(arguments, ::Code::Object::String)
-          context[arguments.first.value] || ::Code::Object::Nothing.new
-        elsif operator == "eval"
-          sig(arguments, ::Code::Object::String)
-          Code.evaluate(arguments.first.value.raw)
+          sig(arguments) { ::Code::Object::String }
+          context[value] || ::Code::Object::Nothing.new
+        elsif operator == "evaluate"
+          sig(arguments) { ::Code::Object::String }
+          Code.evaluate(value.raw)
         else
           result = context[operator]
 
@@ -32,6 +33,10 @@ class Code
           end
         end
       end
+
+      def to_s
+        "global"
+      end
     end
   end
 end

data/lib/code/object/integer.rb

@@ -18,55 +18,73 @@ class Code
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
+        globals = multi_fetch(args, *::Code::GLOBALS)
+        value = arguments.first&.value
 
         if operator == "even?"
           sig(arguments)
           even?
+        elsif operator == "odd?"
+          sig(arguments)
+          odd?
+        elsif operator == "times"
+          sig(arguments) { ::Code::Object::Function }
+          times(value, **globals)
         elsif operator == "*"
-          sig(arguments, [::Code::Object::Number, ::Code::Object::String])
-          multiplication(arguments.first.value)
+          sig(arguments) { [[::Code::Object::Number, ::Code::Object::String]] }
+          multiplication(value)
         elsif operator == "/"
-          sig(arguments, ::Code::Object::Number)
-          division(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          division(value)
         elsif operator == "+"
-          sig(arguments, ::Code::Object)
-          plus(arguments.first.value)
+          if value
+            sig(arguments) { ::Code::Object }
+            plus(value)
+          else
+            sig(arguments)
+            self
+          end
         elsif operator == "%"
-          sig(arguments, ::Code::Object::Number)
-          modulo(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          modulo(value)
         elsif operator == "-"
-          sig(arguments, ::Code::Object::Number)
-          minus(arguments.first.value)
+          if value
+            sig(arguments) { ::Code::Object::Number }
+            minus(value)
+          else
+            sig(arguments)
+            unary_minus
+          end
         elsif operator == "**"
-          sig(arguments, ::Code::Object::Number)
-          power(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          power(value)
         elsif operator == "<"
-          sig(arguments, ::Code::Object::Number)
-          inferior(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          inferior(value)
         elsif operator == "<="
-          sig(arguments, ::Code::Object::Number)
-          inferior_or_equal(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          inferior_or_equal(value)
         elsif operator == ">"
-          sig(arguments, ::Code::Object::Number)
-          superior(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          superior(value)
         elsif operator == ">="
-          sig(arguments, ::Code::Object::Number)
-          superior_or_equal(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          superior_or_equal(value)
         elsif operator == "<<"
-          sig(arguments, ::Code::Object::Number)
-          left_shift(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          left_shift(value)
         elsif operator == ">>"
-          sig(arguments, ::Code::Object::Number)
-          right_shift(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          right_shift(value)
         elsif operator == "&"
-          sig(arguments, ::Code::Object::Number)
-          bitwise_and(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          bitwise_and(value)
         elsif operator == "|"
-          sig(arguments, ::Code::Object::Number)
-          bitwise_or(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          bitwise_or(value)
         elsif operator == "^"
-          sig(arguments, ::Code::Object::Number)
-          bitwise_xor(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          bitwise_xor(value)
         else
           super
         end
@@ -76,6 +94,10 @@ class Code
         ::Code::Object::Integer.new(raw + 1)
       end
 
+      def +(other)
+        ::Code::Object::Integer.new(raw + other.raw)
+      end
+
       def to_s
         raw.to_s
       end
@@ -90,6 +112,10 @@ class Code
         ::Code::Object::Boolean.new(raw.even?)
       end
 
+      def odd?
+        ::Code::Object::Boolean.new(raw.odd?)
+      end
+
       def multiplication(other)
         if other.is_a?(::Code::Object::Integer)
           ::Code::Object::Integer.new(raw * other.raw)
@@ -130,6 +156,10 @@ class Code
         end
       end
 
+      def unary_minus
+        ::Code::Object::Integer.new(-raw)
+      end
+
       def power(other)
         if other.is_a?(::Code::Object::Integer)
           ::Code::Object::Integer.new(raw**other.raw)
@@ -173,6 +203,19 @@ class Code
       def bitwise_xor(other)
         ::Code::Object::Integer.new(raw ^ other.raw.to_i)
       end
+
+      def times(argument, **globals)
+        raw.times do |element|
+          argument.call(
+            arguments: [
+              ::Code::Object::Argument.new(::Code::Object::Integer.new(element))
+            ],
+            **globals
+          )
+        end
+
+        self
+      end
     end
   end
 end

data/lib/code/object/list.rb

@@ -10,32 +10,33 @@ class Code
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
-        globals = args.multi_fetch(*::Code::GLOBALS)
+        globals = multi_fetch(args, *::Code::GLOBALS)
+        value = arguments.first&.value
 
         if operator == "any?"
-          sig(arguments, ::Code::Object::Function)
-          any?(arguments.first.value, **globals)
+          sig(arguments) { ::Code::Object::Function }
+          any?(value, **globals)
         elsif operator == "none?"
-          sig(arguments, ::Code::Object::Function)
-          none?(arguments.first.value, **globals)
+          sig(arguments) { ::Code::Object::Function }
+          none?(value, **globals)
         elsif operator == "detect"
-          sig(arguments, ::Code::Object::Function)
-          detect(arguments.first.value, **globals)
+          sig(arguments) { ::Code::Object::Function }
+          detect(value, **globals)
         elsif operator == "reduce"
-          sig(arguments, ::Code::Object::Function)
-          reduce(arguments.first.value, **globals)
+          sig(arguments) { ::Code::Object::Function }
+          reduce(value, **globals)
         elsif operator == "each"
-          sig(arguments, ::Code::Object::Function)
-          each(arguments.first.value, **globals)
+          sig(arguments) { ::Code::Object::Function }
+          each(value, **globals)
         elsif operator == "select"
-          sig(arguments, ::Code::Object::Function)
-          select(arguments.first.value, **globals)
+          sig(arguments) { ::Code::Object::Function }
+          select(value, **globals)
         elsif operator == "map"
-          sig(arguments, ::Code::Object::Function)
-          map(arguments.first.value, **globals)
+          sig(arguments) { ::Code::Object::Function }
+          map(value, **globals)
         elsif operator == "max_by"
-          sig(arguments, ::Code::Object::Function)
-          max_by(arguments.first.value, **globals)
+          sig(arguments) { ::Code::Object::Function }
+          max_by(value, **globals)
         elsif operator == "max"
           sig(arguments)
           max
@@ -52,8 +53,11 @@ class Code
           sig(arguments)
           last
         elsif operator == "<<"
-          sig(arguments, ::Code::Object)
-          append(arguments.first.value)
+          sig(arguments) { ::Code::Object }
+          append(value)
+        elsif operator == "include?"
+          sig(arguments) { ::Code::Object }
+          include?(value)
         else
           super
         end
@@ -67,7 +71,7 @@ class Code
             else
               acc + [element]
             end
-          end,
+          end
         )
       end
 
@@ -75,6 +79,11 @@ class Code
         ::Code::Object::List.new(raw.deep_dup)
       end
 
+      def <<(other)
+        raw << other
+        self
+      end
+
       def to_s
         "[#{raw.map(&:inspect).join(", ")}]"
       end
@@ -90,9 +99,9 @@ class Code
           raw.any? do |element|
             argument.call(
               arguments: [::Code::Object::Argument.new(element)],
-              **globals,
+              **globals
             ).truthy?
-          end,
+          end
         )
       end
 
@@ -101,9 +110,9 @@ class Code
           raw.none? do |element|
             argument.call(
               arguments: [::Code::Object::Argument.new(element)],
-              **globals,
+              **globals
             ).truthy?
-          end,
+          end
         )
       end
 
@@ -111,7 +120,7 @@ class Code
         raw.max_by do |element|
           argument.call(
             arguments: [::Code::Object::Argument.new(element)],
-            **globals,
+            **globals
           )
         end || ::Code::Object::Nothing.new
       end
@@ -120,7 +129,7 @@ class Code
         raw.detect do |element|
           argument.call(
             arguments: [::Code::Object::Argument.new(element)],
-            **globals,
+            **globals
           ).truthy?
         end || ::Code::Object::Nothing.new
       end
@@ -130,9 +139,9 @@ class Code
           argument.call(
             arguments: [
               ::Code::Object::Argument.new(acc),
-              ::Code::Object::Argument.new(element),
+              ::Code::Object::Argument.new(element)
             ],
-            **globals,
+            **globals
           )
         end || ::Code::Object::Nothing.new
       end
@@ -141,7 +150,7 @@ class Code
         raw.each do |element|
           argument.call(
             arguments: [::Code::Object::Argument.new(element)],
-            **globals,
+            **globals
           )
         end
         self
@@ -152,20 +161,20 @@ class Code
           raw.select do |element|
             argument.call(
               arguments: [::Code::Object::Argument.new(element)],
-              **globals,
+              **globals
             ).truthy?
-          end,
+          end
         )
       end
 
-      def map(argument, context:, io:)
+      def map(argument, **globals)
         ::Code::Object::List.new(
           raw.map do |element|
             argument.call(
               arguments: [::Code::Object::Argument.new(element)],
-              **globals,
+              **globals
             )
-          end,
+          end
         )
       end
 
@@ -174,6 +183,10 @@ class Code
         self
       end
 
+      def include?(other)
+        ::Code::Object::Boolean.new(raw.include?(other))
+      end
+
       def first
         raw.first || ::Code::Object::Nothing.new
       end

data/lib/code/object/range.rb

@@ -13,26 +13,27 @@ class Code
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
-        globals = args.multi_fetch(*::Code::GLOBALS)
+        globals = multi_fetch(args, *::Code::GLOBALS)
+        value = arguments.first&.value
 
         if operator == "any?"
-          sig(arguments, ::Code::Object::Function)
-          any?(arguments.first.value, **globals)
+          sig(arguments) { ::Code::Object::Function }
+          any?(value, **globals)
         elsif operator == "all?"
-          sig(arguments, ::Code::Object::Function)
-          all?(arguments.first.value, **globals)
+          sig(arguments) { ::Code::Object::Function }
+          all?(value, **globals)
         elsif operator == "each"
-          sig(arguments, ::Code::Object::Function)
-          each(arguments.first.value, **globals)
+          sig(arguments) { ::Code::Object::Function }
+          each(value, **globals)
         elsif operator == "select"
-          sig(arguments, ::Code::Object::Function)
-          select(arguments.first.value, **globals)
+          sig(arguments) { ::Code::Object::Function }
+          select(value, **globals)
         elsif operator == "map"
-          sig(arguments, ::Code::Object::Function)
-          map(arguments.first.value, **globals)
+          sig(arguments) { ::Code::Object::Function }
+          map(value, **globals)
         elsif operator == "step"
-          sig(arguments, ::Code::Object::Number)
-          step(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          step(value)
         elsif operator == "to_list"
           sig(arguments)
           to_list
@@ -64,7 +65,7 @@ class Code
               arguments: [::Code::Object::Argument.new(element)],
               **globals
             ).truthy?
-          end,
+          end
         )
       end
 
@@ -75,7 +76,7 @@ class Code
               arguments: [::Code::Object::Argument.new(element)],
               **globals
             ).truthy?
-          end,
+          end
         )
       end
 
@@ -96,7 +97,7 @@ class Code
               arguments: [::Code::Object::Argument.new(element)],
               **globals
             ).truthy?
-          end,
+          end
         )
       end
 
@@ -107,7 +108,7 @@ class Code
               arguments: [::Code::Object::Argument.new(element)],
               **globals
             )
-          end,
+          end
         )
       end
 

data/lib/code/object/ruby_function.rb

@@ -10,13 +10,19 @@ class Code
       private
 
       def call_function(args:, globals:)
-        regular_arguments = args.select(&:regular?).map(&:value).map do |argument|
-          ::Code::Ruby.from_code(argument)
-        end
+        regular_arguments =
+          args
+            .select(&:regular?)
+            .map(&:value)
+            .map { |argument| ::Code::Ruby.from_code(argument) }
 
-        keyword_arguments = args.select(&:keyword?).map do |argument|
-          [argument.name.to_sym, ::Code::Ruby.from_code(argument.value)]
-        end.to_h
+        keyword_arguments =
+          args
+            .select(&:keyword?)
+            .map do |argument|
+              [argument.name.to_sym, ::Code::Ruby.from_code(argument.value)]
+            end
+            .to_h
 
         ::Code::Ruby.to_code(raw.call(*regular_arguments, **keyword_arguments))
       end

data/lib/code/object/string.rb

@@ -10,17 +10,18 @@ class Code
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
-        globals = args.multi_fetch(*::Code::GLOBALS)
+        globals = multi_fetch(args, *::Code::GLOBALS)
+        value = arguments.first&.value
 
-        if operator == "to_function"
+        if operator == "&" || operator == "to_function"
           sig(arguments)
           to_function(**globals)
         elsif operator == "+"
-          sig(arguments, ::Code::Object)
-          plus(arguments.first.value)
+          sig(arguments) { ::Code::Object }
+          plus(value)
         elsif operator == "*"
-          sig(arguments, ::Code::Object::Number)
-          multiplication(arguments.first.value)
+          sig(arguments) { ::Code::Object::Number }
+          multiplication(value)
         elsif operator == "reverse"
           sig(arguments)
           reverse
@@ -52,13 +53,22 @@ class Code
           [
             {
               function: {
-                arguments: [{ regular: { name: "_" } }],
+                parameters: [{ name: "_" }],
                 body: [
-                  { call: { left: { name: "_" }, right: [{ name: raw }] } },
-                ],
-              },
-            },
-          ],
+                  {
+                    chained_call: {
+                      first: {
+                        call: {
+                          name: "_"
+                        }
+                      },
+                      others: [{ call: { name: raw } }]
+                    }
+                  }
+                ]
+              }
+            }
+          ]
         ).evaluate(**globals)
       end