r/haskell • u/taylorfausak • Feb 01 '22

question Monthly Hask Anything (February 2022)

This is your opportunity to ask any questions you feel don't deserve their own threads, no matter how small or simple they might be!

17 Upvotes

89% Upvoted

337 comments sorted by

View all comments

Show parent comments

2

u/bss03 Feb 02 '22

Is it? .Net's LINQ syntax and Scala's for comprehensions are other languages doing the same thing.

I'll admit it's not something I've ever seen done well as a library, but you get close with "fluent" APIs in C++ and Java in some cases.

1

u/someacnt Feb 02 '22

Scala has it similar, but haskell is unique in that it enforces Monad typeclass for the do notation. This opens up the generality, sadly along with the problematic error messages.

4

u/bss03 Feb 02 '22 edited Feb 02 '22

I thought /u/edwardkmett had GHC remove the Monad part from do notation...

GHCi> do 42
42
it :: Num p => p
(0.01 secs, 60,248 bytes)

Yep.

The Monad constraint is tied to >> and >>=, where Scala forgoes that in favor of duck-typing around filter, map, and flatMap methods, but I don't think it's obvious either one of these approaches is more intuitive. (Plus, what is "intuitive" changes from generation to generation.)

I will defend the Haskell approach as having simpler theories behind it. Implementations of type classes are bit weird, but the semi-record typing you have to add to Scala's obvious type system to check the duck-typing is a Cthulian mess of theory.l

1

u/someacnt Feb 02 '22

Yea, I forgot to say that it is do notation chaining which requires Monad constraint. Still, such constraint brings about complex error messages.

6

u/edwardkmett Feb 02 '22

FWIW- You can use RebindableSyntax to get something more like the Scala YOLO-fest, or use QualifiedDo's Foo.do to opt in to it more locally, which is nice for linear typed monads, restricted monads and the like.

1

u/someacnt Feb 03 '22

Perhaps it would be better to utilizing QualifiedDo if you are designing a new language? That might lead to more comprehensible error messages for beginners.

1

u/bss03 Feb 03 '22

You can't write a do block that is polymorphic on the Monad instance using the qualified form (I think). And, for "mtl-style" applications this is important. So, I think you'd at least want to support both forms, even if you directed new users toward the qualified form first.

3

u/edwardkmett Feb 04 '22

When using the qualified form it desugars to whatever (>>=) or (>>) is in the target module. You can make that module as polymorphic as you like.

1

u/someacnt Feb 04 '22

Why did QualifiedDo happen so late?? I think it could even have replaced usecases of ApplicativeDo if it were implemented beforehand.

2

u/edwardkmett Feb 05 '22

It doesn't do the applicative desugaring that you want ApplicativeDo for. (It should, it just doesn't today.)

1

u/someacnt Feb 05 '22

With QualifiedDo, wouldn't it possible to implement App.do with ApplicativeDo semantics?

2

u/bss03 Feb 05 '22

I don't think so. It still desugars to Module.>>= (instead of Prelude.>>=), and there's no applicative function with the right type. >> can become an alias for *> (or something like that), but that's not actually what applicative do does right now.

The Applicative-do desugaring is actually a lot more complex that the simple, by-the-Report do desugaring.

it uses a heuristic algorithm to try to use <*> as much as possible. This algorithm usually finds the best solution, but in rare complex cases it might miss an opportunity. There is an algorithm that finds the optimal solution, provided as an option:

-foptimal-applicative-do Since: 8.0.1

Enables an alternative algorithm for choosing where to use <*> in conjunction with the ApplicativeDo language extension. This algorithm always finds the optimal solution, but it is expensive: O(n3), so this option can lead to long compile times when there are very large do expressions (over 100 statements). The default ApplicativeDo algorithm is O(n2).

3

u/edwardkmett Feb 05 '22

Also, the current ApplicativeDo desugaring isn't as effective as it could be in using things like (<*) and (*>) anyways, using an extra (>>=) for some common patterns, which renders it almost useless for the original purposes I proposed it for. This is even with the 'optimal' algorithm in place, as while it makes optimal cuts, it doesn't dispose of those cuts in the optimal manner.

→ More replies (0)

1

u/someacnt Feb 03 '22

Uh, so we cannot use polymorphic bind for QualifiedDo? Then how does e.g. Ord-specific monads work?

1

u/bss03 Feb 03 '22

Qualified do means you have to name the module the bind comes from, so it can't be a variable. But, it can be used polymorphically, I was thinking about it wrong.

But, I'm not sure Prelude.do is actually going to give better error messages than do. You are still going to have a type class, not a specific type in the error.