code-ruby 0.3.1 → 0.4.0

data/lib/code/object/integer.rb

@@ -20,19 +20,53 @@ class Code
         arguments = args.fetch(:arguments, [])
 
         if operator == "even?"
-          even?(arguments)
+          sig(arguments)
+          even?
         elsif operator == "*"
-          multiplication(arguments)
+          sig(arguments, [::Code::Object::Number, ::Code::Object::String])
+          multiplication(arguments.first.value)
         elsif operator == "/"
-          division(arguments)
+          sig(arguments, ::Code::Object::Number)
+          division(arguments.first.value)
         elsif operator == "+"
-          plus(arguments)
-        elsif %w[% - **].detect { |o| operator == o }
-          integer_or_decimal_operation(operator.to_sym, arguments)
-        elsif %w[> >= < <=].detect { |o| operator == o }
-          comparaison(operator.to_sym, arguments)
-        elsif %w[<< >> & | ^].detect { |o| operator == o }
-          integer_operation(operator.to_sym, arguments)
+          sig(arguments, ::Code::Object)
+          plus(arguments.first.value)
+        elsif operator == "%"
+          sig(arguments, ::Code::Object::Number)
+          modulo(arguments.first.value)
+        elsif operator == "-"
+          sig(arguments, ::Code::Object::Number)
+          minus(arguments.first.value)
+        elsif operator == "**"
+          sig(arguments, ::Code::Object::Number)
+          power(arguments.first.value)
+        elsif operator == "<"
+          sig(arguments, ::Code::Object::Number)
+          inferior(arguments.first.value)
+        elsif operator == "<="
+          sig(arguments, ::Code::Object::Number)
+          inferior_or_equal(arguments.first.value)
+        elsif operator == ">"
+          sig(arguments, ::Code::Object::Number)
+          superior(arguments.first.value)
+        elsif operator == ">="
+          sig(arguments, ::Code::Object::Number)
+          superior_or_equal(arguments.first.value)
+        elsif operator == "<<"
+          sig(arguments, ::Code::Object::Number)
+          left_shift(arguments.first.value)
+        elsif operator == ">>"
+          sig(arguments, ::Code::Object::Number)
+          right_shift(arguments.first.value)
+        elsif operator == "&"
+          sig(arguments, ::Code::Object::Number)
+          bitwise_and(arguments.first.value)
+        elsif operator == "|"
+          sig(arguments, ::Code::Object::Number)
+          bitwise_or(arguments.first.value)
+        elsif operator == "^"
+          sig(arguments, ::Code::Object::Number)
+          bitwise_xor(arguments.first.value)
         else
           super
         end
@@ -52,14 +86,11 @@ class Code
 
       private
 
-      def even?(arguments)
-        sig(arguments)
+      def even?
         ::Code::Object::Boolean.new(raw.even?)
       end
 
-      def multiplication(arguments)
-        sig(arguments, [::Code::Object::Number, ::Code::Object::String])
-        other = arguments.first.value
+      def multiplication(other)
         if other.is_a?(::Code::Object::Integer)
           ::Code::Object::Integer.new(raw * other.raw)
         elsif other.is_a?(::Code::Object::Decimal)
@@ -69,10 +100,7 @@ class Code
         end
       end
 
-      def plus(arguments)
-        sig(arguments, ::Code::Object)
-        other = arguments.first.value
-
+      def plus(other)
         if other.is_a?(::Code::Object::Integer)
           ::Code::Object::Integer.new(raw + other.raw)
         elsif other.is_a?(::Code::Object::Decimal)
@@ -82,32 +110,68 @@ class Code
         end
       end
 
-      def division(arguments)
-        sig(arguments, ::Code::Object::Number)
-        other = arguments.first.value
+      def division(other)
         ::Code::Object::Decimal.new(BigDecimal(raw) / other.raw)
       end
 
