lasp 0.10.1 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 31657ba16b8344004fdeedb166f0be8c69d56529
-  data.tar.gz: fb32904a4b52419ccbbb7f8d38d931673e9f6df5
+  metadata.gz: 239d33a36efb77e46301fa1f4f5eab3355d95371
+  data.tar.gz: 2b63d5918420dd74b0e4e73e9b799eed3ab33113
 SHA512:
-  metadata.gz: 9eb7709cc5b98b0bea98a8c908c630e68d1ac78a1678b12e9e195021cdcf270d07a25c4bd46103d8142484dc154a572342579132896d7ae211c49d0680473f9e
-  data.tar.gz: b603eb61bd7aa5d9fdaaf3a74a5ca67383040dc5e958953a5488b16d7fc4c5a3fec7790ffe4e9a5bb1e2b8109272a32d65d16a056954eb9408cd80a2e9f1772a
+  metadata.gz: 74d78665c4fa130cb7a583c4cce512bdce06db31086f4ad889a0ef0015d60b3a84892e530236f7f21937f4663e5e6e1c5f6383f5d9af6baa6871974524074d97
+  data.tar.gz: 1a7daa286ff20db4c8b3008525c1b10edff6c61a4848f5bb2c04b97ad58cef832bfb72961765c422a761cdae26371c297e1a47d6fc1d307e2e2c943add69e1ea

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Läsp changelog
 
+## v0.11.0 - 2016-03-05
+
+### Added
+
+- Allow `require` to accept a second argument, when it is truthy it uses a path
+  relative to the file that called `require`.
+- Allow `_` to be used several times in parameter lists to ignore parameters
+- Additions to standard library
+  - `and`
+  - `or`
+
+### Changed
+
+- `require` now uses a static paths by default.
+- The `.` function has been renamed to `send`, the `.` can now instead be used
+  as a prefix to call Ruby methods, what previously looked like this: `(. obj method)`
+  now looks like this `(.method obj)`. This is equivalent to `(send :method obj)`.
+
+### Fixed
+
+- Relative paths in `require` was completely broken before this.
+- `empty?` no longer returns `true` for lists with a `nil` value at the first position.
+
+
 ## v0.10.1 - 2016-02-22
 
 ### Fixed

data/DOCUMENTATION.md

