Comment by Cybiote | Hacker News Reader

Comment by Cybiote | Hacker News Reader

I enjoyed reading the perspective given in this essay and agree Haskell's been (and continues to be) an influential language. So take this criticism as maybe my being overly particular about the meaning of descendant.

Idris as a descendant of Haskell I have no argument with.

Rust however, is more correctly viewed as (primarily) a descendant of ML languages, which all possess the properties the articles lists as derived from Haskell. Perhaps it is more correct to call Haskell and Rust cousins, both deriving from the same lineage of languages.

I would also not call Julia a child of Haskell. As it is more correctly viewed as an interpretation of Matlab as a Lisp, I'd therefore call Julia a descendant of Lisp. That Haskell single handedly popularized the utility of category theory in computing and that a category theory library is written in Julia does not make Julia a child of Haskell any more than it would have made Ocaml a child of Haskell (there used to be a category theory library written in Ocaml).

The popularization of functional programming, Domain specific languages as algebras, reactive (not FRP), property based testing, parser combinators, model view update for UIs, design principles secretly based on monads are all but a few of the ways Haskell has influenced programming. Which is the core point of the essay and with which I am in full agreement.

This thread somewhat has the air of an eulogy but it goes without saying that just because something is not the most popular in fashion does not mean it is dying.

Rust’s two most prominent type system features are lifetimes and traits. Traits aka type classes first appeared in Haskell and are not a feature of ML.

I would be interested to learn of features in Rust that came from ML and that aren’t features of Haskell - not counting strictness :-) I can think of a non-example: one of ML's distinguishing features is its functional (in the FP sense) module system; Haskell and Rust have more conventional module systems.

You could maybe argue that a Rust enum definition is more like an ML type definition than a Haskell data definition because the constructor parameters are tuples rather than curried, but it isn’t clear to me whether this is actual influence from ML, or Rust aiming to be more C-ish.

As I understand the history of algebraic data types and pattern matching, they first appeared in Hope, and from there they were added to ML, and on the separate branch of lazy functional languages they were inherited by Hope’s successors Miranda, Orwell, and Haskell.

You raise good points and I suppose valid differences in focus will alter one's notion of nearness. Here's why I made the claim I did:

> Rust that came from ML and that aren’t features of Haskell

> As I understand the history of algebraic data types and pattern matching, they first appeared in Hope, and from there they were added to ML, and later adopted by Hope’s successors

They appeared first in a practical form in Hope but I'm taken to understand that these ideas could already be found in Programs and their Proofs: An Algebraic Approach and the core ideas are clearly present in this 1968 paper by Burstall: http://www.cse.chalmers.se/edu/year/2010/course/DAT140_Types...

Creators of HOPE, VAX ML (which also had limited patterns and case analysis) and LCF/ML all influenced each other and played prominent roles in the design Standard ML, which would in turn strongly influence future functional languages, including Haskell and Ocaml. It's tricky to untangle the history but I don't think it's controversial to say SML popularized functional programming as prototypically understood today (before Haskell evangelized it further).

> Rust’s two most prominent type system features are lifetimes and traits

Other than the initial prototype being written in Ocaml, I'd say Rust's pragmatic feel: eager evaluation, immutability by default but a hatch to mutability and the implementation of the features listed in the posted article all make it feel more like an ML. I agree, though, that this is a subjective take.

There is a good list of ways Rust has a more ML vibe than Haskell here https://lobste.rs/s/nwtarh/haskell_s_children#c_quph8k in aspects of Rust’s syntax and choice of type names

I agree, I would call OCaml, Haskell, and Rust cousins, more or less ... descendants of ML.

Though the original Rust compiler was written in OCaml, so depending on your viewpoint it could also be its child. I'm not sure if Rust lifted any features or syntax from OCaml specifically. I think the "O" in OCaml was not influential ...

----

edit: I found a list of influences, and it does credit Haskell with typeclasses, but SML/OCaml and C++ are credited first:

https://doc.rust-lang.org/reference/influences.html

I always thought of Rust as a mashup of OCaml and C++, but Haskell is in there too.

While Haskell has a lot of influence from ML it is also a descendant of the highly influential line of programming languages designed by David Turner starting with SASL. If Miranda weren't a closed source language it perhaps would be what all of us are talking about now.

Some History of Functional Programming Languages (David Turner) https://www.cs.kent.ac.uk/people/staff/dat/tfp12/tfp12.pdf

Interesting, I didn't know about SASL.

Miranda was open sourced earlier this year! I remember downloading the tarball and looking at its source code.

https://old.reddit.com/r/programming/comments/fbtmar/miranda...

https://www.cs.kent.ac.uk/people/staff/dat/miranda/

https://www.cs.kent.ac.uk/people/staff/dat/miranda/downloads...

This Landin paper predates SASL by about a decade: http://thecorememory.com/Next_700.pdf

Mentioned in the PDF I linked to :) And lambda calculus came decades before still.

But Catlab.jl is definitely a child of Haskell: the developers have said many times how much inspiration they've gotten from Haskell.

> Rust however, is more correctly viewed as (primarily) a descendant of ML languages, which all possess the properties the articles lists as derived from Haskell.

Why would that be more correct? Would Rust have these features if they were not popularized by Haskell? I don't know the answer, but it seems like discussing which language some feature was taken, when more than one contemporary language has it, is a kind of meaningless pedantry.

Given that the original Rust compiler was implemented in OCaml, it seems natural to assume that's where some of these features were inspired.

Though I'm not really sure that it matters.

Reply on news.ycombinator.com