kitten

> ";" operator is more fun. The only problem is that this operator actually doesn't work on stacks but arrays. Oops. It's suppose to work on arrays. He's creating a concatenative array processing language. > This is basically a more sane version of forks and hooks in J > I want to create my own little concatenative array language > I'm not a fan of APL/J style one-liners, I prefer simple expressions with lots of `where`. > So I started to think about design of a sane array programming language. And I contunued to dream about it until meeting a real problem > A concatenative array programming language... I'd rather start from something simple. Like `;` operation, that brings the power of forks and hooks in J into concatenative programming https://github.com/evincarofautumn/kitten/issues/174 https://github.com/suhr/esobsc/commit/809241a726f

This is likely borrowed from Haskell where functions starting with special characters are treated as infix. Parens and backticks allow for switching between the conventions add a b = a + b -- these are all the same 3 + 4 (+) 3 4 add 3 4 3 `add` 4 The article might also make slightly more sense in context, I think it was in part an idea for how to make infix notation more useful in Kitten: https://github.com/evincarofautumn/kitten/issues/174

This is from his HN profile: I’m writing a stack-based functional programming language called Kitten: https://github.com/evincarofautumn/kitten

It’s not the prettiest code, but here: https://github.com/evincarofautumn/kitten/blob/8a7e949f1af71... The key line is: (term', t, tenvFinal) <- inferType dictionary tenvFinal' tenv term In “inferType”, I just annotate each term with “Zonk.type_ tenvFinal type_” as I go, in the same pass as generating the type constraints. Since “tenvFinal” is the final type environment, and “zonking” substitutes all type variables with their solved types, everything gets lazily resolved when reading the annotated types later on, e.g., during analysis & codegen.

I’ve been working on a statically typed concatenative programming language, Kitten[1], off and on for a few years now. I plan to do an early release this year. I started working on the language to bring an elegant compositional style to low-level high-performance programming, in the form of a simple language that admits powerful tooling for program editing and visualisation. I also wanted to address usability concerns with stack-based languages (e.g., by allowing infix operators). As I’ve spent time in industry, I’ve begun to treat it as a way to address my gripes with C, C++, and Haskell; and as I’ve learned more type theory, I’ve begun to use it as a playground for type system research. The goal is to allow pure functional programming that “feels imperative”, with a simple performance model (unboxed values by default, in-place updates,

Author of Kitten here, happy to answer any questions. The site is pretty far out of date—it describes an older version of the language/compiler, so it’s better to check out the GitHub repo[1]. I figure I’ll send a pre-release announcement to all the stargazers, when the time is right. One of my new year’s resolutions is to work on Kitten every week this year, and release it before the end of the year. I’m also working on a short ebook (“Programming with Kitten”) to serve as the standard tutorial. I could really use help with all this—building and marketing a language is no small task. If you’re interested in contributing, even if you’re not familiar with Haskell or compilers, I’d be glad to help you get involved. :) [1]: https://github.com/evincarofautumn/kitten

New: Rust, ATS; new to me: J, D. And working on the compiler for Kitten[1], which should be usable by the end of the year. [1]: https://github.com/evincarofautumn/kitten