# Clojure's Influence

## Dialects of Clojure

Not going to talk too much about these since they're pretty well-understood.

### ClojureScript/Clojure-CLR "official" ones
### Clojerl
### Joker (2015, 19 contributors)

What constitutes a "dialect" is fuzzy but all of these adhere very
closely to Clojure's design.

## New Lisps

Criteria to look at:
* Runtime
* Has the creator used Clojure? contributed to Clojure?
* Settable locals?
* Mutable data structures?
* Lisp-1 or Lisp-2?

Syntax considerations:
* defn/fn?
* [] for args?
* []/{} for data structures?
* implicit quoting?

Macros:
* defmacro style?
* symbol-capture prevention?
* auto-gensym?

Omitting those with single-digit contributors or double-digit commit count.

### LFE (Lisp-flavored Erlang)

* Erlang runtime
* Started 2008
* 25 contributors
* not created by a Clojure user
* syntax is closer to CL/Elisp than anything else
* lisp-2, for reasons of interop with Erlang
* predates Clojure 1.0

### Joxa

* Erlang runtime
* Started 2011
* 10 contributors
* created by Clojure user
* specifically calls out as Clojure-like

### Wisp

* JS runtime
* Started 2012
* 17 contributors
* Created by Clojure user
* Specifically called out as Clojure-like

### Hy

* Python runtime
* started 2013
* 124 contributors
* created by Clojure user
* Uses defn for functions; very Clojure-like syntax
* Mutable data structures by default

### Pixie

* Custom runtime, implemented in RPython
* started 2014
* 48 contributors
* started by Clojure contributor
* Uses defn, very Clojure-like syntax

### Lux

* JVM runtime, implemented in Clojure
* started May 2015
* 10 contributors
* started by Clojure user (all other contributors are 1 or 2 commits)
* static types

### Ferret

* custom runtime, written in Clojure and C++ in org-mode
* started Dec 2015
* 15 contributors
* started by Clojure user
* if it doesn't work like Clojure, it's either a platform limitation or bug

### Carp

* Custom runtime, written in Haskell
* Started Jan 2016
* 40 contributors
* started by Clojure user
* designed for game dev; no GC. rust-like ownership.

### Fennel

* Lua runtime, written in Lua/Fennel
* started August 2016
* 18 contributors
* started by Clojure user, developed by Clojure contributor

### Urn

* Lua runtime
* Started Nov 2016
* 7 contributors
* not started by Clojure user

### Janet

* custom runtime, written in C
* started Feb 2017
* 23 contributors
* started by Clojure user

### Maru

* ???

https://piumarta.com/software/maru/#current

## MAL

Kind of in its own category.

* 104 independent, mostly 1-person implementations across 81 runtimes
* started 2014 Jan
* started by Clojure user

## Too small; probably won't make it into the talk

* Pharen (2009, PHP, 8 contributors, 1113 commits) (no [] for args)
* Sibilant (2012, JS, 8 contributors, 600 commits) (no [] for args)
* l2l (2012, Lua, 5 contributors, 455 commits) (no [] for args)
* Gherkin (2013, shell, 7 contributors, 98 commits)
* Lumen (2015, JS/Lua, 4 contributors, 1290 commits) (no [] for args)
* Tocatta (2017, LLVM, 4 contributors, 314 commits)

## Old Lisps

* Emacs Lisp
    * seq.el is very Clojure-like
    * some 3rd-party macros give better lambda syntax
* Racket
    * rackjure is explicitly Clojure-like
    * Racket moved to immutable-first data structures
* Shen?
    * Shen is a new version of Qi which is quite old.
    * Unlikely to have cross-pollinated much but worth looking into?
* nu

## Non-lisps

* Elixir: protocols primarily, also mix
* Swift: #() lambda syntax
* Kotlin: general JVM-wide push towards FP?

## Areas of Influence

### Syntax

Very few lisps introduced since Clojure use CL-style or Scheme-style
syntax; defn and [] for arg lists. {} and [] for data literals is
common, but less so. Everyone kinda realized that implicit quoting is
the devil.

### Hostedness

Majority of new lisps sit on an existing runtime where features are
specifically selected to mesh well with the runtime. You still see a
fair number of custom runtimes; more than you might expect.

Is this because virtual machines are fun to build?

### Cons cells

Before Clojure cons cells were regarded as holy; the idea that you
could have a lisp that didn't put them front and center was absurd,
and the idea that you could have a lisp that omitted them entirely was
blasphemy. Nowadays lots of lisps don't have cons.

### Immutable Locals

An easy win; lots of folks at least default to this if not require it.

### Immutable data structures

This is way more difficult to do efficiently, but still done by some.

### Lisp-1 has won; basically no one makes lisp-2s any more

LFE is the only exception?

### Macro systems

Everyone wants a CL-style defmacro system but no one wants gensym
capture. Fennel uses auto-gensym with backtick-tainting similar to
Clojure but without tying it to the namespace system.

Others do ...?

### Transducers

## What still is unique?

* Vars? No one has copied that. (why not? they're great!)

Generated by Phil Hagelberg using scpaste at Wed Feb 26 10:50:04 2020. PST. (original)