type-system-j VS L1

An "easy" and arguably most flexible type system is to make it fully user defined: https://github.com/Pascal-J/type-system-j

A function that wants more parameters, can expect a boxed list as a tuple alternative. The single function parameter simplifies "user space" type systems (with user control over coercion or error return) and currying/default arg enhancements: https://github.com/Pascal-J/type-system-j

A user typing system for J that is used for type coercion, and potentially increased polymorphism, rather than just harassing programmer with errors: https://github.com/Pascal-J/type-system-j

L1 does not have statement separator. These are identical:

In L1 https://github.com/mlajtos/L1 is async only — every value is an RxJS observable. You can think of observable as an async iterator, or promise that can resolve multiple times. Assignemnt to variable acts as resolving a promise with that value. On assignemnt, every dependant variables are recomputed. This is called “functional reactive programming”. It is a bit more than you asked for, but I got to L1 when I asked myself what if there was no sync/async distinction, but I may have overthought it. :)

Thanks! I think we share a few aesthetic ideals :) I really like your work on L1 and New Kind of Paper, and just noticed ES1995 – if only it was true…

ShapeRank got me really excited when I first heard about it. I stumbled upon combining arrays and observables in my L1 project, but I never really got it working the way I wanted. Gilad is more than capable, so I am really curious how he progressed.

I did this in L1. Every value is an Observable (RxJS) and operators/function calls are just creating new nodes in the Observable graph. Observables is a generalization of Futures/Promises for multiple values.

I did this in L1: https://github.com/mlajtos/L1