code-ruby 0.3.1 → 0.5.0

data/lib/code/object/list.rb

@@ -10,56 +10,65 @@ class Code
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
-        context = args.fetch(:context)
-        io = args.fetch(:io)
+        globals = multi_fetch(args, *::Code::GLOBALS)
+        value = arguments.first&.value
 
         if operator == "any?"
-          any?(arguments, context: context, io: io)
+          sig(arguments) { ::Code::Object::Function }
+          any?(value, **globals)
         elsif operator == "none?"
-          none?(arguments, context: context, io: io)
+          sig(arguments) { ::Code::Object::Function }
+          none?(value, **globals)
         elsif operator == "detect"
-          detect(arguments, context: context, io: io)
+          sig(arguments) { ::Code::Object::Function }
+          detect(value, **globals)
         elsif operator == "reduce"
-          reduce(arguments, context: context, io: io)
+          sig(arguments) { ::Code::Object::Function }
+          reduce(value, **globals)
         elsif operator == "each"
-          each(arguments, context: context, io: io)
+          sig(arguments) { ::Code::Object::Function }
+          each(value, **globals)
         elsif operator == "select"
-          select(arguments, context: context, io: io)
+          sig(arguments) { ::Code::Object::Function }
+          select(value, **globals)
         elsif operator == "map"
-          map(arguments, context: context, io: io)
+          sig(arguments) { ::Code::Object::Function }
+          map(value, **globals)
+        elsif operator == "max_by"
+          sig(arguments) { ::Code::Object::Function }
+          max_by(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(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
-          end,
+          end
         )
       end
 
@@ -67,6 +76,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
@@ -77,144 +91,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?
-          end,
+            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?
-          end,
+            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),
+              ::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
         )
       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
         )
       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,36 @@ class Code
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
-        context = args.fetch(:context)
-        io = args.fetch(:io)
+        globals = multi_fetch(args, *::Code::GLOBALS)
+        value = arguments.first&.value
 
         if operator == "any?"
-          any?(arguments, context: context, io: io)
+          sig(arguments) { ::Code::Object::Function }
+          any?(value, **globals)
         elsif operator == "all?"
-          all?(arguments, context: context, io: io)
+          sig(arguments) { ::Code::Object::Function }
+          all?(value, **globals)
         elsif operator == "each"
-          each(arguments, context: context, io: io)
+          sig(arguments) { ::Code::Object::Function }
+          each(value, **globals)
         elsif operator == "select"
-          select(arguments, context: context, io: io)
+          sig(arguments) { ::Code::Object::Function }
+          select(value, **globals)
         elsif operator == "map"
-          map(arguments, context: context, io: io)
+          sig(arguments) { ::Code::Object::Function }
+          map(value, **globals)
         elsif operator == "step"
-          step(arguments)
+          sig(arguments) { ::Code::Object::Number }
+          step(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 +58,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
         )
       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
         )
       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
         )
       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
         )
       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 +130,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,31 @@
+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 { |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
+
+        ::Code::Ruby.to_code(raw.call(*regular_arguments, **keyword_arguments))
+      end
+    end
+  end
+end

data/lib/code/object/string.rb

@@ -10,15 +10,21 @@ 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 == "to_function"
-          to_function(arguments)
+        if operator == "&" || operator == "to_function"
+          sig(arguments)
+          to_function(**globals)
         elsif operator == "+"
-          plus(arguments)
+          sig(arguments) { ::Code::Object }
+          plus(value)
         elsif operator == "*"
-          multiplication(arguments)
+          sig(arguments) { ::Code::Object::Number }
+          multiplication(value)
         elsif operator == "reverse"
-          reverse(arguments)
+          sig(arguments)
+          reverse
         else
           super
         end
@@ -42,25 +48,39 @@ class Code
 
       private
 
-      def to_function(arguments)
-        sig(arguments)
-        Code.evaluate("(_) => { _.#{raw} }")
+      def to_function(**globals)
+        ::Code::Node::Code.new(
+          [
+            {
+              function: {
+                parameters: [{ name: "_" }],
+                body: [
+                  {
+                    chained_call: {
+                      first: {
+                        call: {
+                          name: "_"
+                        }
+                      },
+                      others: [{ call: { 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