1. Common Lisp has a whole system for defining and declaring types, and implementations do actually use this information to produce safer and higher performing code, including some amount of static, compile-time verification (e.g., you can get "expected an INTEGER but got a STRING" styles of compile-time errors). Fast, competitive-with-C floating-point math is achieved this way. DEFTYPE/DECLARE work.
2. If you prefer a system that doesn't feel like a 1980s barebones type system (i.e., Common Lisp's), then you can use Coalton [1] which adds types to a Scheme-like DSL within Common Lisp, but has a type system like Haskell's (similar to stock GHC + common extensions). Multi-parameter type classes, monomorphization, functional dependencies, etc. Yet it's still fully interoperable with Lisp code, uses the same Lisp toolchain, same Lisp compilers, same Lisp editors, etc. so it really isn't just a language atop Lisp, but something that's integrated within it.
I wasn't objecting to "a lisp with compile time enforced static types" I was objecting to "lmao just write it yourself". I'm well aware it already exists just as any number of basic bootstrapable C compilers do. It's a huge undertaking to bolt that on as a DSL from scratch instead of introducing a dependency.
Ah, that makes sense. I read the original comment, "you can define them," as meaning one can add static types to Common Lisp programs. But designing and building entirely new systems, at least ones that should work for a large class of practical programs, is not easy. I agree with you then.
CL already has strong types, it's static typing that it lacks. Though some compilers do make use of the information present to varying degrees, they'll emit warnings typically, not errors, for things like
(+ 1 "hello") ;; SBCL should emit a warning, but will let this run and you'll get a runtime type error
If it was not strongly typed then you'd be able to do the silly things you can do in JS and Perl like:
To be fair, it's very possible at this point that LLMs will play a role in ending humanity. Not because they are super capable and will maliciously kill us, but because humans are stupid enough to hook them up to dangerous things that the LLM isn't remotely smart enough to manage successfully.
The agents which hacked Hugging Face were asked to solve their tasks rather than cheat by cooperating and stealing the solution without solving the task. They were aware of that, because they actively tried to cover their tracks in order to deceive a causal grader.
