4 ms·
I'm still surprised the "use" syntax survived the 0.x release "experimentation" phase. It's more confusing than explicit "I can read and tell what this is doin
by ubertaco 3y ago
I'm still surprised the "use" syntax survived the 0.x release "experimentation" phase.
It's more confusing than explicit "I can read and tell what this is doing by matching the braces" callbacks, _and_ it's more confusing (and less expressive) than full-on do-notation (or F#-like "computation expressions").
Instead, it's the worst possible middle ground: it's a third, different mental model that is unfamiliar in an already-unfamiliar language amid other "rough-edges" choices (like not having if-then statements -- even though you can pattern-match on `case true...case false`, it's still another rock in the shoe), but it doesn't offer improved clarity (since you have to keep "what will the real code look like when this is desugared" in mind constantly when figuring out which variables to `use` and which to just assign, and which parameters should stay in the function call and which should get "magically" floated outside the parens, and so on...), nor does it offer improved power/flexibility (in the way that do-notation does, where you can generalize expressing any given nested/monadic operations as though they were not nested).
I love ML-family languages, and I find the BEAM VM intriguing. I want Gleam to be great, but it has just enough friction (in the form of unique-but-not-clearer-or-more-powerful language decisions) and just enough limitation (in the form of a very limited standard library) that I think it's currently just "okay".
- giraffe_lady 3y agoIDK I really don't mind use. Your "worst possible middle ground" is my "useful compromise between complexity and expressiveness."
- lpil 3y ago> it's more confusing (and less expressive) than full-on do-notation (or F#-like "computation expressions"). It's strictly more expressive than do-notation. Anything that Haskell's `do` can do Gleam's `use` can do, but not everything that Gleam's `use` can do Haskell's `do` can do. I don't think the clarity argument holds true, I think rather this is about what you're familiar with rather than an actual property of the syntax. Both are rather opaque. Given there's a few languages with `use` now I think that familiarity problem will lessen too.
- tome 3y agoCan it be nested? Haskell's do can be used like do r <- do foo bar quux r But I don't see (from https://gleam.run/news/v0.25-introducing-use-expressions/ https://gleam.run/news/v0.25-introducing-use-expressions/) any obvious way of nesting like that in Gleam.
- lpil 3y agoUnlike in Haskell `{}` are not optional in Gleam, so that would be written like so: use a <- one({ use b <- two // etc })
- tome 3y agoThanks. I don't fully grasp what `one` is, but do notation has the nice property that do r <- do foo bar quux r is the same as do foo r <- bar quux r It doesn't look like that holds for use. Specifically one({ use b <- two foo }) baz is not the same as use b <- two foo baz right?
- lpil 3y agoCorrect, it’s not.
- comex 3y agoFor reference: https://tour.gleam.run/advanced-features/use/ https://tour.gleam.run/advanced-features/use/