Typed Janet?

[taoeffect]

If there were a clean, clear, intuitive way to add types to Janet I think it would help to both increase the appeal of the language to others, catch bugs quicker, potentially improve the speed of the language, and make it easier to also use Janet with LLMs (which would be less likely to write buggy Janet code by being forced to fix type errors).

EDIT: One additional benefit of adding types is that it would greatly improve the documentation and speed with which Janet could be learned and written. It would also make it possible to create neat IDE autocomplete integrations.

Ideally it would be done in a way that didn't clutter Janet files with too much complicated syntax.

There have been various other attempts to add typing to Lisp-like languages as a reference: Typed Clojure, Typed Racket

Personally, I like the minimal approach of adding type annotations above function definitions to label their inputs and outputs as this keeps the rest of the syntax clean and minimal, and it's familiar to users of other languages.

[sogaiu]

For reference, here is an earlier discussion on the topic.

[veqqq]

Adding types would be cool, could give us better performance at times too! Sequent types like Shen seem very interesting, although generally speaking, I'd prefer to just use predicate functions as type definitions, letting us arbitrarily define them anyway we want elsewhere and then have them hopefully run compile time. I'm working on some declarative testing stuff right now, using predicates for contracts and other things which could fit here - but I think there would be a lot of work to integrate them with the compiler/byte output (and that there are lower hanging fruit to work on first).

make it easier to also use Janet with LLMs

I prefer LLMs to not use Janet.

[taoeffect]

I prefer LLMs to not use Janet.

Well, I'm certainly not going to be converting my newLISP codebase to Janet by hand, but you do you! 😄

I'd prefer to just use predicate functions as type definitions, letting us arbitrarily define them anyway we want elsewhere and then have them hopefully run compile time

Yeah that does sound like a good idea to me. A way of using predicate functions but also keeping the syntax simple so that simple predicates like "is it a string?" are just 1 word to type.

Another possibility is inserting these type definitions into the defn special form as a parameter.

Something else to consider is the relationship between the type system and runtime type detection.

For example, Zod in TypeScript integrates nicely with both the "compile-time" type checking but is also useful for runtime type checking of JSON data from APIs.

It would be great if the syntax were the same for both compile-time and run-time type checking, that way there's only one type checking syntax to learn.