campa 0.1.0

data/lib/campa/language.rb

@@ -0,0 +1,33 @@
+module Campa
+  class Language < Lisp::Core
+    def initialize
+      super
+      load_core_funs
+      load_core_files
+    end
+
+    private
+
+    FUNS = {
+      "tests-run": Core::Test.new,
+      "tests-report": Core::TestReport.new,
+
+      "print": Core::Print.new,
+      "println": Core::PrintLn.new,
+    }.freeze
+
+    FILES = [
+      "../campa/core.cmp",
+      "../campa/test.cmp",
+    ].freeze
+
+    def load_core_funs
+      FUNS.each { |label, fun| self[Symbol.new(label.to_s)] = fun }
+    end
+
+    def load_core_files
+      loader = Campa::Core::Load.new
+      FILES.each { |f| loader.call(Campa.root.join(f), env: self) }
+    end
+  end
+end

data/lib/campa/lisp/atom.rb

@@ -0,0 +1,14 @@
+module Campa
+  module Lisp
+    class Atom
+      def call(expression)
+        case expression
+        when Symbol, Numeric, TrueClass, FalseClass, String
+          true
+        when List
+          expression == List::EMPTY
+        end
+      end
+    end
+  end
+end

data/lib/campa/lisp/cadr.rb

@@ -0,0 +1,41 @@
+module Campa
+  module Lisp
+    class Cadr
+      def initialize
+        @printer = Printer.new
+        @car = Car.new
+        @cdr = Cdr.new
+      end
+
+      def macro?
+        true
+      end
+
+      def call(operation, list)
+        return nil if list.nil? || list == List::EMPTY
+        raise illegal_argument(list) if !list.is_a?(List)
+
+        cut_list(
+          list,
+          operation
+            .label[1..-2]
+            .reverse
+            .split("")
+        )
+      end
+
+      private
+
+      def illegal_argument(list)
+        Error::IllegalArgument.new(@printer.call(list), "list")
+      end
+
+      def cut_list(list, invocation_sequence)
+        invocation_sequence.reduce(list) do |l, oper|
+          to_call = oper == "a" ? @car : @cdr
+          to_call.call(l)
+        end
+      end
+    end
+  end
+end

data/lib/campa/lisp/car.rb

@@ -0,0 +1,22 @@
+module Campa
+  module Lisp
+    class Car
+      def initialize
+        @printer = Printer.new
+      end
+
+      def call(list)
+        return nil if list.nil? || list == List::EMPTY
+        raise illegal_argument(list) if !list.is_a?(List)
+
+        list.head
+      end
+
+      private
+
+      def illegal_argument(list)
+        Error::IllegalArgument.new(@printer.call(list), "list")
+      end
+    end
+  end
+end

data/lib/campa/lisp/cdr.rb

@@ -0,0 +1,22 @@
+module Campa
+  module Lisp
+    class Cdr
+      def initialize
+        @printer = Printer.new
+      end
+
+      def call(list)
+        return nil if list.nil? || list == List::EMPTY
+        raise illegal_argument(list) if !list.is_a?(List)
+
+        list.tail
+      end
+
+      private
+
+      def illegal_argument(list)
+        Error::IllegalArgument.new(@printer.call(list), "list")
+      end
+    end
+  end
+end

data/lib/campa/lisp/cond.rb

@@ -0,0 +1,50 @@
+module Campa
+  module Lisp
+    class Cond
+      FALSEY = [false, nil].freeze
+
+      def initialize
+        @printer = Printer.new
+        @evaler = Evaler.new
+      end
+
+      def macro?
+        true
+      end
+
+      def call(*conditions, env:)
+        found = conditions.find do |cond|
+          raise illegal_argument(cond) if !cond.is_a?(List)
+
+          !FALSEY.include? evaler.call(cond.head, env)
+        end
+
+        eval_result(found, env)
+      end
+
+      private
+
+      attr_reader :evaler, :printer
+
+      def illegal_argument(thing)
+        Error::IllegalArgument.new(printer.call(thing), "list")
+      end
+
+      def eval_result(found, env)
+        return if found.nil?
+
+        # For when condition is a "truethy" value
+        #
+        # (cond
+        #   ((eq 1 2) 'no)
+        #   (true 'yes)
+        # )
+        # => 'yes
+        to_eval = found.tail == List::EMPTY ? [found.head] : found.tail.to_a
+        to_eval.reduce(nil) do |_, expr|
+          evaler.call(expr, env)
+        end
+      end
+    end
+  end
+end

data/lib/campa/lisp/cons.rb

@@ -0,0 +1,23 @@
+module Campa
+  module Lisp
+    class Cons
+      def initialize
+        @printer = Printer.new
+      end
+
+      def call(new_head, list)
+        raise illegal_argument(list) if !list.is_a?(List)
+
+        list.push(new_head)
+      end
+
+      private
+
+      attr_reader :printer
+
+      def illegal_argument(list)
+        Error::IllegalArgument.new(printer.call(list), "list")
+      end
+    end
+  end
+end

data/lib/campa/lisp/core.rb

