1

In 1998 John Hughes proposed the Arrow type class for Haskell in this paper. This type class came with a number of operators that are 'non-alpha-numeric', like *** and &&&. He however does not give a pronounceable name for these operators.

Haskell's Monad type class has a similar thing going on with >>=, which is pronounced as bind.

My question is how to pronounce the Arrow operators *** and &&&. Or do they even have pronounceable names? How do Haskellers refer to these operators in conversations?

RvanHeest
  • 869
  • 6
  • 12
  • 2
    Possible duplicate of [Are there human-friendly names for applicative (and friends) methods?](http://stackoverflow.com/questions/5836640/are-there-human-friendly-names-for-applicative-and-friends-methods) – amalloy Jun 24 '16 at 20:37
  • Although the proposed duplicate asks about `***` and `&&&`, none of the answers to that question addresses them. The author of the question makes a guess that you might consider an answer, though. – chepner Jun 24 '16 at 20:46
  • 2
    I’m voting to close this question because this is an opinion based question, and is not a programming question. – cigien Nov 13 '20 at 17:05

1 Answers1

7

Control.Arrow calls them "split" and "fanout". That's the closest you'll get for official names.

However, in the particular case of arrows, I tend to think of them in terms of factory machines connected with conveyor belts. This gives you a very rich vocabulary if you start with defining the phonemes (not necessarily the actual functions)

belt = id
pipe-into = (.)
dupe = belt &&& belt
next-to = (***)
process-with = arr

In this vocabulary you pronounce first a as "a next to a belt" and second a as "a belt next-to a", while a &&& b becomes "a dupe piped into (an a next to a b)."

It also gives a nice visualization of ArrowApply; the factory machines can ArrowApply when there is some machine which takes in two conveyor belts: one for other machines, and one for objects that fit into the first machine. This machine stuffs the incoming object into the incoming machine, emits whatever the first machine emits, then throws the machine away.

It also gives a less-nice visualization of ArrowLoop in terms of giving the factory a magic box, then incrementally asking the factory to commit to some of the structure of what's inside the magic box (possibly providing more magic boxes for it to use), then making the committed structure magically available when the box is opened.

RvanHeest
  • 869
  • 6
  • 12
CR Drost
  • 9,637
  • 1
  • 25
  • 36