Initial commit with slang as-is from sabre

Author: spy16

.gitignore

@@ -0,0 +1,18 @@
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, build with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+bin/
+.vscode/
+.idea/
+expt/
+sabre.iml
+temp.lisp

.goreleaser.yml

@@ -0,0 +1,54 @@
+before:
+  hooks:
+    - go mod tidy
+    - go mod download
+
+builds:
+  - main: ./cmd/slang/
+    goos:
+      - linux
+      - darwin
+      - windows
+    goarch:
+      - amd64
+      - 386
+      - arm64
+      - arm
+    goarm:
+      - 5
+      - 6
+      - 7
+    ignore:
+      - goos: darwin
+        goarch: arm
+      - goos: darwin
+        goarch: arm64
+      - goos: windows
+        goarch: arm
+      - goos: windows
+        goarch: arm64
+
+archives:
+  - replacements:
+      darwin: MacOS
+      linux: Linux
+      windows: Windows
+      386: i386
+      amd64: x86_64
+    format: zip
+    files:
+      - LICENSE*
+      - README.md
+      - CHANGELOG*
+      - ./lib/
+
+checksum:
+  name_template: 'checksums.txt'
+  algorithm: sha256
+
+changelog:
+  sort: asc
+  filters:
+    exclude:
+    - '^docs:'
+    - '^test:'

.travis.yml

@@ -0,0 +1,13 @@
+language: go
+go: '1.13'
+env:
+- GO111MODULE=on
+script: make clean test-verbose build
+deploy:
+  - provider: script
+    skip_cleanup: true
+    script: curl -sL https://git.io/goreleaser | bash -s -- --rm-dist --skip-validate
+    on:
+      tags: true
+notifications:
+  email: false

CHANGELOG.md

@@ -0,0 +1,34 @@
+VERSION="`git describe --abbrev=0 --tags`"
+COMMIT="`git rev-list -1 --abbrev-commit HEAD`"
+
+all: clean fmt test build
+
+fmt:
+	@echo "Formatting..."
+	@goimports -l -w ./
+
+install:
+	@echo "Installing slang to GOBIN..."
+	@go install -ldflags="-X main.version=${VERSION} -X main.commit=${COMMIT}" ./cmd/slang/
+
+clean:
+	@echo "Cleaning up..."
+	@rm -rf ./bin
+	@go mod tidy -v
+
+test:
+	@echo "Running tests..."
+	@go test -cover ./...
+
+test-verbose:
+	@echo "Running tests..."
+	@go test -v -cover ./...
+
+benchmark:
+	@echo "Running benchmarks..."
+	@go test -benchmem -run="none" -bench="Benchmark.*" -v ./...
+
+build:
+	@echo "Building..."
+	@mkdir -p ./bin
+	@go build -ldflags="-X main.version=${VERSION} -X main.commit=${COMMIT}" -o ./bin/slang ./cmd/slang/

LICENSE

