lasp 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c3c2a2b3d78d531e4669760374632562219a5114
+  data.tar.gz: cea95705d76894736b21d1dac3c24691c606f417
+SHA512:
+  metadata.gz: 7162a39c7d3000b3d1e20e93b0386fc9e60f7e1d793eb73a9b966be4c69f217c0a9bb21567649d2d5576700bde1995a85bbf5189de2b083c95bc5d645d0ed53e
+  data.tar.gz: d7266dd23f4f0e3ca1b547add6c8ced523c9b54ec10adfc547ae46177590e6908a24784bbac9a15416ce4ba3068fb468b5c989101caa1fe49f6de754a3fff69b

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+pkg/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lasp.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Jimmy Börjesson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,97 @@
+# Läsp
+
+A very simple Lisp implementation in Ruby. Run `lasp-repl` to play around with
+it, or `lasp path/to/program.lasp` to execute a Läsp file.
+
+## The language
+
+### Examples
+
+```lisp
+(+ 1 2 3)
+; => 6
+
+(def x 5)
+x
+; => 6
+
+(def inc (fn (x) (+ x 1)))
+(inc 5)
+; => 6
+```
+
+### Data types
+
+Supports these datatypes (implemented as their Ruby counterparts)
+
+- integer
+- float
+- boolean
+- nil
+- string
+
+### Comments
+
+Comments start with a `;` and end at the end of a line
+
+```lisp
+; This is a comment
+(+ 1 2) ; This is also a comment
+```
+
+### Functions in corelib
+
+Implemented as Ruby lambdas.
+
+- `+`
+- `-`
+- `*`
+- `/`
+- `<`
+- `>`
+- `=`
+- `head`
+- `tail`
+- `cons`
+- `not`
+- `println`
+
+### Special forms
+
+Implemented as special cases while evaluating.
+
+- `def`
+- `fn`
+- `do`
+- `if`
+
+### Functions in stdlib
+
+Implemented in Läsp itself.
+
+- `first` (alias of `head`)
+- `rest` (alias of `tail`)
+- `inc`
+- `dec`
+- `empty?`
+- `mod`
+- `complement`
+- `even?`
+- `odd?`
+- `len`
+- `nth`
+- `last`
+- `reverse`
+- `map`
+- `reduce`
+- `filter`
+- `sum`
+- `take`
+- `drop`
+- `range`
+- `max`
+- `min`
+
+## Developing
+
+Run the tests with `rspec`.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/lasp

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require "./lib/eval"
+
+# Load the stdlib
+Lasp::execute_file(File.expand_path("./lib/stdlib.lasp"))
+
+Lasp::execute_file(ARGV.first)

data/bin/lasp-repl

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require "lasp"
+Lasp::load_stdlib!
+
+trap("SIGINT") { puts "\n\nBye!"; exit! }
+
+loop do
+  begin
+    print "lasp> "
+    result = Lasp::execute(gets.chomp)
+    puts "  =>> #{result.inspect}"
+  rescue
+    puts "  **> #{$!}"
+  end
+end

data/lasp.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lasp/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "lasp"
+  spec.version       = "0.1.0"
+  spec.authors       = ["Jimmy Börjesson"]
+  spec.email         = ["lagginglion@gmail.com"]
+
+  spec.summary       = %q{A simple programming language similar to Clojure, but much worse.}
+  spec.homepage      = "https://github.com/alcesleo/lasp"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/lasp/corelib.rb

@@ -0,0 +1,18 @@
+module Lasp
+  CORELIB = {
+    :+       => -> (_, *args)      { args.reduce(:+)           },
+    :-       => -> (_, *args)      { args.reduce(:-)           },
+    :*       => -> (_, *args)      { args.reduce(:*)           },
+    :/       => -> (_, *args)      { args.reduce(:/)           },
+    :<       => -> (_, *args)      { args.sort == args         },
+    :>       => -> (_, *args)      { args.sort.reverse == args },
+    :"="     => -> (_, *args)      { args.uniq.count == 1      },
+    :list    => -> (_, *args)      { args                      },
+    :head    => -> (_, list)       { list.first                },
+    :tail    => -> (_, list)       { list.drop(1)              },
+    :cons    => -> (_, item, list) { [item] + list             },
+    :not     => -> (_, arg)        { !arg                      },
+    :println => -> (_, output)     { puts output               },
+    :"."     => -> (_, obj, meth)  { obj.send(meth)            }
+  }
+end

data/lib/lasp/env.rb

@@ -0,0 +1,9 @@
+require "lasp/corelib"
+
+module Lasp
+  module_function
+
+  def global_env
+    @global_env ||= {}.merge(CORELIB)
+  end
+end

data/lib/lasp/eval.rb

@@ -0,0 +1,37 @@
+require "lasp/parser"
+require "lasp/env"
+
+module Lasp
+  module_function
+
+  def eval(ast, env)
+    case ast
+    when Symbol then env.fetch(ast)
+    when Array  then eval_form(ast, env)
+    else ast
+    end
+  end
+
+  def eval_form(form, env)
+    head, *tail = *form
+
+    if head == :def
+      key, value = tail
+      env[key] = eval(value, env)
+    elsif head == :fn
+      params, func = tail
+      # Use env from context to properly scope closures
+      -> (_, *args) { eval(func, env.merge(Hash[params.zip(args)])) }
+    elsif head == :do
+      tail.each do |form| eval(form, env) end
+    elsif head == :if
+      conditional, true_form, false_form = tail
+      eval(conditional, env) ? eval(true_form, env) : eval(false_form, env)
+    elsif Proc === head
+      head.(env, *tail)
+    else
+      fn = eval(head, env)
+      fn.(env, *tail.map { |form| eval(form, env) })
+    end
+  end
+end