-      def integer_or_decimal_operation(operator, arguments)
-        sig(arguments, ::Code::Object::Number)
-        other = arguments.first.value
+      def modulo(other)
         if other.is_a?(::Code::Object::Integer)
-          ::Code::Object::Integer.new(raw.public_send(operator, other.raw))
+          ::Code::Object::Integer.new(raw % other.raw)
         else
-          ::Code::Object::Decimal.new(raw.public_send(operator, other.raw))
+          ::Code::Object::Decimal.new(raw % other.raw)
         end
       end
 
-      def integer_operation(operator, arguments)
-        sig(arguments, ::Code::Object::Number)
-        other = arguments.first.value
-        ::Code::Object::Integer.new(raw.to_i.public_send(operator, other.raw.to_i))
+      def minus(other)
+        if other.is_a?(::Code::Object::Integer)
+          ::Code::Object::Integer.new(raw - other.raw)
+        else
+          ::Code::Object::Decimal.new(raw - other.raw)
+        end
+      end
+
+      def power(other)
+        if other.is_a?(::Code::Object::Integer)
+          ::Code::Object::Integer.new(raw**other.raw)
+        else
+          ::Code::Object::Decimal.new(raw**other.raw)
+        end
+      end
+
+      def inferior(other)
+        ::Code::Object::Boolean.new(raw < other.raw)
+      end
+
+      def inferior_or_equal(other)
+        ::Code::Object::Boolean.new(raw <= other.raw)
+      end
+
+      def superior(other)
+        ::Code::Object::Boolean.new(raw > other.raw)
+      end
+
+      def superior_or_equal(other)
+        ::Code::Object::Boolean.new(raw >= other.raw)
+      end
+
+      def left_shift(other)
+        ::Code::Object::Integer.new(raw << other.raw.to_i)
+      end
+
+      def right_shift(other)
+        ::Code::Object::Integer.new(raw >> other.raw.to_i)
+      end
+
+      def bitwise_and(other)
+        ::Code::Object::Integer.new(raw & other.raw.to_i)
+      end
+
+      def bitwise_or(other)
+        ::Code::Object::Integer.new(raw | other.raw.to_i)
       end
 
-      def comparaison(operator, arguments)
-        sig(arguments, ::Code::Object::Number)
-        other = arguments.first.value
-        ::Code::Object::Boolean.new(raw.public_send(operator, other.raw))
+      def bitwise_xor(other)
+        ::Code::Object::Integer.new(raw ^ other.raw.to_i)
       end
     end
   end

data/lib/code/object/list.rb

@@ -10,52 +10,60 @@ class Code
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
-        context = args.fetch(:context)
-        io = args.fetch(:io)
+        globals = args.multi_fetch(*::Code::GLOBALS)
 
         if operator == "any?"
-          any?(arguments, context: context, io: io)
+          sig(arguments, ::Code::Object::Function)
+          any?(arguments.first.value, **globals)
         elsif operator == "none?"
-          none?(arguments, context: context, io: io)
+          sig(arguments, ::Code::Object::Function)
+          none?(arguments.first.value, **globals)
         elsif operator == "detect"
-          detect(arguments, context: context, io: io)
+          sig(arguments, ::Code::Object::Function)
+          detect(arguments.first.value, **globals)
         elsif operator == "reduce"
-          reduce(arguments, context: context, io: io)
+          sig(arguments, ::Code::Object::Function)
+          reduce(arguments.first.value, **globals)
         elsif operator == "each"
-          each(arguments, context: context, io: io)
+          sig(arguments, ::Code::Object::Function)
+          each(arguments.first.value, **globals)
         elsif operator == "select"
-          select(arguments, context: context, io: io)
+          sig(arguments, ::Code::Object::Function)
+          select(arguments.first.value, **globals)
         elsif operator == "map"
-          map(arguments, context: context, io: io)
+          sig(arguments, ::Code::Object::Function)
+          map(arguments.first.value, **globals)
+        elsif operator == "max_by"
+          sig(arguments, ::Code::Object::Function)
+          max_by(arguments.first.value, **globals)
         elsif operator == "max"
