language-ruby 0.5.0

data/lib/code/object/integer.rb

@@ -0,0 +1,221 @@
+class Code
+  class Object
+    class Integer < ::Code::Object::Number
+      attr_reader :raw
+
+      def initialize(whole, exponent: nil)
+        @raw = whole.to_i
+
+        if exponent
+          if exponent.is_a?(::Code::Object::Number)
+            @raw = @raw * 10**exponent.raw
+          else
+            raise ::Code::Error::TypeError.new("exponent is not a number")
+          end
+        end
+      end
+
+      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(value)
+        elsif operator == "/"
+          sig(arguments) { ::Code::Object::Number }
+          division(value)
+        elsif operator == "+"
+          if value
+            sig(arguments) { ::Code::Object }
+            plus(value)
+          else
+            sig(arguments)
+            self
+          end
+        elsif operator == "%"
+          sig(arguments) { ::Code::Object::Number }
+          modulo(value)
+        elsif operator == "-"
+          if value
+            sig(arguments) { ::Code::Object::Number }
+            minus(value)
+          else
+            sig(arguments)
+            unary_minus
+          end
+        elsif operator == "**"
+          sig(arguments) { ::Code::Object::Number }
+          power(value)
+        elsif operator == "<"
+          sig(arguments) { ::Code::Object::Number }
+          inferior(value)
+        elsif operator == "<="
+          sig(arguments) { ::Code::Object::Number }
+          inferior_or_equal(value)
+        elsif operator == ">"
+          sig(arguments) { ::Code::Object::Number }
+          superior(value)
+        elsif operator == ">="
+          sig(arguments) { ::Code::Object::Number }
+          superior_or_equal(value)
+        elsif operator == "<<"
+          sig(arguments) { ::Code::Object::Number }
+          left_shift(value)
+        elsif operator == ">>"
+          sig(arguments) { ::Code::Object::Number }
+          right_shift(value)
+        elsif operator == "&"
+          sig(arguments) { ::Code::Object::Number }
+          bitwise_and(value)
+        elsif operator == "|"
+          sig(arguments) { ::Code::Object::Number }
+          bitwise_or(value)
+        elsif operator == "^"
+          sig(arguments) { ::Code::Object::Number }
+          bitwise_xor(value)
+        else
+          super
+        end
+      end
+
+      def succ
+        ::Code::Object::Integer.new(raw + 1)
+      end
+
+      def +(other)
+        ::Code::Object::Integer.new(raw + other.raw)
+      end
+
+      def to_s
+        raw.to_s
+      end
+
+      def inspect
+        to_s
+      end
+
+      private
+
+      def even?
+        ::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)
+        elsif other.is_a?(::Code::Object::Decimal)
+          ::Code::Object::Decimal.new(raw * other.raw)
+        else
+          ::Code::Object::String.new(other.raw * raw)
+        end
+      end
+
+      def plus(other)
+        if other.is_a?(::Code::Object::Integer)
+          ::Code::Object::Integer.new(raw + other.raw)
+        elsif other.is_a?(::Code::Object::Decimal)
+          ::Code::Object::Decimal.new(raw + other.raw)
+        else
+          ::Code::Object::String.new(to_s + other.to_s)
+        end
+      end
+
+      def division(other)
+        ::Code::Object::Decimal.new(BigDecimal(raw) / other.raw)
+      end
+
+      def modulo(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 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 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)
+        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 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

