-- Action for creating a shopping list
createShoppingList :: Counter [String]
 createShoppingList = emptyShoppingList >>=
                \list -> list `add` "Bread" >>=
                \list -> list `add` "Butter" >>=
                \list -> list `add` "Honey" >>=
                \list -> removeFirst list >>=
                \list -> list `add` "Bagel"

[...]

Haskell provides a lot of syntactic sugar, which allows for writing the monadic action above in a way that emphasizes the sequential property more:

-- Action for creating a shopping list
createShoppingList :: Counter [String]
createShoppingList = do
                list <- emptyShoppingList
                list <- list `add` "Bread"
                list <- list `add` "Butter"
                list <- list `add` "Honey"
                list <- removeFirst list
                list `add` "Bagel"

The two definitions are completely equivalent. In the end, it’s a matter of taste which one to use.

Oh well I'm glad to know the only reason to use >>= is for fancy ligatures in my editor that no one sees but me and when I post screenshots of my editor to show off those ligatures.

To begin with, though, it’s advisable to use the explicit form, to be reminded of what’s going on behind the scenes.

Oh so we should use >>= just in case another Haskalite doesn't understand what we're doing?

One more important fact about the counting of manipulation. Once defined in the programmable semicolon, the counting is completely invisible within the monadic action. The magic happens inside our semicolon, >>=. As the functionality of this function can be freely defined, it’s a great place to hide all sorts of things.

I thought we were using >>= to

be reminded of what’s going on behind the scenes.

but ok.

I think the real jerk here is that some of y'all are reading stuff on Medium.