glojure

README

Glojure

Try it in your browser! (fair warning: startup on the web is slow)

Gopher image derived from @egonelbre, licensed under Creative Commons 1.0 Attributions license.

Glojure is an interpreter for Clojure, hosted on Go. Glojure provides easy access to Go libraries, similar to how Clojure provides easy access to Java frameworks.

Glojure is in early development; expect bugs, missing features, and limited performance. Backwards compatibility is not guaranteed until a v1 release. That said, it is used successfully in hobby projects and runs a significant subset of the (transformed) core Clojure library.

Note that unlike most other Go implementations of Clojure, Glojure is a "hosted" language - a term used to describe languages that are implemented in terms of a host language (in this case, Go). This means that all Go values can be used as Glojure values and vice versa.

Prerequisites

Before you get started with Glojure, make sure you have installed and have knowledge of Go (version 1.19 or higher).

Installation

Glojure is currently available from source for all platforms where Go can run, and it requires at least go 1.19.

Install it with the go install command:

$ go install github.com/glojurelang/glojure/cmd/glj@latest

After installation, you can start the REPL (Read-Eval-Print-Loop) with the glj command:

$ glj
user=> (println "Hello, world!")
Hello, world!
nil
user=>

Usage

Here's a small example program that starts an HTTP server with a simple handler function that responds with the request body:

;; example.glj
(ns example.server)

(defn echo-handler
  [w r]
  (io.Copy w (.Body r))
  nil)

(net$http.Handle "/" (net$http.HandlerFunc echo-handler))

(net$http.ListenAndServe ":8080" nil)

Run it with the glj command:

$ glj ./example.glj

$ curl localhost:8080 -d "sicp"
sicp

Interop

Glojure ships with interop with many standard library packages out-of-the-box. Go package names are munged to avoid ambiguity with the use of / to refer to namespaced symbols; instances of / in package names are replaced with $. Here's a simple example:

user=> (println (fmt.Sprintf "A couple of HTTP methods: %v" [net$http.MethodGet net$http.MethodPost]))
A couple of HTTP methods: ["GET" "POST"]
nil

The following standard library packages are included by default:

• bytes
• context
• errors
• flag
• fmt
• io
• io/fs
• io/ioutil
• math
• math/big
• math/rand
• net/http
• os
• os/exec
• os/signal
• regexp
• reflect
• sort
• strconv
• strings
• sync
• sync/atomic
• time
• unicode

To expose additional packages, you must generate a "package map" and compile your own executable that imports both your package map and the Glojure API. See the section below for more details.

Expect improvements to both the availability of standard library packages and interop workflows.

Accessing additional Go packages

The gen-import-interop can be used to emit the contents of a .go file that will export a function that can be used to add the exports of additional packages to the Glojure package map.

$ go run github.com/glojurelang/glojure/cmd/gen-import-interop \
     -packages=:comma-separated-package-list: \
     > your/package/gljimports/my_package_map.go

Then, in your own program:

package main

import (
	// Add your packages' exports to the pkgmap.
	_ "your.package/gljimports"
)

// ...

Differences from Clojure

Numbers

Clojure Type	Glojure Type	Notes
long	int64
double	float64
float	float32
double	float64
byte	byte	Note that Go bytes are unsigned, whereas JVM bytes are signed.
short	int16
int	int	Note that JVM ints are 32-bit, whereas Go ints are 32- or 64-bit depending on the platform.
char	lang.Char	The Glojure type is a tagged rune (type Char rune). JVM chars are 16-bit whereas Go runes are 32-bit.
BigInt	*lang.BigInt	The Glojure type wraps *big.Int.
BigDecimal	*lang.BigDecimal	The Glojure type wraps *big.Float.
Ratio	*lang.Ratio	The Glojure type wraps *big.Rat.
BigInteger	*big.Int	Native JVM BigInteger corresponds to *big.Int.

Comparisons to other Go ports of Clojure

Aspect	Glojure	Joker	let-go
Hosted[^1]	Yes	No	No
Extensible Go interop	Yes	No	No
Concurrency	Yes	Yes (with GIL)	Yes
Clojure tooling (e.g. linter)	No	Yes	No
Execution	Tree-walk interpreter	Tree-walk interpreter	Bytecode Interpreter

If you'd like to see another port in this table, or if you believe there is an error in it, please file an issue or open a pull request!

[^1]: What does it mean to be a hosted language? For Clojure on the JVM, it means that all Java values are also Clojure values, and vice versa. Glojure strives to maintain the same relationship with Go.