@@ -40,7 +40,7 @@ create a local binding, use [let](#let) instead.
 
 Creates a function.
 
-Parameters `(parameters body)`
+Parameters `(parameters body)`:
 
 1. A list of parameters that the function shall accept, e.g. `(arg1 arg2)`, `(one two & others)`, `(& args)`
 2. The body of the function, the declared parameters will be available in here.
@@ -49,11 +49,12 @@ Parameters `(parameters body)`
 ; This creates a function object, it can be read as "a function of x".
 (fn (x) (+ x 2)) ; => #<Fn (x)>
 
-; Functions are called when placed as the first item in a form:
+; Functions are called when placed as the first element in a form:
 ((fn (x) (+ x 2)) 40) ; => 42
 ```
 
-Most of the time, you'll want to define a function before using it (see [defn](#defn)):
+Most of the time, you'll want to define a function before using it (see
+[defn](#defn) for a nicer syntax for doing this):
 
 ```clojure
 (def plus-two (fn (x) (+ x 2)))
@@ -67,6 +68,8 @@ Functions will enforce that the correct number of arguments is passed to them:
 (plus-two 40 41) ; !> Lasp::ArgumentError: wrong number of arguments (2 for 1)
 ```
 
+#### Variadic parameter lists
+
 Functions can also accept any number of extra arguments as a list:
 
 ```clojure
@@ -84,6 +87,16 @@ Functions can also accept any number of extra arguments as a list:
 (show-args) ; !> Lasp::ArgumentError: wrong number of arguments (0 for 1+)
 ```
 
+#### Ignoring parameters
+
+Normally you get an error from naming 2 parameters the same, but if you want to
+ignore parameters, the `_` is allowed to be used several times.
+
+```clojure
+(def ignore-2 (fn (nope nope) (println "lalalala"))) ; !> Lasp::SyntaxError
+(def ignore-2 (fn (_ _)       (println "lalalala"))) ; => #<Fn (_ _)>
+```
+
 
 ### do
 
@@ -181,7 +194,8 @@ Except for the order of evaluation, macros behave just like functions and can
 accept rest-arguments etc. the same way. Just like functions, you mostly want
 to define them before you use them, see [defm](#defm).
 
-**It is important to quote things that you do not want evaluated until after the macro has returned.**
+**It is important to quote things that you do not want evaluated until after
+the macro has returned.**
 
 ```clojure
 ; Note that we want `if` to be evaluated after the macro has returned, so we have to quote it.
@@ -193,7 +207,25 @@ to define them before you use them, see [defm](#defm).
 (reverse-if true "yes" "no") ; => "no"
 ```
 
-To debug macros and see what they expand to without trying to evaluate the result, see [macroexpand](#macroexpand).
+To debug macros and see what they expand to without trying to evaluate the
+result, see [macroexpand](#macroexpand).
+
+
+### require
+
+Loads and runs a Läsp file. Paths are relative to the folder where the `lasp`
+command was invoked, or, if a second truthy parameter is passed, to the file
+where `require` is called.
+
+```clojure
+(require "lasp_file.lasp")
+(require "dir/lasp_file.lasp")
+(require "../lasp_file.lasp")
+
+; Pass a truthy second parameter to use relative paths:
+(require "lasp_file.lasp" true)
+(require "lasp_file.lasp" :relative)
+```
 
 
 ## Core library
@@ -469,18 +501,18 @@ Applies a function to a list of arguments as if they were passed in directly.
 ```
 
 
-### .
+### send
 
-Interoperability operator - calls a Ruby method.
+Calls a Ruby method on an object.
 
-Parameters `(object message & args)`:
+Parameters `(message object & args)`:
 
 1. The object to send the message to
 2. A text with the message name
 3. Any number of arguments to be passed along with the message
 
 ```clojure
-(. "01011101" :to_i 2) ; => 93
+(send :to_i "01011101" 2) ; => 93
 ```
 
 ```ruby
@@ -488,16 +520,11 @@ Parameters `(object message & args)`:
 "01011101".to_i(2)
 ```
 
-
-### require
-
-Loads and runs a Läsp file. Paths are relative to the file they are being
-required in.
+You can accomplish the same by prepending a dot to the function name, this
+makes it look very similar to a normal Läsp function call:
 
 ```clojure
-(require "lasp_file.lasp")     ; lasp_file.lasp is in the same directory as this code
-(require "dir/lasp_file.lasp") ; dir/ is a folder with a lasp file in this directory
-(require "../lasp_file.lasp")  ; lasp_file.lasp is in the parent folder
+(.upcase "hello") ; => "HELLO"
 ```
 
 
@@ -947,6 +974,49 @@ If given an uneven number of bindings, the last one will be assigned to `nil`.
 ```
 
 
+### or
+
+Evaluates its arguments in turn, returning:
+
+- the first **truthy** value it encounters
+- the last value, if all forms evaluate to logical **false**
+- `nil` if no arguments are given
+
+```clojure
+; Typical usage in if-statements
+(or (= 1 2) (= 3 3)) ; => true
+(or (= 1 2) (= 3 4)) ; => false
+
+(or)               ; => nil
+(or nil nil false) ; => false
+
+; will return without printing anything
+(or (not true) 42 (println "nope")) ; => 42
+```
+
+
+### and
+
+Evaluates its arguments in turn, returning:
+
+- the first **falsy** value it encounters
+- the last value, if all forms evaluate to logical **true**
+- `true` if no arguments are given
+
+```clojure
+; Typical usage in if-statements
+(and (= 1 1) (= 2 2)) ; => true
+(and (= 1 1) (= 2 3)) ; => false
+
+(and)               ; => nil
+(and true true 42)  ; => 42
+
+; will return without printing anything
+(and 42 false (println "nope")) ; => false
+```
+
+
+
 ### macroexpand
 
 Returns the unevaluated result of a macro, indispensable for debugging.

data/README.md

@@ -1,14 +1,17 @@
-# Läsp
+# Läsp [![Build Status](https://travis-ci.org/alcesleo/lasp.svg?branch=master)](https://travis-ci.org/alcesleo/lasp)
 
 A Lisp implementation in Ruby.
 
 ## Features
 
-- Very concise [core library](lib/lasp/corelib.rb) written in Ruby
-- [Standard library](lib/lasp/stdlib.lisp) written in Läsp itself
+- Comprehensive [documentation](DOCUMENTATION.md)
 - Interactive REPL with auto-closing of missing trailing parentheses
+- Closures
+- let-bindings
 - Fully functional macro system
 - Interoperability with Ruby
+- Very concise [core library](lib/lasp/corelib.rb) written in Ruby
+- [Standard library](lib/lasp/stdlib.lisp) written in Läsp itself
 
 ## Installation
 
@@ -75,7 +78,7 @@ Comments start with a `;` and end at the end of a line
 ### Run the specs
 
 ```bash
-rake
+bundle exec rake
 ```
 
 ### Dev REPL

data/bin/lasp

@@ -2,10 +2,9 @@
 
 require "lasp"
 require "lasp/repl"
-Lasp::load_stdlib!
 
 if ARGV.first
-  Lasp::execute_file(ARGV.first)
+  Lasp::execute_file(ARGV.first, Lasp::env_with_stdlib)
 else
   Lasp::Repl.run
 end

data/lasp.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Jimmy Börjesson"]
   spec.email         = ["lagginglion@gmail.com"]
 
-  spec.summary       = %q{A simple programming language similar to Clojure, but much worse.}
+  spec.summary       = %q{A simple Lisp-dialect programming language inspired by Clojure.}
   spec.homepage      = "https://github.com/alcesleo/lasp"
   spec.license       = "MIT"
 
@@ -20,6 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '~> 2.0'
 
-  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.4"
 end

data/lib/lasp/corelib.rb

@@ -1,5 +1,3 @@
-require "lasp"
-
 module Lasp
   CORELIB = {
     :+          => -> (*args)         { args.reduce(:+)                            },
@@ -23,7 +21,6 @@ module Lasp
     :print      => -> (*output)       { STDOUT.print(*output)                      },
     :readln     => -> ()              { STDIN.gets.chomp                           },
     :apply      => -> (f, list)       { f.call(*list)                              },
-    :"."        => -> (obj, m, *args) { obj.send(m, *args)                         },
-    :require    => -> (p)             { execute_file(File.expand_path(p, __dir__)) },
+    :send       => -> (m, o, *args)   { o.public_send(m, *args)                    },
   }
 end

data/lib/lasp/env.rb

@@ -1,9 +1,17 @@
-require "lasp/corelib"
+require "forwardable"
 
 module Lasp
-  module_function
+  class Env
+    extend Forwardable
 
-  def global_env
-    @global_env ||= {}.merge(CORELIB)
+    def_delegators :@env, :fetch, :[]=
+
+    def initialize(env = {})
+      @env = env
+    end
+
+    def merge(hash)
+      Env.new(@env.merge(hash))
+    end
   end
 end

data/lib/lasp/fn.rb

@@ -1,5 +1,5 @@
 require "lasp/interpreter"
-require "lasp/params"
+require "lasp/params_builder"
 require "lasp/errors"
 
 module Lasp
@@ -7,7 +7,7 @@ module Lasp
     attr_reader :params, :body, :env
 
     def initialize(params, body, env)
-      @params = Params.new(params)
+      @params = ParamsBuilder.build(params)
       @body   = body
       @env    = env
     end
@@ -24,26 +24,7 @@ module Lasp
     private
 
     def env_with_args(args)
-      enforce_arity!(args)
-
-      params_with_args = params
-                           .ordered
-                           .zip(args.take(params.length))
-                           .to_h
-
-      if params.variadic?
-        params_with_args[params.rest] = args.drop(params.length)
-      end
-
-      env.merge(params_with_args)
-    end
-
-    def enforce_arity!(args)
-      wrong_number_of_args!(args) unless params.matches_arity?(args.length)
-    end
-
-    def wrong_number_of_args!(args)
-      fail ArgumentError, "wrong number of arguments (#{args.length} for #{params.arity})"
+      env.merge(params.with_args(args))
     end
   end
 end

data/lib/lasp/interpreter.rb

@@ -1,3 +1,4 @@
+require "lasp"
 require "lasp/fn"
 require "lasp/macro"
 require "lasp/errors"
@@ -22,12 +23,13 @@ module Lasp
       head, *tail = *form
 
       case head
-      when :def   then def_special_form(tail, env)
-      when :fn    then fn_special_form(tail, env)
-      when :do    then do_special_form(tail, env)
-      when :if    then if_special_form(tail, env)
-      when :quote then quote_special_form(tail, env)
-      when :macro then macro_special_form(tail, env)
+      when :def     then def_special_form(tail, env)
+      when :fn      then fn_special_form(tail, env)
+      when :do      then do_special_form(tail, env)
+      when :if      then if_special_form(tail, env)
+      when :quote   then quote_special_form(tail, env)
+      when :macro   then macro_special_form(tail, env)
+      when :require then require_special_form(tail, env)
       else call_function(head, tail, env)
       end
     end
@@ -75,5 +77,14 @@ module Lasp
       params, func = form
       Macro.new(params, func, env)
     end
+
+    def require_special_form(form, env)
+      require_path, is_relative = form
+
+      require_root  = is_relative ? File.dirname(env.fetch(:__FILE__)) : Dir.pwd
+      absolute_path = File.expand_path(require_path, require_root)
+
+      Lasp::execute_file(absolute_path, env)
+    end
   end
 end

data/lib/lasp/lexer.rb

@@ -4,6 +4,7 @@ class Lexer
   TOKENS = [
     /\(|\)/,          # parens
     /'/,              # quote
+    /\./,             # dot
     /"(\\"|[^"])*"/,  # string literal
     /[^\s)]+/,        # any non-whitespace character excluding )
   ]

data/lib/lasp/params.rb

@@ -6,76 +6,41 @@ module Lasp
 
     def initialize(param_list)
       @param_list = param_list
-
-      validate_params!
     end
 
-    def ordered
-      param_list.take_while { |p| p != :& }
+    def to_s
+      "(" + param_list.join(" ") + ")"
     end
 
-    def rest
-      unless variadic?
-        fail LaspError, "a non-variadic function does not have rest-arguments"
-      end
-      param_list.last
+    def with_args(args)
+      enforce_arity!(args)
+      fixed_params.zip(args.take(length)).to_h
     end
 
-    def variadic?
-      param_list.include?(:&)
+    private
+
+    def fixed_params
+      param_list
     end
 
     def arity
-      ordered.length.to_s + (variadic? ? "+" : "")
+      length.to_s
     end
 
     def matches_arity?(num_args)
-      if variadic?
-        num_args >= length
-      else
-        num_args == length
-      end
+      num_args == length
     end
 
     def length
-      ordered.length
-    end
-
-    def to_s
-      "(" + param_list.join(" ") + ")"
-    end
-
-    private
-
-    def validate_params!
-      validate_list!
-      validate_single_ampersand!
-      validate_single_rest_parameter!
-      validate_unique_parameter_names!
-    end
-
-    def validate_list!
-      unless Array === param_list
-        fail SyntaxError, "parameters must be a list"
-      end
-    end
-
-    def validate_unique_parameter_names!
-      unless param_list.uniq.length == param_list.length
-        fail SyntaxError, "parameter names have to be unique"
-      end
-    end
-
-    def validate_single_ampersand!
-      invalid_rest_argument_usage! unless param_list.select { |p| p == :& }.length <= 1
+      fixed_params.length
     end
 
-    def validate_single_rest_parameter!
-      invalid_rest_argument_usage! if variadic? && param_list[-2] != :&
+    def enforce_arity!(args)
+      wrong_number_of_args!(args) unless matches_arity?(args.length)
     end
 
-    def invalid_rest_argument_usage!
-      fail SyntaxError, "rest-arguments may only be used once, at the end, with a single binding"
+    def wrong_number_of_args!(args)
+      fail ArgumentError, "wrong number of arguments (#{args.length} for #{arity})"
     end
   end
 end

data/lib/lasp/params_builder.rb

@@ -0,0 +1,69 @@
+require "lasp/errors"
+require "lasp/params"
+require "lasp/variadic_params"
+
+module Lasp
+  class ParamsBuilder
+    def self.build(param_list)
+      new(param_list).build
+    end
+
+    def initialize(param_list)
+      @param_list = param_list
+    end
+
+    def build
+      validate_params!
+      params_object
+    end
+
+    private
+
+    attr_reader :param_list
+
+    def params_object
+      if variadic?
+        VariadicParams.new(param_list)
+      else
+        Params.new(param_list)
+      end
+    end
+
+    def validate_params!
+      validate_list!
+      validate_single_ampersand!
+      validate_single_rest_parameter!
+      validate_unique_parameter_names!
+    end
+
+    def variadic?
+      param_list.include?(:&)
+    end
+
+    def validate_list!
+      unless Array === param_list
+        fail SyntaxError, "parameters must be a list"
+      end
+    end
+
+    def validate_unique_parameter_names!
+      accepted_params = param_list.reject { |p| p == :_ }
+
+      unless accepted_params.uniq.length == accepted_params.length
+        fail SyntaxError, "parameter names must be unique (except for _)"
+      end
+    end
+
+    def validate_single_ampersand!
+      invalid_rest_argument_usage! unless param_list.select { |p| p == :& }.length <= 1
+    end
+
+    def validate_single_rest_parameter!
+      invalid_rest_argument_usage! if variadic? && param_list[-2] != :&
+    end
+
+    def invalid_rest_argument_usage!
+      fail SyntaxError, "rest-arguments may only be used once, at the end, with a single binding"
+    end
+  end
+end

data/lib/lasp/parser.rb

@@ -30,6 +30,7 @@ module Lasp
       case token
       when "(" then form(tokens)
       when "'" then quote(tokens)
+      when "." then dot(tokens)
       else atom(token)
       end
     end
@@ -47,6 +48,12 @@ module Lasp
       [:quote] << build_ast(tokens)
     end
 
+    def dot(tokens)
+      method = tokens.shift
+      tokens.unshift(":" + method)
+      :send
+    end
+
     def atom(token)
       case token
       when "true"          then true

data/lib/lasp/repl.rb

@@ -11,13 +11,15 @@ module Lasp
     def run
       trap("SIGINT") { puts "\n\nBye!"; exit }
 
+      env = Lasp::env_with_stdlib
+
       puts "((( Läsp v#{Lasp::VERSION} REPL (ctrl+c to exit) )))\n\n"
       loop do
         begin
           history = true
           input   = Readline.readline(prompt, history).to_s
           input   = autoclose_parentheses(input)
-          result  = Lasp::execute(input)
+          result  = Lasp::execute(input, env)
           print_result(result)
         rescue => error
           print_error(error)

data/lib/lasp/stdlib.lasp

@@ -1,4 +1,4 @@
-(require "stdmacros.lasp")
+(require "stdmacros.lasp" :relative)
 
 ; Aliases
 (def first head)
@@ -16,7 +16,7 @@
 ; If a list is empty
 (defn empty?
   (coll)
-  (nil? (head coll)))
+  (= coll (rest coll)))
 
 ; If all arguments are not equal
 (defn not= (& args)
@@ -143,7 +143,7 @@
 
 ; Takes a method from Ruby-land and returns a Lasp function
 (defn ruby-method (meth)
-  (fn (arg) (. arg meth)))
+  (fn (arg) (send meth arg)))
 
 
 ; Conversion functions

data/lib/lasp/stdmacros.lasp

@@ -67,3 +67,21 @@
   (form)
   (list 'apply (first form)
         (list 'quote (rest form))))
+
+(defm or
+  (& args)
+  (if (empty? args)        nil
+  (if (empty? (tail args)) (head args)
+
+  (list 'let
+        (list 'or-value (head args))
+        (list 'if 'or-value 'or-value (cons 'or (tail args)))))))
+
+(defm and
+  (& args)
+  (if (empty? args)        true
+  (if (empty? (tail args)) (head args)
+
+  (list 'let
+        (list 'and-value (head args))
+        (list 'if 'and-value (cons 'and (tail args)) 'and-value)))))

data/lib/lasp/variadic_params.rb

@@ -0,0 +1,27 @@
+require "lasp/params"
+
+module Lasp
+  class VariadicParams < Params
+    def with_args(args)
+      super.merge(rest_args(args))
+    end
+
+    private
+
+    def fixed_params
+      param_list.take_while { |p| p != :& }
+    end
+
+    def arity
+      super + "+"
+    end
+
+    def matches_arity?(num_args)
+      num_args >= length
+    end
+
+    def rest_args(args)
+      { param_list.last => args.drop(length) }
+    end
+  end
+end

data/lib/lasp/version.rb

@@ -1,3 +1,3 @@
 module Lasp
-  VERSION = "0.10.1"
+  VERSION = "0.11.0"
 end

data/lib/lasp.rb

@@ -2,6 +2,7 @@ require "lasp/version"
 require "lasp/env"
 require "lasp/parser"
 require "lasp/interpreter"
+require "lasp/corelib"
 require "lasp/ext"
 
 module Lasp
@@ -9,15 +10,24 @@ module Lasp
 
   module_function
 
-  def execute_file(path)
-    execute("(do #{File.read(path)})")
+  def execute(program, env = env_with_corelib)
+    Interpreter.eval(Parser.parse(program), env)
   end
 
-  def execute(program, env = global_env)
-    Interpreter.eval(Parser.parse(program), env)
+  def execute_file(path, env = env_with_corelib)
+    env[:__FILE__] = path
+    result = execute("(do #{File.read(path)})", env)
+    env[:__FILE__] = nil
+    result
+  end
+
+  def env_with_corelib
+    Env.new(CORELIB.dup)
   end
 
-  def load_stdlib!
-    Lasp::execute_file(STDLIB_PATH)
+  def env_with_stdlib
+    env_with_corelib.tap do |env|
+      Lasp::execute_file(STDLIB_PATH, env)
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lasp
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.11.0
 platform: ruby
 authors:
 - Jimmy Börjesson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-22 00:00:00.000000000 Z
+date: 2016-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
 description: 
 email:
 - lagginglion@gmail.com
@@ -67,10 +81,12 @@ files:
 - lib/lasp/lexer.rb
 - lib/lasp/macro.rb
 - lib/lasp/params.rb
+- lib/lasp/params_builder.rb
 - lib/lasp/parser.rb
 - lib/lasp/repl.rb
 - lib/lasp/stdlib.lasp
 - lib/lasp/stdmacros.lasp
+- lib/lasp/variadic_params.rb
 - lib/lasp/version.rb
 homepage: https://github.com/alcesleo/lasp
 licenses:
@@ -95,5 +111,5 @@ rubyforge_project:
 rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
-summary: A simple programming language similar to Clojure, but much worse.
+summary: A simple Lisp-dialect programming language inspired by Clojure.
 test_files: []