@@ -0,0 +1,200 @@
+class Code
+  class Object
+    class List < ::Code::Object
+      attr_reader :raw
+
+      def initialize(raw = [])
+        @raw = raw
+      end
+
+      def call(**args)
+        operator = args.fetch(:operator, nil)
+        arguments = args.fetch(:arguments, [])
+        globals = multi_fetch(args, *::Code::GLOBALS)
+        value = arguments.first&.value
+
+        if operator == "any?"
+          sig(arguments) { ::Code::Object::Function }
+          any?(value, **globals)
+        elsif operator == "none?"
+          sig(arguments) { ::Code::Object::Function }
+          none?(value, **globals)
+        elsif operator == "detect"
+          sig(arguments) { ::Code::Object::Function }
+          detect(value, **globals)
+        elsif operator == "reduce"
+          sig(arguments) { ::Code::Object::Function }
+          reduce(value, **globals)
+        elsif operator == "each"
+          sig(arguments) { ::Code::Object::Function }
+          each(value, **globals)
+        elsif operator == "select"
+          sig(arguments) { ::Code::Object::Function }
+          select(value, **globals)
+        elsif operator == "map"
+          sig(arguments) { ::Code::Object::Function }
+          map(value, **globals)
+        elsif operator == "max_by"
+          sig(arguments) { ::Code::Object::Function }
+          max_by(value, **globals)
+        elsif operator == "max"
+          sig(arguments)
+          max
+        elsif operator == "flatten"
+          sig(arguments)
+          flatten
+        elsif operator == "reverse"
+          sig(arguments)
+          reverse
+        elsif operator == "first"
+          sig(arguments)
+          first
+        elsif operator == "last"
+          sig(arguments)
+          last
+        elsif operator == "<<"
+          sig(arguments) { ::Code::Object }
+          append(value)
+        else
+          super
+        end
+      end
+
+      def flatten
+        ::Code::Object::List.new(
+          raw.reduce([]) do |acc, element|
+            if element.is_a?(::Code::Object::List)
+              acc + element.flatten.raw
+            else
+              acc + [element]
+            end
+          end
+        )
+      end
+
+      def deep_dup
+        ::Code::Object::List.new(raw.deep_dup)
+      end
+
+      def <<(other)
+        raw << other
+        self
+      end
+
+      def to_s
+        "[#{raw.map(&:inspect).join(", ")}]"
+      end
+
+      def inspect
+        to_s
+      end
+
+      private
+
+      def any?(argument, **globals)
+        ::Code::Object::Boolean.new(
+          raw.any? do |element|
+            argument.call(
+              arguments: [::Code::Object::Argument.new(element)],
+              **globals
+            ).truthy?
+          end
+        )
+      end
+
+      def none?(argument, **globals)
+        ::Code::Object::Boolean.new(
+          raw.none? do |element|
+            argument.call(
+              arguments: [::Code::Object::Argument.new(element)],
+              **globals
+            ).truthy?
+          end
+        )
+      end
+
+      def max_by(argument, **globals)
+        raw.max_by do |element|
+          argument.call(
+            arguments: [::Code::Object::Argument.new(element)],
+            **globals
+          )
+        end || ::Code::Object::Nothing.new
+      end
+
+      def detect(argument, **globals)
+        raw.detect do |element|
+          argument.call(
+            arguments: [::Code::Object::Argument.new(element)],
+            **globals
+          ).truthy?
+        end || ::Code::Object::Nothing.new
+      end
+
+      def reduce(argument, **globals)
+        raw.reduce do |acc, element|
+          argument.call(
+            arguments: [
+              ::Code::Object::Argument.new(acc),
+              ::Code::Object::Argument.new(element)
+            ],
+            **globals
+          )
+        end || ::Code::Object::Nothing.new
+      end
+
+      def each(argument, **globals)
+        raw.each do |element|
+          argument.call(
+            arguments: [::Code::Object::Argument.new(element)],
+            **globals
+          )
+        end
+        self
+      end
+
+      def select(argument, **globals)
+        ::Code::Object::List.new(
+          raw.select do |element|
+            argument.call(
+              arguments: [::Code::Object::Argument.new(element)],
+              **globals
+            ).truthy?
+          end
+        )
+      end
+
+      def map(argument, **globals)
+        ::Code::Object::List.new(
+          raw.map do |element|
+            argument.call(
+              arguments: [::Code::Object::Argument.new(element)],
+              **globals
+            )
+          end
+        )
+      end
+
+      def append(other)
+        raw << other
+        self
+      end
+
+      def first
+        raw.first || ::Code::Object::Nothing.new
+      end
+
+      def max
+        raw.max || ::Code::Object::Nothing.new
+      end
+
+      def reverse
+        ::Code::Object::List.new(raw.reverse)
+      end
+
+      def last
+        raw.last || ::Code::Object::Nothing.new
+      end
+    end
+  end
+end

data/lib/code/object/nothing.rb

@@ -0,0 +1,23 @@
+class Code
+  class Object
+    class Nothing < ::Code::Object
+      attr_reader :raw
+
+      def initialize
+        @raw = nil
+      end
+
+      def truthy?
+        false
+      end
+
+      def to_s
+        ""
+      end
+
+      def inspect
+        "nothing"
+      end
+    end
+  end
+end

data/lib/code/object/number.rb

@@ -0,0 +1,6 @@
+class Code
+  class Object
+    class Number < ::Code::Object
+    end
+  end
+end

data/lib/code/object/range.rb

