Hacker News Reader

Comment by mccoyb | Hacker News Reader

Not a core team member -- but this comment confuses me.

What exactly do you mean by "duck type and thtt" (?)

Also, people are constantly asking for traits. But I don't think I've seen a compelling example where: this is something that you can only do with traits, but you can't do with multiple dispatch.

Perhaps what you're arguing for is the ergonomics of multiple abstract inheritance (?) So a concrete struct can inherit from multiple abstract types (?) So maybe it's not a comment on utility, but more ergonomics.

View on HN

Is there a difference between traits and multiple abstract inheritance? Those seem equivalent to me.

Re duck typing: people usually respond to "what is the type of map?" with "it's duck typed". But we should be able to do better.

I think the difference is in name only -- but TBH, I'm a little naive on more specific PL details.

That's just how I imagine the implementation of that concept would likely go in the Julia space.

I think we have a big PL-shaped hole in our community. Taine's work [1] shows how much PL folks can add to Julia. We need more of them.

[1] https://github.com/thautwarm

Can you elaborate on where the hole is? Jeff Bezanson's thesis work on Julia was undoubtedly PLT, as were some of the other folks at the Julia Lab now (e.g. Shuhei Kadowaki). Keno Fischer is very much into all things PLT, as can be evidenced by his work on Diffractor (see this ACM SIGPLAN presentation [1]). Ditto for James Fairbanks and all the people working on Catlab.jl's [2] ecosystem.

Where I do agree with you is that PLT awareness has not permeated the entire community as much as I'd like to see. Certainly one feels a need sometimes to push back against increased "Matlab-ification" of the language. However, it is also nice to see a direct line between rather theoretical concepts like abstract interpretation and very practical use cases like GPU computation.

[1] https://www.youtube.com/watch?v=mQnSRfseu0c [2] https://github.com/AlgebraicJulia/Catlab.jl [3] https://en.wikipedia.org/wiki/Abstract_interpretation

I agree there are a number of interesting packages in this space (Metatheory is another).

What I'd like to see more of is things like arrows, higher-kinded data types, etc, that work better with support from the language's type system, and things like parametrized modules and contracts, that just need someone with the right background to show Julia how to do it well.

I'd like to see those as well, with the caveat that I've yet to see a language implement some of them performantly (e.g. arguments against higher-kinded types in Rust).

Reply on news.ycombinator.com