<aeth>
Afaik, Clojure, Racket (via the Typed Racket language), and Common Lisp (at least in the SBCL implementation; CL declarations can be ignored) all have some degree of static type checking added, but Clojure, Racket, and CL were clearly initially designed with dynamic types in mind.
longshi has quit [Ping timeout: 252 seconds]
<aeth>
Of course, these additions were all done in very different ways, e.g. the Racket approach is to make sublanguages with "#lang foo" so the Racket approach here was to add a "#lang typed/racket"
<aeth>
Afaik, all three are probably best described as "optionally typed", i.e. dynamic-first with some static checking that can be added.
<aeth>
Clojure seems to use "optional typing" and Typed Racket uses "gradually typed" in the documentation for their systems. The SBCL Manual does not appear to use either phrase for its system.
<aeth>
Since this is #racket the one true way to describe this system is thus "gradually-typed".
jao has quit [Remote host closed the connection]
jao has joined #racket
acarrico has quit [Ping timeout: 245 seconds]
<jcowan>
Common Lisp has type declarations, but their meaning depends on both the compiler in usse and its settings. In particular, they can be type checks that the user wishes to have made, or type guarantees that the user is making.
orivej has joined #racket
<jcowan>
the standard "speed" and "safety" setting influence this
longshi has joined #racket
dddddd has quit [Remote host closed the connection]
acarrico has joined #racket
<aeth>
jcowan: SBCL with (safety 0) is afaik the only thing that assumes types and that created the style guideline to essentially never use (safety 0)
<aeth>
It's basically just there to break the language so it benchmarks better.
badkins has quit []
<aeth>
Worse, it removes the static checking, too, so you wind up with basically just a worse C.
<jcowan>
Worse? Better, I'd say
<jcowan>
but yes, unsafe; sometimes speed really does trump safety
<aeth>
jcowan: The whole point of (safety 0) is to remove the runtime type checks for performance. But it doesn't do static type checking with (safety 0), either, so you can do something that's easily catchable at compile time without (safety 0) and it will instead *fail* (not error) at runtime.
<aeth>
I mean, I guess it improves compilation speed, but it makes it very dangerous.
<jcowan>
compile once with higher safety, then again with safety 0, then