Clojurians Log v2

Thanks again!

I have a question - why does this (and many other type-annotating libs) use sym :- Type rather than using metadata? Clojure could have done type hints like this but didn't, instead inventing metadata for that. The big advantage of metadata is that it makes it easy for macros to flow a single type-annotated symbol around, whereas now you've got three things.

Common Lisp has detached type info like this and it's a real pain to write program generators that convey types as a result

I might be to blame there: Typed Racket uses a reader macro : which is invalid syntax, so it became :- in core.typed. IIRC Plumatic Schema picked it up etc. You're spot on, it led to a proliferation of wrapper macros. I then went back and supported annotations via metadata which look like this: https://github.com/typedclojure/typedclojure/blob/c103738554091c6debbb87ad47225d1b68e34024/example-projects/zero-deps/src/typed_example/zero_deps.cljc#L20

Metadata annotations have a subtlety which can be hard to convey to users: depending on the macro, metadata can either be an evaluation context or a quoted context. So it ends up being a bit brittle encouraging metadata annotations because the user has to figure this out for each macro. I don't have a great example, but this is the kind of issue:

^{:foo (nil)} (fn [])
=> NPE
(defn a {:foo (nil)} [])
=> NPE

But that's a minor issue compared to abandoning the great properties of flowing data around implicitly.

Raster internally flows the type information (and static information in general) through metadata as well, so this is only a surface issue and could be fixed fairly easily. One concern I have though is that metadata could be much more verbose, in particular if map syntax and quoting are needed, e.g. ^{:raster.type '(Array float)} vs. :- (Array float) . But I would also be in favor of a standardized metadata based type annotation approach because it composes better.

I found I could squeeze it into about half a dozen extra chars:

^{::t/- ann/MyStr} e

e :- ann/MyStr

IMO it's really the singleton map literal that makes it noisy. I've yet to think of a good syntax proposal, but essentially I was looking for a namespaced ^tag syntax.

It seems like less of a challenge for Raster since you (Ambrose) are looking to adorn arbitrary Clojure code while Raster is working only inside its own macro I think

My goal with Raster is to stick to TypedClojure as much as possible since it already allows me to devirtualize and do type inference like Julia does. I am happy to follow TC in general (e.g. if it starts to use a Malli syntax), and don't need to reinvent the wheel. I would in general appreciate to have a standardized optional type annotation syntax like Python has now and that library authors start to use more in Clojure, as this makes implementing embedded languages/compilers like Raster much more convenient. TC can express complex parametric type constraints between inputs and outputs, https://github.com/replikativ/ansatz (Lean4) can additionally express dependent type constraints and types over types, but also has a somewhat adhoc syntax atm. Ideally a standardized type annotation syntax would cover this ground as well. @ambrosebs How would you represent the (All [T] ...) parametric type scope with metadata?

How would you represent the (All [T] ...) parametric type scope with metadata?

x: Foo
=> (with-meta 'x {:ann 'Foo})
[]: Bar
=> (with-meta [] {:ann 'Bar})

(defn foo ([a: Int, b: Bool]: Return, code))
=> (defn foo (^{:ann Return} [^{:ann Int} a, ^{:ann Bool} b] code))

Tho something like this would probably work fine and works today.

(defn foo (^{- Return} [^{- Int} a, ^{- Bool} b] code))

Impressive! Congratulations on the release 🙌

@teodorlu Thank you!

Brief update: Both Ansatz and Raster support now metadata type annotations. I still kept the shorthands, might remove them as well if we agree they are harmful duplications, I find them a bit easier to read though.