Yeah, but you still can’t explain monads.
It puts the fun in functional
This is true
Why do programs written in Haskell not have side effects?
To have side effects someone would have to run the programs.
Of course, they have side effects. Side effects are what the computation does. Otherwise, they would simply make the box hot.
The difference between Haskell and most languages is that Haskell forces one to keep that impurity at the outer edges. It enforces that constantly, making programs easier to reason about.
I heard it explained succinctly lately: types are all of the possible inputs and inputs of a program while functions encapsulate the mutation. Excel, for example, is a purely functional language.
pandoc.
Yeah, there’s like two projects that use Haskell. Doesn’t change the fact that it’s the language that most people know and will never write anything productive in it.
Eh, i’m not a math type but for them, Haskell is chef’s kiss from what i’ve heard.
Typisch.
Php has real enforced types
Count us rust folks in. Typescript may doing it’s best, but it’s not as great
Listen I absolutely love rust but it’s not even close. Typescript’s type system is orders of magnitude more powerful, to the point where it is actually turing complete.
Typescript doesn’t have linear types. Not even Haskell has linear types (correction GHC has had LT by extension since 9.0). Give Rust some credit for having linear types (AKA borrow checker).
Ps. Typescript doesn’t have dependent types and their type system is a joke even compared to Purescript. Here’s a little writeup about it: https://lemmy.dbzer0.com/post/66729809
GHC has had experimental support for linear types in Haskell since version 9.0.1
Thanks. I think it’s most fair to count what a language has without extensions but thanks for the correction. To that end, Haskell basically has Dependent Types now too if you pile 10 extensions together (singletons, linear types, and others) and squint a little. It’ll easily be the first production-grade language to do so.
That’s not realistic or “fair” - most Haskell projects will use a dozen or so extensions easily. GHC has been a platform for language experimentation for a long time; standardisation efforts keep on cropping up in annual surveys. (Eg, swapping in Text for String in base is long overdue, but it’s a hold over from days where FP pedagogy was seen as more important.)
Typescript’s string pattern types are quite neat though
That’s true and they’re great for prototyping but I’ve fallen in love with Purescript for that domain. So I’m a bit biased.
I code a ton in both Rust and Typescript for work… I think Rust has just as capable of a type system, but leveraging macros for functional defs vs object ones.
I started programming in a time when the idea that the computer could keep track of your variable types for you automatically was a fever dream, so it’s wild for me to see some programmers now throwing shade at particular langages for “not implementing proper variable typing functionality”.
It feels like someone saying that low-fat milk producers are too cheap or lazy to put enough fat in their milk.
Fashion really does go in cycles.
It was a dream when it wasn’t available. Once it existed, we saw the many flaws it had. That’s why statically strong typed languages still exist. And even new ones are being created.
Fashion really does go in cycles.
This here.
When I got into programming I figured it would be mostly linear technological progression. Every once in a while something new gets invented that’s better than the last iteration, so we discard the last option (except for legacy stuff) and everyone moves to the better thing.
But since then everything that was cool back then became uncool and cool again at least once.
I like the SQL/No-SQL cycle. SQL is powerful, but it’s also slow and clunky and if you do it badly it gets really slow. So we invented No-SQL DBs. They are fast, lightweight, but also barebones and limited. So we add functionality here and there, and before we know it we have another variant of SQL with a different syntax. So we head back to use real SQL. But then we realize it’s slow and clunky and if you do it badly it gets really slow. So we invent a new No-SQL DB and the cycle continues.
It’s more that nosql makes sense of you have very specific performance characteristics and can accept very specific constraints.
Alternatively, you want to use a document db because you don’t understand that delaying implementing schema integrity or implementing it yourself in the application layer instead of having it baked into your database will be more complex and slow you down in the long run. RDBMS isn’t slower than a generic document DB.
I don’t even think it’s fashion. Some ideas sound good but are bad. Or, overlappingly, are convenient to use but actually turn into nightmarish spaghetti code. I don’t know how many people are still pushing MongoDB and BASE, for example.
Meanwhile SQL hasn’t changed, and C didn’t until someone figured out memory safety in Rust.
1950??? Statically typed programming languages are very old…
Sorry for not being clear; when I said “keep track automatically” I meant dynamic typing. Of course you’re right that “keeping track of your variables” could also be interpreted to refer to static typing.
Haskell keeps track of your types automatically. You can ask it “what is the type of this expression” and it will infer it for you. Haskell is of course fully static typed (types erased at compile time).
GOTO is all i’m saying.
HOW CAN TYPES BE REAL IF OUR EYES AREN’T REAL
The same reaction whenever I look at haskell. A “pure” language with an escape hatch that has a fancy name. Once you open the escape hatch, you can write entirely impure code in Haskell and never see a pure function in your life. So much for “pure”.
You say your house is clean, yet nothing’s stopping me from dumping out this bucket of mud on your floor, curious!
Reading current discussion, it seems more like “You say that it’s impossible to dirty your house, yet nothing’s stopping anyone from dumping out this bucket of mud on your floor, curious!”
Same goes for rust and memory safety. What’s your point?
the only languages that don’t have an escape hatch of some sort are languages with no safety in the first place. the escape hatch is an important part of treating your developer like an adult
Haskellers when someone boasts about Typescript’s fake type system.
Haskellers when someone boasts about Typescript’s fake type system.
Are extensible records usable already?
Not that I would pick TS because of that, but the disdain is undeserved when it has some very useful features that Haskell has been trying to copy for years.
The features Haskell has been “trying to copy” from TypeScript are, without exception, features TypeScript copied from type theory research that predates TypeScript by decades – row polymorphism from Didier Rémy’s 1989 work, untagged unions from the intersection type literature of the 1980s, type-level computation from Martin-Löf’s 1975 intuitionistic type theory – and what you are observing is not Haskell enviously watching TypeScript and taking notes, but rather two languages drinking from the same well of ideas, one of which is doing so with a formal semantics and a proof of soundness, and the other of which is doing so while standing in a JavaScript runtime and hoping no one looks down.
Elm for ever!