@@ -0,0 +1,19 @@
+# Slang
+
+Slang (short for Sabre Lang) is a tiny LISP built using [Sabre](https://github.com/spy16/sabre).
+
+## Installation
+
+1. Download a release from [Releases](https://github.com/spy16/slang/releases) for
+   your target platfomr.
+2. Extract files and add extraction path to `PATH` variable.
+
+## Usage
+
+1. `slang` for REPL
+2. `slang -e "(+ 1 2 3)"` for executing string
+3. `slang -f "examples/simple.lisp"` for executing file.
+
+> If you specify both -f and -e flags, file will be executed first and then the string
+> will be executed in the same scope and you will be dropped into REPL. If REPL not needed,
+> use -norepl option.

Makefile

@@ -0,0 +1,83 @@
+package slang
+
+import (
+	"github.com/spy16/sabre"
+)
+
+// BindAll binds all core functions into the given scope.
+func BindAll(scope sabre.Scope) error {
+	core := map[string]sabre.Value{
+		"core/->": &sabre.Fn{
+			Args:     []string{"exprs"},
+			Func:     ThreadFirst,
+			Variadic: true,
+		},
+		"core/->>": &sabre.Fn{
+			Args:     []string{"exprs"},
+			Func:     ThreadLast,
+			Variadic: true,
+		},
+		"core/assert": &sabre.Fn{
+			Func:     Assert,
+			Args:     []string{"expr", "err?"},
+			Variadic: true,
+		},
+		"core/.": &sabre.Fn{
+			Func: sabre.Dot,
+		},
+
+		// special forms
+		"core/do":           sabre.Do,
+		"core/def":          sabre.Def,
+		"core/if":           sabre.If,
+		"core/fn*":          sabre.Lambda,
+		"core/macro*":       sabre.Macro,
+		"core/let*":         sabre.Let,
+		"core/quote":        sabre.SimpleQuote,
+		"core/syntax-quote": sabre.SyntaxQuote,
+
+		"core/eval":      sabre.ValueOf(sabre.Eval),
+		"core/type":      sabre.ValueOf(TypeOf),
+		"core/to-type":   sabre.ValueOf(ToType),
+		"core/impl?":     sabre.ValueOf(Implements),
+		"core/realize":   sabre.ValueOf(Realize),
+		"core/apply-seq": sabre.ValueOf(ApplySeq),
+		"core/throw":     sabre.ValueOf(Throw),
+
+		// Sequence functions
+		"core/next":   sabre.ValueOf(Next),
+		"core/first":  sabre.ValueOf(First),
+		"core/cons":   sabre.ValueOf(Cons),
+		"core/conj":   sabre.ValueOf(Conj),
+		"core/concat": sabre.ValueOf(Concat),
+
+		// Type system functions
+		"core/str": sabre.ValueOf(MakeString),
+
+		// Math functions
+		"core/+":  sabre.ValueOf(Add),
+		"core/-":  sabre.ValueOf(Sub),
+		"core/*":  sabre.ValueOf(Multiply),
+		"core//":  sabre.ValueOf(Divide),
+		"core/=":  sabre.ValueOf(sabre.Compare),
+		"core/>":  sabre.ValueOf(Gt),
+		"core/>=": sabre.ValueOf(GtE),
+		"core/<":  sabre.ValueOf(Lt),
+		"core/<=": sabre.ValueOf(LtE),
+
+		// io functions
+		"core/println": sabre.ValueOf(Println),
+		"core/printf":  sabre.ValueOf(Printf),
+
+		"types/Seq":       TypeOf((*sabre.Seq)(nil)),
+		"types/Invokable": TypeOf((*sabre.Invokable)(nil)),
+	}
+
+	for sym, val := range core {
+		if err := scope.Bind(sym, val); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

README.md

@@ -0,0 +1,107 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"flag"
+	"fmt"
+	"os"
+	"runtime"
+
+	"github.com/chzyer/readline"
+	"github.com/spy16/sabre"
+	"github.com/spy16/sabre/repl"
+	"github.com/spy16/slang"
+)
+
+const help = `Slang %s [Commit: %s] [Compiled with %s]
+Visit https://github.com/spy16/sabre for more.`
+
+var (
+	version = "N/A"
+	commit  = "N/A"
+
+	executeFile = flag.String("f", "", "File to read and execute")
+	executeStr  = flag.String("e", "", "Execute string")
+	noREPL      = flag.Bool("norepl", false, "Don't start REPL after executing file and string")
+)
+
+type temp struct {
+	Name string
+}
+
+func (temp *temp) Foo() {
+	fmt.Println("foo called")
+}
+
+func main() {
+	flag.Parse()
+
+	sl := slang.New()
+	sl.BindGo("*version*", version)
+
+	var result sabre.Value
+	var err error
+
+	if *executeFile != "" {
+		fh, err := os.Open(*executeFile)
+		if err != nil {
+			fatalf("error: %v\n", err)
+		}
+		defer fh.Close()
+
+		result, err = sl.ReadEval(fh)
+		if err != nil {
+			fatalf("error: %v\n", err)
+		}
+		sl.SwitchNS(sabre.Symbol{Value: "user"})
+	}
+
+	if *executeStr != "" {
+		result, err = sl.ReadEvalStr(*executeStr)
+		if err != nil {
+			fatalf("error: %v\n", err)
+		}
+	}
+
+	if *noREPL {
+		fmt.Println(result)
+		return
+	}
+
+	lr, errMapper := readlineInstance()
+
+	repl := repl.New(sl,
+		repl.WithBanner(fmt.Sprintf(help, version, commit, runtime.Version())),
+		repl.WithInput(lr, errMapper),
+		repl.WithOutput(lr.Stdout()),
+		repl.WithPrompts("=>", "|"),
+	)
+
+	if err := repl.Loop(context.Background()); err != nil {
+		fatalf("REPL exited with error: %v", err)
+	}
+	fmt.Println("Bye!")
+}
+
+func readlineInstance() (*readline.Instance, func(error) error) {
+	lr, err := readline.New("")
+	if err != nil {
+		fatalf("readline: %v", err)
+	}
+
+	errMapper := func(e error) error {
+		if errors.Is(e, readline.ErrInterrupt) {
+			return nil
+		}
+
+		return e
+	}
+
+	return lr, errMapper
+}
+
+func fatalf(format string, args ...interface{}) {
+	fmt.Printf(format, args...)
+	os.Exit(1)
+}