@@ -0,0 +1,35 @@
+module Campa
+  module Lisp
+    class Core < Context
+      CORE_FUNCS_MAP = {
+        "quote" => Quote,
+        "atom" => Atom,
+        "eq" => Eq,
+        "car" => Car,
+        "cdr" => Cdr,
+        "cons" => Cons,
+        "cond" => Cond,
+        "lambda" => LambdaFn,
+        "label" => Label,
+        "defun" => Defun,
+
+        "_cadr" => Cadr,
+        "list" => ListFn,
+
+        "load" => Campa::Core::Load,
+      }.freeze
+
+      def initialize
+        super Hash[
+          CORE_FUNCS_MAP.map { |label, handler| [sym(label), handler.new] }
+        ]
+      end
+
+      private
+
+      def sym(label)
+        Campa::Symbol.new(label)
+      end
+    end
+  end
+end

data/lib/campa/lisp/defun.rb

@@ -0,0 +1,36 @@
+module Campa
+  module Lisp
+    class Defun
+      def initialize
+        @printer = Printer.new
+        @label_fn = Label.new
+      end
+
+      def macro?
+        true
+      end
+
+      def call(label, params, *body, env:)
+        raise label_error(label) if !label.is_a?(Symbol)
+
+        label_fn.call(
+          label,
+          invoke_lambda(params, body),
+          env: env
+        )
+      end
+
+      private
+
+      attr_reader :printer, :label_fn
+
+      def label_error(given)
+        Error::IllegalArgument.new(printer.call(given), "symbol")
+      end
+
+      def invoke_lambda(params, body)
+        List.new(SYMBOL_LAMBDA, params, *body)
+      end
+    end
+  end
+end

data/lib/campa/lisp/eq.rb

@@ -0,0 +1,9 @@
+module Campa
+  module Lisp
+    class Eq
+      def call(expr_a, expr_b)
+        expr_a == expr_b
+      end
+    end
+  end
+end

data/lib/campa/lisp/label.rb

@@ -0,0 +1,29 @@
+module Campa
+  module Lisp
+    class Label
+      def initialize
+        @evaler = Evaler.new
+        @printer = Printer.new
+      end
+
+      def macro?
+        true
+      end
+
+      def call(label, expression, env:)
+        result = evaler.call(expression, env)
+        raise Error::Reserved, printer.call(label) if reserved?(label, result)
+
+        env[label] = result
+      end
+
+      private
+
+      attr_reader :evaler, :printer
+
+      def reserved?(symbol, result)
+        symbol.label.match?(CR_REGEX) && result.is_a?(Lambda)
+      end
+    end
+  end
+end

data/lib/campa/lisp/lambda_fn.rb

@@ -0,0 +1,33 @@
+module Campa
+  module Lisp
+    class LambdaFn
+      def initialize
+        @printer = Printer.new
+      end
+
+      def macro?
+        true
+      end
+
+      def call(params, *body, env:)
+        raise parameters_error(printer.call(params)) if !params.respond_to?(:find)
+
+        validate_params(params)
+        Lambda.new(params, body, env)
+      end
+
+      private
+
+      attr_reader :printer
+
+      def parameters_error(param, expected = "list of symbols")
+        Error::Parameters.new(param, expected)
+      end
+
+      def validate_params(params)
+        invalid_param = params.find { |el| !el.is_a?(Symbol) }
+        raise parameters_error(invalid_param, "symbol") if !invalid_param.nil?
+      end
+    end
+  end
+end

data/lib/campa/lisp/list_fn.rb

@@ -0,0 +1,9 @@
+module Campa
+  module Lisp
+    class ListFn
+      def call(*items)
+        List.new(*items)
+      end
+    end
+  end
+end

data/lib/campa/lisp/quote.rb

@@ -0,0 +1,13 @@
+module Campa
+  module Lisp
+    class Quote
+      def macro?
+        true
+      end
+
+      def call(expression)
+        expression
+      end
+    end
+  end
+end

data/lib/campa/list.rb

@@ -0,0 +1,83 @@
+module Campa
+  class List
+    include Enumerable
+
+    EMPTY = new
+
+    def initialize(*elements)
+      @first = nil
+      @head = nil
+      @tail = EMPTY
+
+      with elements
+    end
+
+    def push(element)
+      self.class.new.tap do |l|
+        l.first = Node.new(value: element, next_node: first)
+      end
+    end
+
+    def head
+      return nil if self == EMPTY
+
+      first.value
+    end
+
+    def tail
+      return EMPTY if first.nil? || first.next_node.nil?
+
+      self.class.new.tap { |l| l.first = @first.next_node }
+    end
+
+    def each(&block)
+      return if self == EMPTY
+
+      block.call(head)
+      tail.each(&block) if tail != EMPTY
+    end
+
+    def ==(other)
+      return false if !other.is_a?(List)
+
+      node = first
+      other_node = other.first
+
+      loop do
+        # If both node and other_node are nil
+        # we managed to walk the whole list.
+        # Since there was no early return (with false)
+        # this means all nodes are equal.
+        return node.nil? if other_node.nil?
+        return false if node != other_node
+
+        node = node.next_node
+        other_node = other_node.next_node
+      end
+    end
+
+    def inspect
+      @printer ||= Printer.new
+      @printer.call(self)
+    end
+
+    protected
+
+    attr_accessor :first
+
+    private
+
+    def with(elements)
+      return if elements.empty?
+
+      elements.reduce(nil) do |previous, current|
+        new_node = Node.new(value: current)
+        if previous.nil?
+          self.first = new_node
+        else
+          previous.next_node = new_node
+        end
+      end
+    end
+  end
+end