language-ruby 0.5.6 → 0.6.1

data/lib/code/object/function.rb

@@ -1,64 +0,0 @@
-class Code
-  class Object
-    class Function < ::Code::Object
-      def initialize(parameters:, body:)
-        @parameters = parameters
-        @body = body
-      end
-
-      def call(**args)
-        operator = args.fetch(:operator, nil)
-        arguments = args.fetch(:arguments, [])
-        globals = multi_fetch(args, *::Code::GLOBALS)
-
-        if operator.nil? || operator == "call"
-          call_function(args: arguments, globals: globals)
-        else
-          super
-        end
-      end
-
-      def to_s
-        ""
-      end
-
-      def inspect
-        "function"
-      end
-
-      private
-
-      attr_reader :parameters, :body
-
-      def call_function(args:, globals:)
-        new_context = deep_dup(globals[:context])
-
-        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 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 = parameter.evaluate(**globals) if arg.nil?
-              new_context[parameter.name] = arg
-            end
-          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)
-      end
-    end
-  end
-end

data/lib/code/object/global.rb

@@ -1,42 +0,0 @@
-class Code
-  class Object
-    class Global < ::Code::Object
-      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 == "print"
-          io.print(*arguments.map(&:value))
-          ::Code::Object::Nothing.new
-        elsif operator == "puts"
-          io.puts(*arguments.map(&:value))
-          ::Code::Object::Nothing.new
-        elsif operator == "context"
-          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]
-
-          if result && result.is_a?(::Code::Object::Function)
-            result.call(**args.merge(operator: nil))
-          elsif result
-            result
-          else
-            raise ::Code::Error::Undefined.new("#{operator} is not defined")
-          end
-        end
-      end
-
-      def to_s
-        "global"
-      end
-    end
-  end
-end

data/lib/code/object/integer.rb

@@ -1,221 +0,0 @@
-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

@@ -1,207 +0,0 @@
-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)
-        elsif operator == "include?"
-          sig(arguments) { ::Code::Object }
-          include?(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 include?(other)
-        ::Code::Object::Boolean.new(raw.include?(other))
-      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

@@ -1,23 +0,0 @@
-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

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

data/lib/code/object/range.rb

@@ -1,146 +0,0 @@
-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