code-ruby 1.1.1 → 1.2.1

data/lib/code/object/list.rb

@@ -4,81 +4,86 @@ class Code
   class Object
     class List < Object
       def initialize(*args, **_kargs, &)
-        raw = args.first
-        raw = raw.raw if raw.is_an?(Object)
-        @raw = raw.to_a
+        @raw =
+          if args.first.is_a?(List)
+            args.first.raw.map(&:to_code)
+          elsif args.first.is_an?(::Array)
+            args.first.map(&:to_code)
+          else
+            []
+          end
       end
 
       def call(**args)
-        operator = args.fetch(:operator, nil)
-        arguments = args.fetch(:arguments, List.new)
+        code_operator = args.fetch(:operator, nil).to_code
+        code_arguments = args.fetch(:arguments, []).to_code
         globals = multi_fetch(args, *GLOBALS)
-        value = arguments.code_first
+        code_value = code_arguments.code_first
 
-        case operator.to_s
+        case code_operator.to_s
         when "join"
           sig(args) { String.maybe }
-          code_join(value)
+          code_join(code_value)
         when "sort"
           sig(args)
           code_sort
         when "<<", "append"
           sig(args) { Object }
-          code_append(value)
+          code_append(code_value)
         when "any?"
           sig(args) { Function.maybe }
-          code_any?(value, **globals)
+          code_any?(code_value, **globals)
         when "detect"
           sig(args) { Function }
-          code_detect(value, **globals)
+          code_detect(code_value, **globals)
         when "each"
           sig(args) { Function }
-          code_each(value, **globals)
+          code_each(code_value, **globals)
         when "first"
-          sig(args)
-          code_first
+          sig(args) { Integer.maybe }
+          code_first(code_value)
         when "flatten"
           sig(args) { Integer.maybe }
           code_flatten
         when "include?"
           sig(args) { Object }
-          code_include?(value)
+          code_include?(code_value)
         when "last"
           sig(args)
           code_last
         when "map"
           sig(args) { Function }
-          code_map(value, **globals)
+          code_map(code_value, **globals)
         when "map!"
           sig(args) { Function }
-          code_map!(value, **globals)
+          code_map!(code_value, **globals)
         when "max"
           sig(args)
           code_max
         when "max_by"
           sig(args) { Function }
-          code_max_by(value, **globals)
+          code_max_by(code_value, **globals)
         when "none?"
           sig(args) { Function.maybe }
-          code_none?(value, **globals)
+          code_none?(code_value, **globals)
         when "reduce"
           sig(args) { Function }
-          code_reduce(value, **globals)
+          code_reduce(code_value, **globals)
         when "reverse"
           sig(args)
           code_reverse
         when "select"
           sig(args) { Function }
-          code_select(value, **globals)
+          code_select(code_value, **globals)
         when "select!"
           sig(args) { Function }
-          code_select!(value, **globals)
+          code_select!(code_value, **globals)
         when "reject"
           sig(args) { Function }
-          code_reject(value, **globals)
+          code_reject(code_value, **globals)
         when "reject!"
           sig(args) { Function }
-          code_reject!(value, **globals)
+          code_reject!(code_value, **globals)
         when "size"
           sig(args)
           code_size
@@ -94,21 +99,22 @@ class Code
       end
 
       def code_any?(argument = nil, **globals)
