Add appliedTo and chain aliases

[NickSeagull]

Hi 👋

I wanted to request the addition of the following function aliases:

appliedTo = (<*>)

and

chain = (=<<)

The reason behind this, is that I found them much easier to understand for newcomers, and they are much better in my experience with teaching Haskell, as one can resemble fluent APIs from other languages with them:

Just(drop 1)
& appliedTo (Just [1,2,3])
& chain head

vs

(Just [1,2,3] <*> Just (drop 1)) >>= head

I really love relude , I really wish it becomes the standard for preludes out there. For me it is always the prelude of choice, and would love that it had nice little features like these that make the adoption of Haskell much easier 😊

If this is okay for you, I can work on a PR. Where should these aliases go? 🤔

[vrom911]

@NickSeagull Thanks for such kind words 😊

Regarding your proposal, I think that these functions make perfect sense and should be pretty useful for understanding indeed! I see that appliedTo is not intersecting with any existing common functions. But chain is used quite a lot (I see it in streaming, pipes libraries, and some more as well), probably chained or chainedTo will do? What do you think?

[chshersh]

@NickSeagull It's so nice to hear kind words about our project 😊

As @vrom911 pointed out, appliedTo is not present on Hackage, so it's okay to take this name. I guess Relude.Applicative would be the best place for this function 👍 Often <*> is called apply (or spaceship or star cyclops) but looks like apply is taken for & in the ecosystem:

• https://github.com/tfausak/flow#cheat-sheet

Regarding chain: this name is much more popular and looks more generic (also often used not only in streaming libraries, but also in parser-combinator libraries). So I tend to vote more for chained or chainedTo (for naming consistency). Usually >>= is called andThen but from your examples I see that you defined natural language aliases for flipped versions of >>= and <*>. Though, with human-readable names we indeed can write more beginner-friendly code:

Just ["garbage", "2"] `appliedTo` Just (drop 1) `chainedTo` viaNonEmpty head `chainedTo` readMaybe

(or you can replace chainedTo with andThen but I kinda like chainedTo)

I guess chainedTo can go to Relude.Monad module. Also, since we care a lot about good documentation, it would be really nice to see good Haddock with doctest examples for both functions.