3 ms·
I believe Rust has ADTs as well, though I don't know whether it has Lisp-style ad-hoc ADTs, with which you could easily do something like: (defun* foo ((bar
by tmtvl 2y ago
I believe Rust has ADTs as well, though I don't know whether it has Lisp-style ad-hoc ADTs, with which you could easily do something like:
(defun* foo ((bar Bar))
(:returns (or Baz QuuxException ZotException YendorException))
...)
But in Rust syntax.
- brabel 2y agoRust doesn't support that, but there's an RFC trying to figure out how that could be done (hasn't gone anywhere after more than 10 years of discussions): https://github.com/rust-lang/rfcs/issues/294 https://github.com/rust-lang/rfcs/issues/294 But Rust supports macros, just like Lisp, so of course someone wrote a library that provides something similar: https://docs.rs/some-error/latest/some_error/ https://docs.rs/some-error/latest/some_error/ Their post about how they came up with this crate is quite interesting: https://jam1.re/blog/anonymous-sum-types-for-rust-errors https://jam1.re/blog/anonymous-sum-types-for-rust-errors
- tmtvl 2y agoCool, that's the value of languages with macros: adding useful features which help combat needless infrastructure code (AKA boilerplate).
- Expurple 2y agoYeah, but there's always a cultural struggle to prevent everyone from using their own incomprehensible DSL. See "The Lisp Curse" [1]. Even vanilla Haskell (without macros, i.e. without Template Haskell) takes it too far by allowing to define arbitrary custom operators with arbirtary associativity and precedence. Many Haskell libraries are an incomprehensible soup of symbols instead of regular functions with readable names. Rust does pretty well so far. Macros are used appropriately in the ecosystem. [1] http://www.winestockwebdesign.com/Essays/Lisp_Curse.html http://www.winestockwebdesign.com/Essays/Lisp_Curse.html
- kazinator 2y agoThe Lisp Curse was written by someone who never worked on a Lisp project, let alone with other people. It's a good example of what hallucination looked like before AI took it over. Macros are super helpful in communicating ideas to future maintainers. The alternative to writing a macro and using it seventeen times is to just open code some similar logic in seventeen places. The macro calls can all be found by name, and if something is wrong, it can be fixed in one place: the macro definition. Macros run in your development system, and so do not have to be debugged in the live target. Most macris are functional and have only one input: the unexpanded macro call. They can be debugged simply by inspecting the output, and iterating on it.