Hacker News Reader

Comment by mikebenfield | Hacker News Reader

I used to dream about this too.

Not so much anymore though. I feel like static type systems have progressed enough that dynamic typing really has little appeal to me at this point, especially the idea of dynamic stuff "all the way down."

Nowadays my fantasy is more along the lines of:

* a machine with a simple instruction set for CPU and GPU and without slow transfers between the two

* a modern statically typed language that can be used to program both CPU and GPU, that's basically "Rust, but better, and with simpler syntax without braces and semicolons and commas and with easier macros and..."

* some simple garbage collected extension language for runtime/dynamic stuff. Still statically typed though.

View on HN

Well, on a Symbolics Lisp Machine you could run Ada, C, Pascal, Fortran and some other exotic stuff. Probably there was an ML for it and I guess you could bring up an early Haskell compiler (Yale Haskell) on it.

I'm pretty sure Prolog was there too. If I'm not mistaken Symbolics C had safe pointer arithmetic and a garbage collector.

Prolog was one of the main language offerings, though it was not statically typed. ;-)

> Rust, but better, and with simpler syntax without braces and semicolons and commas and with easier macros and...

Makes me wonder: could there be a fully statically typed variant of Lisp? Did anyone try that?

Well, there is Shen. Static typing, I think it can do dependent typing... Doesn't have the affine types of Rust tho. Not sure how it works out to use in practice.

Discussed here, for example: https://news.ycombinator.com/item?id=9297665

>Makes me wonder: could there be a fully statically typed variant of Lisp? Did anyone try that?

FYI: Lisp already allows you to specify data types if you want, as if it were a statically typed language. If you do this, a good Lisp implementation, like SBCL, will then do static type checks and will also improve execution speed significantly -- with this plus other tricks, Lisp can approach Fortran and C speed.

There is Typed Racket which has been under substantial development for many months now, with good results.

https://docs.racket-lang.org/ts-guide/

There's https://github.com/murarth/ketos which is not exactly that but related

With type inference, extra speed of static typing (no run-time type checks), and the convenience of dynamic typing (no type declarations).

Reply on news.ycombinator.com