What is <|> in haskell?

Question

I am still learning haskell and looking at the snap web framework. In their hello world example there is a thingy that looks like <|>

site :: Snap ()
site =
    ifTop (writeBS "hello world") <|>
    route [ ("foo", writeBS "bar")
          , ("echo/:echoparam", echoHandler)
          ] <|>
    dir "static" (serveDirectory ".")

Googling for this is surprisingly challenging, and the snap documentation simply uses <|> as a noun. What is it, and what does it do?

Enough with the downvotes here people, I am here to learn something I simply could not google for. — Fresheyeball, May 17 '14 at 22:26
You have to import the module that contains this function before you can get the type of it. The downvotes are because this is a very trivial question that you could have easily answered on your own. — , May 17 '14 at 22:26
@EdgarAroutiounian how could I have answered this on my own? — Fresheyeball, May 17 '14 at 22:27
But how was I supposed to know what package to load? or that it needed to be loaded from a package? and is not a language axiom? — Fresheyeball, May 17 '14 at 22:30
You use [Hoogle](http://www.haskell.org/hoogle/?hoogle=%3C|%3E). — Vincent Savard, May 17 '14 at 22:30
@Fresheyeball hoogle also lets you search by type signature to answer questions like "is there a function that does Foo -> Bar?". Super useful. — jberryman, May 18 '14 at 15:38
@jberryman I just spend the last 3 hours just in hoogle. So much to learn, and what a great tool. — Fresheyeball, May 18 '14 at 17:41
@Fresheyeball One other point. You don't have to know where <|> is defined to use :t on it in ghci. All you have to do is find a module where it is being used and load that module. Then you can use :t to see the type and you can use :i to see where it came from. — mightybyte, May 18 '14 at 18:44
@mightybyte I understand that now. I've never seen anything like `<|>`, so didn't know to look in modules. I was just at a loss. — Fresheyeball, May 19 '14 at 00:08
@Fresheyeball Yeah, with Haskell it takes a bit to learn the best ways of finding things. — mightybyte, May 19 '14 at 16:17

score 9 · Accepted Answer · answered May 17 '14 at 22:24

It's a method in the Alternative typeclass in the module Control.Applicative in the base package.

Typically it means that you're dealing with a kind of computation which can fail and continue. If both x and y are typed as m a where m tags this kind of computation we're talking about then

x <|> y :: m a

is a computation which "tries" x and if it fails then "tries" y. Such kinds of computation instantiate Alternative.

score 2 · Answer 2 · answered May 18 '14 at 10:24

2

Quoting the Snap tutorial

If you’re not familiar with Haskell, you may be wondering about the <|>. It is simply a binary operator that evaluates its first argument, and if it failed, evaluates the second. If the first argument succeeded, then it stops without evaluating the second argument.

The site function uses <|> to connect three different functions that guard what page gets rendered. First, the ifTop function runs. This function succeeds if the requested URL is http:// site.com. If that happens, then Snap sends a response of “hello world”. Otherwise the route function is executed.

answered May 18 '14 at 10:24

chi

111,837
3
133
218

+1 yes I see that now. This is what I get for reading the code and ignoring the copy. – Fresheyeball May 18 '14 at 17:42
The description is not quite correct - what exactly `<|>` does depends on the instance, and for `[]` for example, it simply ignores empty lists: `[] <|> [1,2,3] == [1,2,3]`. – Xeo May 19 '14 at 07:30
1

The quoted text just describes the relevant instance for Snap. – chi May 19 '14 at 08:27

David Schalk · Answer 3 · 2014-08-10T04:25:05.533

I agree with Xeo to the extent that <|> has the effect of ignoring the empty list in [] <|> [1,2,3], but under the hood the compiler might be concatenating the empty list with the non-empty list. I have ghci set up to automatically display the types of what it prints. Here are some results which suggest that, in the case of lists, <|> and ++ might be equivalent:

λ: [] <|> [3,4]
[3,4]
it :: Num a => [a]
λ: [] ++ [3,4]
[3,4]
it :: Num a => [a]
λ: [1,2] <|> [3,4]
[1,2,3,4]
it :: Num a => [a]
λ: [1,2] ++ [3,4]
[1,2,3,4]
it :: Num a => [a]
λ: :t (<|>) [1,2] [3,4]
(<|>) [1,2] [3,4] :: Num a => [a]
λ: :t (++) [1,2] [3,4]
(++) [1,2] [3,4] :: Num a => [a]
λ: [1,2] <|> [] <|> [3,4]
[1,2,3,4]

Well, <|> has the effect of ++ in the above examples, but there is more than that going on. At https://hackage.haskell.org/package/parsec-3.0.0/docs/Text-ParserCombinators-Parsec-Prim.html we read this about <|>: "This combinator is defined equal to the mplus member of the MonadPlus class and the (Control.Applicative.<|>) member of Control.Applicative.Alternative." Turning to the Hackage "Control.Monad" discussion we read: "msum :: MonadPlus m => [m a] -> m a Source" followed by "This generalizes the list-based concat function." The answer to the question, "What does <|> do?", is rooted in understanding what Haskell compilers do when they encounter <|>, say in "[] <|> [1,2,3]"? Do they just ignore []? Do they execute the concatenation routine? There are steps involved in just figuring out what do do with this strangely overloaded operator. It's no wonder that programmers are mystified by it, and settle for knowing little more than the effect of employing it in special use cases.

<|> is useful for jumping out of recursive loops as soon as a condition is satisfied. Here's some code to suggest how this works:

λ: Nothing <|> Just 6 <|> Just 7
Just 6
it :: Num a => Maybe a

λ: Nothing <|> Just [1,2] <|> Nothing <|> Just [3,4]
Just [1,2]
it :: Num t => Maybe [t]

What is <|> in haskell?

3 Answers3