-          max(arguments)
+          sig(arguments)
+          max
         elsif operator == "flatten"
-          flatten(arguments)
+          sig(arguments)
+          flatten
         elsif operator == "reverse"
-          reverse(arguments)
+          sig(arguments)
+          reverse
         elsif operator == "first"
-          first(arguments)
+          sig(arguments)
+          first
         elsif operator == "last"
-          last(arguments)
-        elsif operator == "max_by"
-          max_by(arguments, context: context, io: io)
+          sig(arguments)
+          last
         elsif operator == "<<"
-          append(arguments)
+          sig(arguments, ::Code::Object)
+          append(arguments.first.value)
         else
           super
         end
       end
 
-      def <<(element)
-        raw << element
-      end
-
-      def flatten(arguments)
-        sig(arguments)
+      def flatten
         ::Code::Object::List.new(
           raw.reduce([]) do |acc, element|
             if element.is_a?(::Code::Object::List)
-              acc + element.flatten(arguments).raw
+              acc + element.flatten.raw
             else
               acc + [element]
             end
@@ -77,144 +85,109 @@ class Code
 
       private
 
-      def any?(arguments, context:, io:)
-        sig(arguments, ::Code::Object::Function)
-        argument = arguments.first
+      def any?(argument, **globals)
         ::Code::Object::Boolean.new(
           raw.any? do |element|
-            argument
-              .value
-              .call(
-                arguments: [::Code::Object::Argument.new(element)],
-                context: context,
-                io: io,
-              )
-              .truthy?
+            argument.call(
+              arguments: [::Code::Object::Argument.new(element)],
+              **globals,
+            ).truthy?
           end,
         )
       end
 
-      def none?(arguments, context:, io:)
-        sig(arguments, ::Code::Object::Function)
-        argument = arguments.first
+      def none?(argument, **globals)
         ::Code::Object::Boolean.new(
           raw.none? do |element|
-            argument
-              .value
-              .call(
-                arguments: [::Code::Object::Argument.new(element)],
-                context: context,
-                io: io,
-              )
-              .truthy?
+            argument.call(
+              arguments: [::Code::Object::Argument.new(element)],
+              **globals,
+            ).truthy?
           end,
         )
       end
 
-      def max_by(arguments, context:, io:)
-        sig(arguments, ::Code::Object::Function)
-        argument = arguments.first.value
+      def max_by(argument, **globals)
         raw.max_by do |element|
           argument.call(
             arguments: [::Code::Object::Argument.new(element)],
-            context: context,
-            io: io,
+            **globals,
           )
         end || ::Code::Object::Nothing.new
       end
 
-      def detect(arguments, context:, io:)
-        sig(arguments, ::Code::Object::Function)
-        argument = arguments.first.value
+      def detect(argument, **globals)
         raw.detect do |element|
           argument.call(
             arguments: [::Code::Object::Argument.new(element)],
-            context: context,
-            io: io,
+            **globals,
           ).truthy?
         end || ::Code::Object::Nothing.new
       end
 
-      def reduce(arguments, context:, io:)
-        sig(arguments, ::Code::Object::Function)
-        argument = arguments.first.value
+      def reduce(argument, **globals)
         raw.reduce do |acc, element|
           argument.call(
             arguments: [
               ::Code::Object::Argument.new(acc),
               ::Code::Object::Argument.new(element),
             ],
-            context: context,
-            io: io,
+            **globals,
           )
         end || ::Code::Object::Nothing.new
       end
 
-      def each(arguments, context:, io:)
-        sig(arguments, ::Code::Object::Function)
-        argument = arguments.first.value
+      def each(argument, **globals)
         raw.each do |element|
           argument.call(
             arguments: [::Code::Object::Argument.new(element)],
-            context: context,
-            io: io,
+            **globals,
           )
         end
         self
       end
 
-      def select(arguments, context:, io:)
-        sig(arguments, ::Code::Object::Function)
-        argument = arguments.first.value
+      def select(argument, **globals)
         ::Code::Object::List.new(
           raw.select do |element|
             argument.call(
               arguments: [::Code::Object::Argument.new(element)],
-              context: context,
-              io: io,
+              **globals,
             ).truthy?
           end,
         )
       end
 
-      def map(arguments, context:, io:)
-        sig(arguments, ::Code::Object::Function)
-        argument = arguments.first.value
+      def map(argument, context:, io:)
         ::Code::Object::List.new(
           raw.map do |element|
             argument.call(
               arguments: [::Code::Object::Argument.new(element)],
-              context: context,
-              io: io,
+              **globals,
             )
           end,
         )
       end
 
-      def append(arguments)
-        sig(arguments, ::Code::Object)
-        raw << arguments.first.value
+      def append(other)
+        raw << other
         self
       end
 
-      def first(arguments)
-        sig(arguments)
-        raw.first
+      def first
+        raw.first || ::Code::Object::Nothing.new
       end
 
-      def max(arguments)
-        sig(arguments)
+      def max
         raw.max || ::Code::Object::Nothing.new
       end
 
-      def reverse(arguments)
-        sig(arguments)
+      def reverse
         ::Code::Object::List.new(raw.reverse)
       end
 
-      def last(arguments)
-        sig(arguments)
-        raw.last
+      def last
+        raw.last || ::Code::Object::Nothing.new
       end
     end
   end

data/lib/code/object/range.rb

@@ -13,27 +13,35 @@ class Code
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
-        context = args.fetch(:context)
-        io = args.fetch(:io)
+        globals = args.multi_fetch(*::Code::GLOBALS)
 
         if operator == "any?"
-          any?(arguments, context: context, io: io)
+          sig(arguments, ::Code::Object::Function)
+          any?(arguments.first.value, **globals)
         elsif operator == "all?"
-          all?(arguments, context: context, io: io)
+          sig(arguments, ::Code::Object::Function)
+          all?(arguments.first.value, **globals)
         elsif operator == "each"
-          each(arguments, context: context, io: io)
+          sig(arguments, ::Code::Object::Function)
+          each(arguments.first.value, **globals)
         elsif operator == "select"
-          select(arguments, context: context, io: io)
+          sig(arguments, ::Code::Object::Function)
+          select(arguments.first.value, **globals)
         elsif operator == "map"
-          map(arguments, context: context, io: io)
+          sig(arguments, ::Code::Object::Function)
+          map(arguments.first.value, **globals)
         elsif operator == "step"
-          step(arguments)
+          sig(arguments, ::Code::Object::Number)
+          step(arguments.first.value)
         elsif operator == "to_list"
-          to_list(arguments)
+          sig(arguments)
+          to_list
         elsif operator == "first"
-          first(arguments)
+          sig(arguments)
+          first
         elsif operator == "last"
-          last(arguments)
+          sig(arguments)
+          last
         else
           super
         end
@@ -49,79 +57,61 @@ class Code
 
       private
 
-      def any?(arguments, context:, io:)
-        sig(arguments, ::Code::Object::Function)
-        argument = arguments.first.value
+      def any?(argument, **globals)
         ::Code::Object::Boolean.new(
           raw.any? do |element|
             argument.call(
               arguments: [::Code::Object::Argument.new(element)],
-              context: context,
-              io: io,
+              **globals
             ).truthy?
           end,
         )
       end
 
-      def all?(arguments, context:, io:)
-        sig(arguments, ::Code::Object::Function)
-        argument = arguments.first.value
+      def all?(argument, **globals)
         ::Code::Object::Boolean.new(
           raw.all? do |element|
             argument.call(
               arguments: [::Code::Object::Argument.new(element)],
-              context: context,
-              io: io,
+              **globals
             ).truthy?
           end,
         )
       end
 
-      def each(arguments, context:, io:)
-        sig(arguments, ::Code::Object::Function)
-        argument = arguments.first.value
+      def each(argument, **globals)
         raw.each do |element|
           argument.call(
             arguments: [::Code::Object::Argument.new(element)],
-            context: context,
-            io: io,
+            **globals
           )
         end
         self
       end
 
-      def select(arguments, context:, io:)
-        sig(arguments, ::Code::Object::Function)
-        argument = arguments.first.value
+      def select(argument, **globals)
         ::Code::Object::List.new(
           raw.select do |element|
             argument.call(
               arguments: [::Code::Object::Argument.new(element)],
-              context: context,
-              io: io,
+              **globals
             ).truthy?
           end,
         )
       end
 
-      def map(arguments, context:, io:)
-        sig(arguments, ::Code::Object::Function)
-        argument = arguments.first.value
+      def map(argument, **globals)
         ::Code::Object::List.new(
           raw.map do |element|
             argument.call(
               arguments: [::Code::Object::Argument.new(element)],
-              context: context,
-              io: io,
+              **globals
             )
           end,
         )
       end
 
-      def step(arguments)
-        sig(arguments, ::Code::Object::Number)
-        argument = arguments.first.value
-
+      def step(argument)
         list = ::Code::Object::List.new
         element = @left
         list << element
@@ -139,18 +129,15 @@ class Code
         list
       end
 
-      def to_list(arguments)
-        sig(arguments)
+      def to_list
         ::Code::Object::List.new(raw.to_a)
       end
 
-      def first(arguments)
-        sig(arguments)
+      def first
         raw.first
       end
 
-      def last(arguments)
-        sig(arguments)
+      def last
         raw.last
       end
     end

data/lib/code/object/ruby_function.rb

@@ -0,0 +1,25 @@
+class Code
+  class Object
+    class RubyFunction < ::Code::Object::Function
+      attr_reader :raw
+
+      def initialize(raw)
+        @raw = raw
+      end
+
+      private
+
+      def call_function(args:, globals:)
+        regular_arguments = args.select(&:regular?).map(&:value).map do |argument|
+          ::Code::Ruby.from_code(argument)
+        end
+
+        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
+    end
+  end
+end

data/lib/code/object/string.rb

@@ -10,15 +10,20 @@ class Code
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
+        globals = args.multi_fetch(*::Code::GLOBALS)
 
         if operator == "to_function"
-          to_function(arguments)
+          sig(arguments)
+          to_function(**globals)
         elsif operator == "+"
-          plus(arguments)
+          sig(arguments, ::Code::Object)
+          plus(arguments.first.value)
         elsif operator == "*"
-          multiplication(arguments)
+          sig(arguments, ::Code::Object::Number)
+          multiplication(arguments.first.value)
         elsif operator == "reverse"
-          reverse(arguments)
+          sig(arguments)
+          reverse
         else
           super
         end
@@ -42,25 +47,30 @@ class Code
 
       private
 
-      def to_function(arguments)
-        sig(arguments)
-        Code.evaluate("(_) => { _.#{raw} }")
+      def to_function(**globals)
+        ::Code::Node::Code.new(
+          [
+            {
+              function: {
+                arguments: [{ regular: { name: "_" } }],
+                body: [
+                  { call: { left: { name: "_" }, right: [{ name: raw }] } },
+                ],
+              },
+            },
+          ],
+        ).evaluate(**globals)
       end
 
-      def plus(arguments)
-        sig(arguments, ::Code::Object)
-        other = arguments.first.value
+      def plus(other)
         ::Code::Object::String.new(raw + other.to_s)
       end
 
-      def multiplication(arguments)
-        sig(arguments, ::Code::Object::Number)
-        other = arguments.first.value
+      def multiplication(other)
         ::Code::Object::String.new(raw * other.raw)
       end
 
-      def reverse(arguments)
-        sig(arguments)
+      def reverse
         ::Code::Object::String.new(raw.reverse)
       end
     end