@@ -0,0 +1,146 @@
+class Code
+  class Object
+    class Range < ::Code::Object
+      attr_reader :raw
+
+      def initialize(left, right, exclude_end: false)
+        @left = left
+        @right = right
+        @exclude_end = exclude_end
+        @raw = ::Range.new(left, right, exclude_end)
+      end
+
+      def call(**args)
+        operator = args.fetch(:operator, nil)
+        arguments = args.fetch(:arguments, [])
+        globals = multi_fetch(args, *::Code::GLOBALS)
+        value = arguments.first&.value
+
+        if operator == "any?"
+          sig(arguments) { ::Code::Object::Function }
+          any?(value, **globals)
+        elsif operator == "all?"
+          sig(arguments) { ::Code::Object::Function }
+          all?(value, **globals)
+        elsif operator == "each"
+          sig(arguments) { ::Code::Object::Function }
+          each(value, **globals)
+        elsif operator == "select"
+          sig(arguments) { ::Code::Object::Function }
+          select(value, **globals)
+        elsif operator == "map"
+          sig(arguments) { ::Code::Object::Function }
+          map(value, **globals)
+        elsif operator == "step"
+          sig(arguments) { ::Code::Object::Number }
+          step(value)
+        elsif operator == "to_list"
+          sig(arguments)
+          to_list
+        elsif operator == "first"
+          sig(arguments)
+          first
+        elsif operator == "last"
+          sig(arguments)
+          last
+        else
+          super
+        end
+      end
+
+      def to_s
+        raw.to_s
+      end
+
+      def inspect
+        to_s
+      end
+
+      private
+
+      def any?(argument, **globals)
+        ::Code::Object::Boolean.new(
+          raw.any? do |element|
+            argument.call(
+              arguments: [::Code::Object::Argument.new(element)],
+              **globals
+            ).truthy?
+          end
+        )
+      end
+
+      def all?(argument, **globals)
+        ::Code::Object::Boolean.new(
+          raw.all? do |element|
+            argument.call(
+              arguments: [::Code::Object::Argument.new(element)],
+              **globals
+            ).truthy?
+          end
+        )
+      end
+
+      def each(argument, **globals)
+        raw.each do |element|
+          argument.call(
+            arguments: [::Code::Object::Argument.new(element)],
+            **globals
+          )
+        end
+        self
+      end
+
+      def select(argument, **globals)
+        ::Code::Object::List.new(
+          raw.select do |element|
+            argument.call(
+              arguments: [::Code::Object::Argument.new(element)],
+              **globals
+            ).truthy?
+          end
+        )
+      end
+
+      def map(argument, **globals)
+        ::Code::Object::List.new(
+          raw.map do |element|
+            argument.call(
+              arguments: [::Code::Object::Argument.new(element)],
+              **globals
+            )
+          end
+        )
+      end
+
+      def step(argument)
+        list = ::Code::Object::List.new
+        element = @left
+        list << element
+
+        if @exlucde_end
+          while (element = element + argument) < @right
+            list << element
+          end
+        else
+          while (element = element + argument) <= @right
+            list << element
+          end
+        end
+
+        list
+      end
+
+      def to_list
+        ::Code::Object::List.new(raw.to_a)
+      end
+
+      def first
+        raw.first
+      end
+
+      def last
+        raw.last
+      end
+    end
+  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

@@ -0,0 +1,88 @@
+class Code
+  class Object
+    class String < ::Code::Object
+      attr_reader :raw
+
+      def initialize(string)
+        @raw = string
+      end
+
+      def call(**args)
+        operator = args.fetch(:operator, nil)
+        arguments = args.fetch(:arguments, [])
+        globals = multi_fetch(args, *::Code::GLOBALS)
+        value = arguments.first&.value
+
+        if operator == "&" || operator == "to_function"
+          sig(arguments)
+          to_function(**globals)
+        elsif operator == "+"
+          sig(arguments) { ::Code::Object }
+          plus(value)
+        elsif operator == "*"
+          sig(arguments) { ::Code::Object::Number }
+          multiplication(value)
+        elsif operator == "reverse"
+          sig(arguments)
+          reverse
+        else
+          super
+        end
+      end
+
+      def succ
+        ::Code::Object::String.new(raw.succ)
+      end
+
+      def to_sym
+        raw.to_sym
+      end
+
+      def to_s
+        raw
+      end
+
+      def inspect
+        raw.inspect
+      end
+
+      private
+
+      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(other)
+        ::Code::Object::String.new(raw + other.to_s)
+      end
+
+      def multiplication(other)
+        ::Code::Object::String.new(raw * other.raw)
+      end
+
+      def reverse
+        ::Code::Object::String.new(raw.reverse)
+      end
+    end
+  end
+end