Jesus H Christ could the whole FP world stop this? You're either going to prioritize static types or you're going to blow them off. Either front-and-center your type system, or stop mentioning how you blew it off. Those of us who want Clojure's syntax and semantics and a decent type system would like to stop being taunted.
I think you may have misunderstood what you're looking at. Julia is very much a dynamic language. It also has the ability to add type hints, but, unlike for most optionally typed languages, these aren't just type hints for human readers or an external type checker. They're actually one of Julia's more interesting features. Julia's type declarations provide information that the compiler uses to generate faster code, and to support its multiple dispatch functionality.
When the notes say "optional typing - currently not implemented", all they're saying is that this syntax doesn't allow you to tap into that feature, because a syntax for type declarations has not been provided.
Just a minor point - type hints only really help if you put them in struct fields. In function signatures they only limit what can be dispatched to that specific method, there's (almost always) no difference to leaving it untyped since functions are compiled for specialized types anyway.
Basically every new lisp that comes out has a big bullet point of features and included in the list of features is a link in the README about static type checking. They all invariably raise the hope of a statically typed lisp for the given use case, then clicking through to the linked heading say “this project isn’t focusing on static types”. It’s Lucy and Charlie with the football. If you’re developing a lisp and you’re not interested in a static type system, not mentioning it is good enough. Making it a big headline only to yank it away in the rest of the text is just a disappointing setup.
I think you’re confused about this project. This is not a new language. It’s literally just lisp syntax for the Julia language.
When this gets typing, it will be with Julia’s very powerful and expressive type system (which is dynamic by the way), and it just needs someone to modify the LispSyatax.jl parser to properly represent the type annotations.
You’re the second person to say so, and it’s entirely possible I’ve misunderstood the language I quoted that’s nearly verbatim in almost every new lisp that addresses static types at all.
> When this gets typing
I’m not entirely clear that there’s any intention of it getting typing. Am I missing some statement that “not implemented” is temporary?
> Calm down.
I’m sorry I took my exasperation out on this project which I’m sure is awesome. It’s just a very general frustration I feel about the priorities of the FP+lisp community generally. Like I expressed, it’s exceptionally common to announce a new lisp (language or syntax) where static types are explicitly called out as a headline non-feature.
It’s disappointing because every time I see “lisp”, especially “Clojure like”, and I see types addressed explicitly... I keep hoping someone’s come along and married a syntax and (hopefully) state management approach I adore with a static analysis DX I also adore. And 100% of the time so far it’s been... “Types? Glad I got your attention, this isn’t for you!”
I’m well aware I’m not entitled to other people building the language I want. I’m even well aware I could build it myself, probably on top of these existing lisps.
I’m just disappointed to see so many projects explicitly identify something I want in a way that feels hopeful and bury the “nope we didn’t actually bring a type system to something like clojure” behind the headline.
I’m not losing sleep over it (other than to type this between falling asleep on the couch and proper bedtime), but can you understand how that messaging is a disappointing thing?
There's a strong tradition of dynamic fp-ish languages with Erlang, Scheme, Common Lisp[1], and lately Clojure (along with many others) that just isn't about static typing. A lot of people feel that dynamic + fp is just the right thing. It's not an omission, since putting in static typing restricts, complicates and remolds a language a lot.
[1] Yes, there's optional type declarations in CL, as an add-on feature. But I'd guess most CL programs don't elect to use them.
I’m well aware that most lisps and BEAM languages are dynamically typed. My objection wasn’t that they didn’t include static types, but that there’s also a strong tradition of these languages including a prominent headline about static types, which gets my hopes up that this one is bucking that trend, only to have my hopes dashed. It’s so much a general expectation that a lisp will have a dynamic type system that it’s safe to assume and could go without saying.
No hit for "static type" in the web pages or reference manual. Dynamic type ditto:
$ grep 'dynamic type' txr-web/*.html txr/txr.1
$
I don't think Common Lisp has a "prominent headline" about static types anywhere, either. There are no hits for any of those terms in the draft ANSI standard:
Scheme's R7RS explicitly talks about dynamic typing in two places:
Introduction:
Scheme was one of the first programming languages to incorporate first-class procedures as in the lambda calculus, thereby proving the usefulness of static scope rules and block structure in a dynamically typed language.
1.1 Semantics:
Scheme is a dynamically typed language. Types are associated with values (also called objects) rather than with
variables. Statically typed languages, by contrast, associate types with variables and expressions as well as with
values.
That's also the only mention of "static type" or "statically typed".
> It’s so much a general expectation that a lisp will have a dynamic type system that it’s safe to assume and could go without saying.
A language reference manual has to document the type system so that someone knowing nothing about language type systems can understand it. This can be done without using dynamic type terminology or mentioning static type checking, but it has to be done.
There is a lot of detail there; no two dynamic type systems are exactly alike.
Sorry for double response but I took a glance and have some stars in my eyes! I’m not sure this is the language I imagine but it’s awesome awesome that it exists and someone is working on something even a bit like a Clojure with a real static type system I would want to work with.
Jesus H Christ could the whole FP world stop this? You're either going to prioritize static types or you're going to blow them off. Either front-and-center your type system, or stop mentioning how you blew it off. Those of us who want Clojure's syntax and semantics and a decent type system would like to stop being taunted.