data/lib/lasp/parser.rb

@@ -0,0 +1,47 @@
+module Lasp
+  module_function
+
+  def parse(program)
+    build_ast(tokenize(sanitize(program)))
+  end
+
+  def build_ast(tokens)
+    return if tokens.empty?
+    token = tokens.shift
+
+    if token == "("
+      form = []
+      while tokens.first != ")"
+        form << build_ast(tokens)
+      end
+      tokens.shift
+      form
+    else
+      atom(token)
+    end
+  end
+
+  def tokenize(string)
+    string
+      .gsub("(", " ( ")
+      .gsub(")", " ) ")
+      .scan(/(?:[^\s"]|"[^"]*")+/)
+  end
+
+  def atom(token)
+    case token
+    when "true"        then true
+    when "false"       then false
+    when "nil"         then nil
+    when /\A\d+\z/     then Integer(token)
+    when /\A\d+.\d+\z/ then Float(token)
+    when /"(.*)"/      then String($1)
+    when /:(\w+)/      then String($1) # Symbol style strings are actually just strings
+    else token.to_sym
+    end
+  end
+
+  def sanitize(string)
+    string.gsub(/;.*$/, "")
+  end
+end

data/lib/lasp/stdlib.lasp

@@ -0,0 +1,122 @@
+(do
+  ; Aliases
+  (def first head)
+  (def rest tail)
+
+  ; Increment a number by one
+  (def inc (fn (x) (+ x 1)))
+
+  ; Decrement a number by one
+  (def dec (fn (x) (- x 1)))
+
+  ; If a list is empty
+  (def empty?
+    (fn (coll)
+      (= (head coll) nil)))
+
+  ; Modulus
+  (def mod
+    (fn (x y) (- x (* (/ x y) y))))
+
+  ; Returns a function that does the opposite of the given function
+  (def complement
+    (fn (f) (fn (x) (not (f x)))))
+
+  ; If a number is even
+  (def even?
+    (fn (x) (= (mod x 2) 0)))
+
+  ; If a number is odd
+  (def odd? (complement even?))
+
+  ; Length of a list
+  (def len
+    (fn (coll)
+      (if (empty? coll)
+        0
+        (inc (len (tail coll))))))
+
+  ; Gets an item in a list by index
+  (def nth
+    (fn (index coll)
+      (if (= 0 index)
+        (head coll)
+        (nth (dec index) (tail coll)))))
+
+  ; Last item in list
+  (def last
+    (fn (coll)
+      (nth (dec (len coll)) coll)))
+
+  ; Reverses a list
+  (def reverse
+    (fn (coll)
+      (reduce (fn (acc item) (cons item acc)) (list) coll)))
+
+  ; Apply f to all items in list
+  (def map
+    (fn (f coll)
+      (if (= nil (head coll))
+        coll
+        (cons
+          (f (head coll))
+          (map f (tail coll))))))
+
+  ; Go through a list passing an accumulator and each item of the list through f
+  ; f(acc item)
+  (def reduce
+    (fn (f acc coll)
+      (if (empty? coll)
+        acc
+        (reduce f (f acc (head coll)) (tail coll)))))
+
+  ; Fil er a list of items based on a function
+  (def filter
+    (fn (f coll)
+      (reduce
+        (fn (acc item) (if (f item) (cons item acc) acc))
+        (list)
+        (reverse coll))))
+
+  ; Sum of all items in a list
+  (def sum
+    (fn (coll)
+      (reduce + 0 coll)))
+
+  ; Take x items from list
+  (def take
+    (fn (num coll)
+      (if (= num 0)
+        (list)
+        (cons (head coll) (take (dec num) (tail coll))))))
+
+  ; Drop x items from list
+  (def drop
+    (fn (num coll)
+      (if (= num 0)
+        coll
+        (drop (dec num) (tail coll)))))
+
+  ; Exclusive range
+  (def range
+    (fn (from to)
+      (if (= from to)
+        (list)
+        (cons from (range (inc from) to)))))
+
+  ; Highest value in list
+  (def max
+    (fn (coll)
+      (reduce
+        (fn (acc item) (if (< acc item) item acc))
+        (head coll)
+        (tail coll))))
+
+  ; Lowest value in list
+  (def min
+    (fn (coll)
+      (reduce
+        (fn (acc item) (if (> acc item) item acc))
+        (head coll)
+        (tail coll))))
+)

data/lib/lasp/version.rb

@@ -0,0 +1,3 @@
+module Lasp
+  VERSION = "0.1.0"
+end

data/lib/lasp.rb

@@ -0,0 +1,18 @@
+require "lasp/version"
+require "lasp/eval"
+
+module Lasp
+  module_function
+
+  def execute_file(path)
+    execute(File.read(path))
+  end
+
+  def execute(program, env = global_env)
+    Lasp::eval(Lasp::parse(program), env)
+  end
+
+  def load_stdlib!
+    Lasp::execute_file(File.expand_path("../lasp/stdlib.lasp", __FILE__))
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: lasp
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jimmy Börjesson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: 
+email:
+- lagginglion@gmail.com
+executables:
+- lasp
+- lasp-repl
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/lasp
+- bin/lasp-repl
+- lasp.gemspec
+- lib/lasp.rb
+- lib/lasp/corelib.rb
+- lib/lasp/env.rb
+- lib/lasp/eval.rb
+- lib/lasp/parser.rb
+- lib/lasp/stdlib.lasp
+- lib/lasp/version.rb
+homepage: https://github.com/alcesleo/lasp
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: A simple programming language similar to Clojure, but much worse.
+test_files: []