lantiga/ki

lisp + mori, sweet.js

{
  "createdAt": "2014-01-12T21:51:03Z",
  "defaultBranch": "master",
  "description": "lisp + mori, sweet.js",
  "fullName": "lantiga/ki",
  "homepage": "ki-lang.org",
  "language": "JavaScript",
  "name": "ki",
  "pushedAt": "2018-05-28T20:39:20Z",
  "stargazersCount": 479,
  "topics": [],
  "updatedAt": "2025-10-06T01:17:00Z",
  "url": "https://github.com/lantiga/ki"
}

ki

lisp + mori, sweet.js

See ki-lang.org for more information or try ki straight in your browser.

ki is a lisp with Clojure data structures and semantics that can be intermixed with Javascript code at any level.

ki is a thin macro layer on top of mori plus a few constructs.

ki is in flux, feel free to test it out but expect glitches.

Currently available functions / special forms

All of mori.

The following list of functions / special forms

[] {} [$ ] {$ } add and apply atom bind catch chain cond def defmethod defmulti
defn deref div do doto eq falsey finally fn fnth geq gt if ifNot js leq letc
let lt loop mod mul neq nil not ns or prn recur reset str sub swap threadf
threadl truthy try use when whenNot while

Plus destructuring and source maps.

Take a look at the tests to keep up with the latest additions.

Examples

Require ki (this in turns expands into an appropriate require for mori)

ki require core

Mori’s persistent data structures and Clojure(Script)-like api at your fingertips

var foo = ki (vector 1 2 3)
ki (conj foo 4)
// => [1 2 3 4]

Plus lambdas

ki (map (fn [a] (inc a)) (range 5))
// => (1 2 3 4 5)

Interoperability: write js in a ki form

var fn1 = ki (js function (a,b) { return a + b + 2; })

at any level - e.g. you can use infix where it makes sense

var fn2 = ki (fn [a b] (js a + b + 2))

and you can use ki wherever in js code

function somefunc (a) {
  ki (toJs (filter (fn [el] (isEven el)) (range a))).forEach(function(el) {
      console.log(el);
      });
  return [0, 1, 2, 3, 4].filter(ki (fn [el] (isEven el)));
}
console.log(somefunc(5));
// => 0
// => 2
// => 4
// [0 2 4]

Like a pro

ki (take 6 (map (fn [x] (js x * 2)) (range 1000)))
// => (0 2 4 6 8 10)

Get it

$ npm install -g ki

All set. Now to compile a JavaScript file containing ki code into a plain JavaScript file do

$ ki -o foo_build.js foo.js

To watch the file and have it automatically compiled whenever the file changes on disk

$ ki -w -o foo_build.js foo.js

License

MIT license http://www.opensource.org/licenses/mit-license.php/