Kiss

A type-safe, compiled Lisp for Haxe programs

What is Kiss?

Kiss is a work in progress. (See: Who should use Kiss?)

Kiss aims to be a statically typed Lisp that runs correctly almost anywhere using Haxe's FFI features.

Main features:

• [x] Traditional Lisp macros
• [x] Rust-style pattern-matching
• [x] Reader macros
• [x] Plug-and-play with every pure-Haxe library on Haxelib
• [x] Smooth FFI with any non-Haxe library you can find or write Haxe bindings for
• [x] helpful compiler errors

Extra goodies:

• [x] string interpolation
• [x] Rust-style raw string literals
• [x] syntactic sugar for Promise-based asynchronous code
• [x] negative indexing
• [x] list comprehensions
• [x] immutability by default
• [x] destructuring assignment

How does it work?

Kiss

• reads Kiss code from .kiss files
• converts the Kiss expressions into Haxe macro expressions
• provides a builder macro which adds your Kiss functions to your Haxe classes before compiling

By compiling into Haxe expressions, Kiss leverages all of the cross-target, cross-platform, type-safety, and null-safety features of the Haxe language.

Why?

I've been working on a Haxe-based interpreted Lisp called Hiss since December 2019. I had to rewrite Hiss from scratch at least once. I've learned so much from writing Hiss, but it has majorly slowed down the productivity of Hiss-based projects because it is so complex, fast-changing, and prone to runtime errors. Kiss is like a Kompiled hISS, and a reminder to Keep It Simple, Stupid.

What does the license mean?

Licenses are confusing and GPL licenses can be intimidating. I've chosen the LGPL because I never want any big corporation to profit from my work. If you are an independent developer/studio with good intentions, I'm willing to negotiate usage of Kiss under a different license on a case-by-case basis.

Who should use Kiss?

As of now:

• Language design enthusiasts
• Hobbyists writing disposable code without deadlines

Hopefully someday:

• Professional game developers who want to learn the ways of Lisp

Limitations

• No pattern matching in macros
• No type checking in macro definitions
• Macros are extremely hard to debug