I have a confession to make: I secretly love bash. Sure, it’s impossible to use for large programs, takes tons of configuration to make work correctly, is filled with syntactic gotchas and has only one type (don’t talk to me about bash arrays and assoc-arrays…). It has a simplicity to it, and the left-to-right chaining makes it really easy to compose small programs into sophisticated ones that are easy to read, decent to reason about, and incredibly easy to type. Barewords ease the typing burden of quoting.

I also love haskell. The merits of functional programming have been talked into the ground already, but particularly important is the emphasis on creating a large common understanding between the programmer and the compiler. But on the repl, it can be awkward to work with, since you have to keep jumping to the left to use each subsequent expression, and properly quote and balance parentheses.

So, without further ado, I’d like to introduce ixl, a language optimized for heavy repl usage, and also appropriate for writing large programs. During my time off, I’ll be working on a proof-of-concept implementation targetting Haskell Core. Your feedback would be super appreciated!

A few notes on the syntax, since it is very different from many other languages out there:

For runtime expressions, the emphasis is on compactness and left-to-right writeability. Imagine writing each of these lines on a shell. On a shell, barewords are far more common than variables, which is why variables and patterns require sigils.

For parts that you would normally put in a library, the emphasis is on consistency and readability. This includes the type language and the @enum and @struct keywords.

Tuples are intended to be recursive (one of my personal bugaboos with haskell…). This means that ('a, ()) is equivalent to 'a, and ('a, ('b, 'c)) is equivalent to ('a, 'b, 'c). (('a, 'b), 'c) is semantically different, though. This will allow making arbitrary tuples instances of typeclasses.