-        argument ||= Nothing.new
+        code_argument = argument.to_code
+
         index = 0
 
         Boolean.new(
-          raw.any? do |element|
-            if argument.nothing?
-              element.truthy?
+          raw.any? do |code_element|
+            if code_argument.nothing?
+              true
             else
-              argument.call(
-                arguments: List.new([element, Integer.new(index), self]),
+              code_argument.call(
+                arguments: List.new([code_element, Integer.new(index), self]),
                 **globals
               ).truthy?
             end
           rescue Error::Next => e
-            e.value || Nothing.new
+            e.code_value
           ensure
             index += 1
           end
@@ -116,58 +122,75 @@ class Code
       end
 
       def code_append(other)
-        raw << other
+        code_other = other.to_code
+
+        raw << code_other
+
         self
       end
 
       def code_detect(argument, **globals)
-        raw.detect.with_index do |element, index|
-          argument.call(
-            arguments: List.new([element, Integer.new(index), self]),
+        code_argument = argument.to_code
+
+        raw.detect.with_index do |code_element, index|
+          code_argument.call(
+            arguments: List.new([code_element, Integer.new(index), self]),
             **globals
           ).truthy?
         rescue Error::Next => e
-          e.value || Nothing.new
+          e.code_value
         end || Nothing.new
       end
 
       def code_each(argument, **globals)
-        raw.each.with_index do |element, index|
-          argument.call(
-            arguments: List.new([element, Integer.new(index), self]),
+        code_argument = argument.to_code
+
+        raw.each.with_index do |code_element, index|
+          code_argument.call(
+            arguments: List.new([code_element, Integer.new(index), self]),
             **globals
           )
         rescue Error::Next => e
-          e.value || Nothing.new
+          e.code_value
         end
+
         self
       end
 
-      def code_first
-        raw.first || Nothing.new
+      def code_first(value = nil)
+        code_value = value.to_code
+
+        if code_value.nothing?
+          raw.first || Nothing.new
+        else
+          List.new(raw.first(code_value.raw))
+        end
       end
 
       def code_flatten(level = nil)
-        level = Integer.new(-1) if level.nil? || level.is_a?(Nothing)
-        level = level.raw if level.is_a?(Integer)
+        code_level = level.to_code
+        code_level = Integer.new(-1) if code_level.nothing?
+        level = code_level.raw
 
         List.new(
-          raw.reduce([]) do |acc, element|
-            if element.is_a?(List) && level != 0
+          raw.reduce([]) do |acc, code_element|
+            if code_element.is_a?(List) && level != 0
               if level.positive?
-                acc + element.code_flatten(level - 1).raw
+                acc + code_element.code_flatten(level - 1).raw
               else
-                acc + element.code_flatten(level).raw
+                acc + code_element.code_flatten(level).raw
               end
             else
-              acc + [element]
+              acc + [code_element]
             end
           end
         )
       end
 
       def code_include?(other)
-        Boolean.new(raw.include?(other))
+        code_other = other.to_code
+
+        Boolean.new(raw.include?(code_other))
       end
 
       def code_last
@@ -175,26 +198,30 @@ class Code
       end
 
       def code_map(argument, **globals)
+        code_argument = argument.to_code
+
         List.new(
-          raw.map.with_index do |element, index|
-            argument.call(
-              arguments: List.new([element, Integer.new(index), self]),
+          raw.map.with_index do |code_element, index|
+            code_argument.call(
+              arguments: List.new([code_element, Integer.new(index), self]),
               **globals
             )
           rescue Error::Next => e
-            e.value || Nothing.new
+            e.code_value
           end
         )
       end
 
       def code_map!(argument, **globals)
-        raw.map!.with_index do |element, index|
-          argument.call(
-            arguments: List.new([element, Integer.new(index), self]),
+        code_argument = argument.to_code
+
+        raw.map!.with_index do |code_element, index|
+          code_argument.call(
+            arguments: List.new([code_element, Integer.new(index), self]),
             **globals
           )
         rescue Error::Next => e
-          e.value || Nothing.new
+          e.code_value
         end
 
         self
@@ -205,32 +232,35 @@ class Code
       end
 
       def code_max_by(argument, **globals)
-        raw.max_by.with_index do |element, index|
-          argument.call(
-            arguments: List.new([element, Integer.new(index), self]),
+        code_argument = argument.to_code
+
+        raw.max_by.with_index do |code_element, index|
+          code_argument.call(
+            arguments: List.new([code_element, Integer.new(index), self]),
             **globals
           )
         rescue Error::Next => e
-          e.value || Nothing.new
+          e.code_value
         end || Nothing.new
       end
 
       def code_none?(argument = nil, **globals)
-        argument ||= Nothing.new
+        code_argument = argument.to_code
+
         index = 0
 
         Boolean.new(
-          raw.none? do |element|
-            if argument.nothing?
-              element.truthy?
+          raw.none? do |code_element|
+            if code_argument.nothing?
+              code_element.truthy?
             else
-              argument.call(
-                arguments: List.new([element, Integer.new(index), self]),
+              code_argument.call(
+                arguments: List.new([code_element, Integer.new(index), self]),
                 **globals
               ).truthy?
             end
           rescue Error::Next => e
-            (e.value || Nothing.new).truthy?
+            e.code_value.truthy?
           ensure
             index += 1
           end
@@ -238,13 +268,16 @@ class Code
       end
 
       def code_reduce(argument, **globals)
-        raw.reduce.with_index do |acc, element, index|
-          argument.call(
-            arguments: List.new([acc, element, Integer.new(index), self]),
+        code_argument = argument.to_code
+
+        raw.reduce.with_index do |code_acc, code_element, index|
+          code_argument.call(
+            arguments:
+              List.new([code_acc, code_element, Integer.new(index), self]),
             **globals
           )
         rescue Error::Next => e
-          e.value || Nothing.new
+          e.code_value
         end || Nothing.new
       end
 
@@ -253,61 +286,69 @@ class Code
       end
 
       def code_select(argument, **globals)
+        code_argument = argument.to_code
+
         List.new(
-          raw.select.with_index do |element, index|
-            argument.call(
-              arguments: List.new([element, Integer.new(index), self]),
+          raw.select.with_index do |code_element, index|
+            code_argument.call(
+              arguments: List.new([code_element, Integer.new(index), self]),
               **globals
             ).truthy?
           rescue Error::Next => e
-            (e.value || Nothing.new).truthy?
+            e.code_value.truthy?
           end
         )
       end
 
       def code_select!(argument, **globals)
-        raw.select!.with_index do |element, index|
-          argument.call(
-            arguments: List.new([element, Integer.new(index), self]),
+        code_argument = argument.to_code
+
+        raw.select!.with_index do |code_element, index|
+          code_argument.call(
+            arguments: List.new([code_element, Integer.new(index), self]),
             **globals
           ).truthy?
         rescue Error::Next => e
-          (e.value || Nothing.new).truthy?
+          e.code_value.truthy?
         end
 
         self
       end
 
       def code_reject(argument, **globals)
+        code_argument = argument.to_code
+
         List.new(
-          raw.reject.with_index do |element, index|
-            argument.call(
-              arguments: List.new([element, Integer.new(index), self]),
+          raw.reject.with_index do |code_element, index|
+            code_argument.call(
+              arguments: List.new([code_element, Integer.new(index), self]),
               **globals
             ).truthy?
           rescue Error::Next => e
-            (e.value || Nothing.new).truthy?
+            e.code_value.truthy?
           end
         )
       end
 
       def code_reject!(argument, **globals)
-        raw.reject!.with_index do |element, index|
-          argument.call(
-            arguments: List.new([element, Integer.new(index), self]),
+        code_argument = argument.to_code
+
+        raw.reject!.with_index do |code_element, index|
+          code_argument.call(
+            arguments: List.new([code_element, Integer.new(index), self]),
             **globals
           ).truthy?
         rescue Error::Next => e
-          (e.value || Nothing.new).truthy?
+          e.code_value.truthy?
         end
 
         self
       end
 
       def code_join(separator = nil)
-        separator ||= +""
+        code_separator = separator.to_s.to_code
 
-        String.new(raw.join(separator.raw))
+        String.new(raw.join(code_separator.raw))
       end
 
       def code_sort
@@ -326,7 +367,15 @@ class Code
         raw.inject(&:code_plus) || Nothing.new
       end
 
-      delegate :any?, to: :raw
+      def code_get(argument)
+        code_argument = argument.to_code
+
+        raw[code_argument] || Nothing.new
+      end
+
+      def any?
+        code_any?.truthy?
+      end
     end
   end
 end

data/lib/code/object/parameter.rb

@@ -4,35 +4,35 @@ class Code
   class Object
     class Parameter < Object
       def initialize(*args, **_kargs, &)
-        @raw = Dictionary.new(args.first.presence || {})
+        @raw = Dictionary.new(args.first)
       end
 
       def code_name
-        String.new(raw.code_get(String.new(:name)))
+        String.new(raw.code_get(:name))
       end
 
       def code_regular?
-        Boolean.new(raw.code_get(String.new(:regular?)))
+        Boolean.new(raw.code_get(:regular?))
       end
 
       def code_keyword?
-        Boolean.new(raw.code_get(String.new(:keyword?)))
+        Boolean.new(raw.code_get(:keyword?))
       end
 
       def code_regular_splat?
-        Boolean.new(raw.code_get(String.new(:regular_splat?)))
+        Boolean.new(raw.code_get(:regular_splat?))
       end
 
       def code_keyword_splat?
-        Boolean.new(raw.code_get(String.new(:keyword_splat?)))
+        Boolean.new(raw.code_get(:keyword_splat?))
       end
 
       def code_default
-        Code.new(raw.code_get(String.new(:default)))
+        Code.new(raw.code_get(:default))
       end
 
-      def evaluate(...)
-        default.evaluate(...)
+      def code_evaluate(...)
+        code_default.code_evaluate(...)
       end
 
       def regular?
@@ -50,10 +50,6 @@ class Code
       def keyword_splat?
         code_keyword_splat?.truthy?
       end
-
-      def to_h
-        raw.raw
-      end
     end
   end
 end