[Question]
  [
What general tips do you have for golfing in Haskell? I am looking for ideas that can be applied to code golf problems in general that are at least somewhat specific to Haskell. Please post only one tip per answer.
---
If you are new to golfing in Haskell, please have a look at the **[Guide to Golfing Rules in Haskell](https://codegolf.meta.stackexchange.com/a/11935/56433)**. There is also a dedicated Haskell chat room: [Of Monads and Men](https://chat.stackexchange.com/rooms/66515/of-monads-and-men).
  
[Answer]
# Define infix operators instead of binary functions
This saves usually one or two spaces per definition or call.
```
0!(y:_)=y
x!(y:z)=(x-1)!z
```
vs.
```
f 0(y:_)=y
f x(y:z)=f(x-1)z
```
---
The available symbols for 1-byte operators are `!`, `#`, `%`, `&`, and `?`. All other ASCII punctuation is either already defined as an operator by the Prelude (such as `$`) or has a special meaning in Haskell's syntax (such as `@`).
If you need more than five operators, you could use combinations of the above, such as `!#`, or certain Unicode punctuation characters, such as these (all 2 bytes in UTF-8):
```
¡ ¢ £ ¤ ¥ ¦ § ¨ © ¬ ® ¯ ° ± ´ ¶ · ¸ ¿ × ÷
```
[Answer]
Use pointless (or -free) notation where appropriate
Often a function with one or two parameters can be written point free.
So a lookup for a list of tuples whose elements are swapped is naïvely written as:
```
revlookup :: Eq b => b -> [(a, b)] -> Maybe a
revlookup e l=lookup e(map swap l)
```
(the type is there just to help you understand what it's doing.) 
for our purposes this is much better:
```
revlookup=(.map swap).lookup
```
[Answer]
Use guards not conditionals:
```
f a=if a>0 then 3 else 7
g a|a>0=3|True=7
```
Use semicolons not indents
```
f a=do
  this
  that
g a=do this;that
```
Use boolean expressions for boolean functions
```
f a=if zzz then True else f yyy
g a=zzz||f yyy
```
(SO is being a pain about letting me post these separately)
[Answer]
# Use the list monad
A quick review:
```
xs >> ys        =  concat $ replicate (length xs) ys
xs >>= f        =  concatMap f xs
mapM id[a,b,c]  =  cartesian product of lists: a × b × c
mapM f[a,b,c]   =  cartesian product of lists: f a × f b × f c
```
Examples:
* ### Repeating a list twice
```
Prelude> "aa">>[1..5]
[1,2,3,4,5,1,2,3,4,5]
```
* ### Shorter `concatMap`
```
Prelude> reverse=<<["Abc","Defgh","Ijkl"]
"cbAhgfeDlkjI"
```
* ### Shorter `concat` + list comprehension
```
Prelude> do x<-[1..5];[1..x]
[1,1,2,1,2,3,1,2,3,4,1,2,3,4,5]
```
* ### Cartesian product
```
Prelude> mapM id["Hh","io",".!"]
["Hi.","Hi!","Ho.","Ho!","hi.","hi!","ho.","ho!"]
```
* ### List of coordinates on a lattice
```
Prelude> mapM(\x->[0..x])[3,2]
[[0,0],[0,1],[0,2],[1,0],[1,1],[1,2],[2,0],[2,1],[2,2],[3,0],[3,1],[3,2]]
```
[Answer]
# Use GHC 7.10
*The first version of GHC that contained this stuff was released on **March 27, 2015**.*
It's the latest version, and Prelude got some new additions that are useful for golfing:
## The `(<$>)` and `(<*>)` operators
These useful operators from `Data.Applicative` made it in! **`<$>` is just `fmap`, so you can replace `map f x` and `fmap f x` with `f<$>x` everywhere and win back bytes.** Also, `<*>` is useful in the `Applicative` instance for lists:
```
Prelude> (,)<$>[1..2]<*>"abcd"
[(1,'a'),(1,'b'),(1,'c'),(1,'d'),(2,'a'),(2,'b'),(2,'c'),(2,'d')]
```
## The `(<$)` operator
`x<$a` is equivalent to `fmap (const x) a`; i.e. replace every element in a container by `x`.
This is often a nice alternative to `replicate`: `4<$[1..n]` is shorter than `replicate n 4`.
## The Foldable/Traversable Proposal
The following functions got lifted from working on lists `[a]` to general `Foldable` types `t a`:
```
fold*, null, length, elem, maximum, minimum, sum, product
and, or, any, all, concat, concatMap
```
This means they now also work on `Maybe a`, where they behave just like "lists with at most one element". For example, `null Nothing == True`, or `sum (Just 3) == 3`. Similarly, `length` returns 0 for `Nothing` and 1 for `Just` values. Instead of writing `x==Just y` you can write `elem y x`.
You can also apply them on tuples, which works as if you'd called `\(a, b) -> [b]` first. It's almost completely useless, but `or :: (a, Bool) -> Bool` is one character shorter than `snd`, and `elem b` is shorter than `(==b).snd`.
## The Monoid functions `mempty` and `mappend`
Not often a life-saver, but if you can infer the type, `mempty` is one byte shorter than `Nothing`, so there's that.
[Answer]
Use `1<2` instead of `True` and `1>2` instead of `False`.
```
g x|x<10=10|True=x
f x|x<10=10|1<2=x
```
[Answer]
# `interact :: (String → String) → IO ()`
People often forget that this function exists - it grabs all of stdin and applies it to a (pure) function. I often see `main`-code along the lines of
```
main=getContents>>=print.foo
```
while
```
main=interact$show.foo
```
is quite a bit shorter. It is in the Prelude so no need for imports!
[Answer]
# Use list comprehensions (in clever ways)
Everyone knows they're useful syntax, often shorter than `map` + a lambda:
```
Prelude> [[1..x]>>show x|x<-[1..9]]
["1","22","333","4444","55555","666666","7777777","88888888","999999999"]
```
Or `filter` (and optionally a `map` at the same time):
```
Prelude> [show x|x<-[1..60],mod 60x<1]
["1","2","3","4","5","6","10","12","15","20","30","60"]
```
But there are some weirder uses that come in handy now and then. For one, a list comprehension doesn't need to contain any `<-` arrows at all:
```
Prelude> [1|False]
[]
Prelude> [1|True]
[1]
```
Which means instead of `if p then[x]else[]`, you can write `[x|p]`. Also, to count the number of elements of a list satisfying a condition, intuitively you would write:
```
length$filter p x
```
But this is shorter:
```
sum[1|y<-x,p y]
```
[Answer]
## Match a constant value
A list comprehension can pattern match on a constant.
---
```
[0|0<-l]
```
This extracts the 0's of a list `l`, i.e. makes a list of as many 0's as are in `l`.
---
```
[1|[]<-f<$>l] 
```
This makes a list of as many `1`'s as there are elements of `l` that `f` takes to the empty list (using `<$>` as infix `map`). Apply `sum` to count these elements.
Compare:
```
[1|[]<-f<$>l]
[1|x<-l,f x==[]]
```
---
[Answer]
# Know your `Prelude`
Fire up GHCi and scroll through the [Prelude documentation](https://hackage.haskell.org/package/base-4.8.0.0/docs/Prelude.html). Whenever you cross a function that has a short name, it can pay off to look for some cases where it might be useful.
For example, suppose you wish to transform a string `s = "abc\ndef\nghi"` into one that's space-separated, `"abc def ghi"`. The obvious way is:
```
unwords$lines s
```
But you can do better if you abuse `max`, and the fact that `\n < space < printable ASCII`:
```
max ' '<$>s
```
Another example is [`lex :: String -> [(String, String)]`](https://hackage.haskell.org/package/base-4.8.0.0/docs/Prelude.html#v:lex), which does something quite mysterious:
```
Prelude> lex "   some string of Haskell tokens  123  "
[("some"," string of Haskell tokens  123  ")]
```
Try `fst=<<lex s` to get the first token from a string, skipping whitespace. [Here](http://golf.shinh.org/reveal.rb?Divide+section/henkma_1292522156&hs) is a clever solution by henkma that uses `lex.show` on `Rational` values.
[Answer]
# Arguments can be shorter than definitions
I just got outgolfed in a very curious way by [henkma](http://golf.shinh.org/reveal.rb?String+in+String+in+String/henkma_1487067285&hs).
If an auxiliary function `f` in your answer uses an operator that isn’t used elsewhere in your answer, and `f` is called once, make the operator an argument of `f`.
This:
```
(!)=take
f a=5!a++3!a
reverse.f
```
Is two bytes longer than this:
```
f(!)a=5!a++3!a
reverse.f take
```
[Answer]
Use `words` instead of a long list of strings. This isn't really specific to Haskell, other languages have similar tricks too.
```
["foo","bar"]
words"foo bar"  -- 1 byte longer
```
```
["foo","bar","baz"]
words"foo bar baz"  -- 1 byte shorter
```
```
["foo","bar","baz","qux"]
words"foo bar baz qux"    -- 3 bytes shorter
```
[Answer]
## Shorter conditional
```
last$x:[y|b]
```
is equivalent to
```
if b then y else x
```
Here's how it works:
```
             [y|b]   x:[y|b]   last$x:[y|b]
if...      +--------------------------------
b == False | []      [x]       x
b == True  | [y]     [x,y]     y
```
[Answer]
# Know your monadic functions
1)  
simulate monadic functions using `mapM`.
a lot of times code will have `sequence(map f xs)`, but it can be replaced with `mapM f xs`. even when just using `sequence` alone it is longer then `mapM id`.
2)  
combine functions using `(>>=)` (or `(=<<)`)
the function monad version of `(>>=)` is defined as so:
```
(f >>= g) x = g (f x) x 
```
it can be useful for creating functions which can't be expressed as a pipeline. for example, `\x->x==nub x` is longer than `nub>>=(==)`, and `\t->zip(tail t)t` is longer than `tail>>=zip`.
[Answer]
# Shorter conditionals when one outcome is the empty list
When you need a conditional which returns the list `A` or the empty list `[]` depending on some condition `C`, then there exist some shorter alternatives to the usual conditional constructs:
```
if(C)then(A)else[] -- the normal conditional
last$[]:[A|C]      -- the golfy all-round-conditional
concat[A|C]        -- shorter and works when surrounded by infix operator
id=<<[A|C]         -- even shorter but might conflict with other infix operators
[x|C,x<-A]         -- same length and no-conflict-guarantee™
[0|C]>>A           -- shortest way, but needs surrounding parenthesis more often than not
do[0|C];A          -- longer but works in some places where the above would need parents
```
Examples: [1](https://codegolf.stackexchange.com/a/150747/56433), [2](https://codegolf.stackexchange.com/a/150784/56433)
[Answer]
## Don't waste the "otherwise" guard
A final guard that's a catch-all `True` (shorter as `1>0`) can be used to bind a variable. Compare:
```
... |1>0=1/(x+y)
... |z<-x+y=1/z
... |1>0=sum l-sum m
... |s<-sum=s l-s m
```
Since the guard is mandatory and is otherwise wasted, little is needed to make this worth it. It's enough to save a pair of parens or bind a length-3 expression that's used twice. Sometimes you can negate guards to make the final case be the expression that best uses a binding.
[Answer]
# Use the cons operator (:)
when concatenating lists, if the first is of length 1 then use `:` instead.
```
a++" "++b
a++' ':b  -- one character shorter
[3]++l
3:l    -- three characters shorter
```
[Answer]
Don't use backticks too often.
Backticks are a cool tool for making sections of prefix functions, but can sometimes be misused.
Once I saw someone write this subexpression:
```
(x`v`)
```
Although it is the same as just `v x`.
Another example is writing `(x+1)`div`y`
as opposed to `div(x+1)y`.
I see it happen around `div` and `elem` more often because these functions are usually used as infix in regular code.
[Answer]
# Use [pattern guards](https://wiki.haskell.org/Pattern_guard)
They're shorter than a `let` or a lambda that deconstructs the arguments of a function you're defining. This helps when you need something like `fromJust` from `Data.Maybe`:
```
f x=let Just c=… in c
```
is longer than
```
f x=(\(Just c)->c)$…
```
is longer than
```
m(Just c)=c;f x=m$…
```
is longer than
```
f x|Just c<-…=c
```
In fact, they’re shorter even when binding a plain old value instead of deconstructing: see [xnor’s tip](https://codegolf.stackexchange.com/a/76749/3852).
[Answer]
# Use GHC 8.4.1 (or later)
With the [Semigroup Monoid Proposal](https://prime.haskell.org/wiki/Libraries/Proposals/SemigroupMonoid) and the release of [GHC 8.4.1](https://downloads.haskell.org/%7Eghc/8.4.1/docs/html/users_guide/8.4.1-notes.html), `Semigroup` has been moved to the `Prelude`. This gives us:
```
(<>) :: Semigroup a => a -> a -> a
```
Now these might seem useless at first glance, but looking closer we notice that `Monoid a => (x -> a)` is an instance of `Monoid`1, in which case we have the implementation:
```
(f <> g) xs = f xs <> g xs
```
This can be quite useful with for example lists, knowing that `(<>)` is the same as `(++)` for lists. So we have for example:
```
(init <> reverse) [1,2,3] ≡ init [1,2,3] <> reverse [1,2,3]
                          ≡ [1,2] <> [3,2,1]
                          ≡ [1,2] ++ [3,2,1]
                          ≡ [1,2,3,2,1]
```
However, this is not the only useful case: Knowing that `[x] -> [x]` is an instance of `Monoid`, we also have `a -> [x] -> [x]` an instance of `Monoid` (you can iterate this as many times as you want):
```
(drop <> take) 2 [1,2,3,4,5] ≡ (drop 2 <> take 2) [1,2,3,4,5]
                             ≡ drop 2 [1,2,3,4,5] <> take 2 [1,2,3,4,5]
                             ≡ [3,4,5] <> [1,2]
                             ≡ [3,4,5,1,2]
```
1: Note that `Monoid a` \$\implies\$ `Semigroup a`.
## Overview what we gained so far
Using this trick we have these (not exhaustive) helpers, note that we can chain them:
```
duplicate    = id <> id
triple²      = id <> id <> id
palindromize = init <> reverse
rotateLeft   = drop <> take
removeElementAt = take <> drop . succ
removeNElementsAt n = take <> drop . (+n)
```
2: This could ~~also be `([1..3]>>)` for the same bytecount~~ be shorter (see comment by [Ørjan Johansen](https://codegolf.stackexchange.com/users/66041/%C3%98rjan-johansen)).
## Where are the \$(\mathbb{Z},\texttt{+})\$ and \$(\mathbb{Z},\texttt{\*})\$ monoids?
If we want to use the \$(\mathbb{Z},\texttt{+})\$ monoid, we need to tell GHC that. It can not decide for us which one it should use, therefore there are two `newtype`s which allow this - `Sum` and `Product`.
Given that the consensus is [to allow implicitly typed functions](https://codegolf.meta.stackexchange.com/questions/11223/untyped-functions-in-static-languages/12747#12747), we are probably allowed to do so if the challenge does not talk about a specific implementation for integers. Using this we can for example write \$n\$th [oblong number](https://oeis.org/A002378) as
```
id<>(+1)
```
which is shorter than `f n=n*(n-1)` or even `(*)=<<succ`/`(*)<*>succ`.
[Try it online!](https://tio.run/##XY8xT8NADIX3@xVPVYdEkFO7RmkmFoYKpA4MBCHT3KUnkjvr4gj1zxOutBlgsAe/7/nZJxo/Td/PbuAQBQ8kpPfBB9ciw3MM7XSUTOv8HllV58iVUhZluUh49GI6E1HU/0fK7prZtVWd3W3zeSDnsUMbFFAUeInEcFdwBI2LuZAzG5BvQcz9GTbhA/H@HRnHxEPDprrROV43Wm83b@q69UCDwcckoH4MmPzXJUVOZoANERyNiEu3hkl4kmRJ/SARq8Y/xRvOpi0bWV3E37w1OiPLZ3/CUa3rJX/@PtqeunEujsw/ "Haskell – Try It Online")3
3: Note that we need to use `(+1)` and cannot use `succ` since GHC can't know that there is an instance of `Enum`.
## Other noteworthy related tricks
Instances that might be useful not covered above:
```
()
Ordering
(Monoid a, Monoid b) => Monoid (a,b)  -- (also 3-,4- and 5-tuples)
Monoid a => Monoid (IO a)
Ord k => Monoid (Map k v)             -- from Data.Map
```
---
It might be worth noting that there is `mconcat` too:
```
mconcat [f1,f2,…,fN] ≡ f1 <> f2 <> … <> fN
```
This will probably not be useful often, for it needs at least \$3-11\$ functions (depending on the need of parentheses, see comments), but it might be in case you have some list `Monoid a => [a]` already.
---
Furthermore `mempty` can be useful since it is shorter than `Nothing` or even `pure Nothing`, `([],[])` etc.
---
Another useful instance is `Monoid a => Monoid (IO a)` which has successfully been used for the currently [shortest quine](https://codegolf.stackexchange.com/a/161036/48198) as
```
(putStr <> print) "foo" ≡ putStr "foo" <> print "foo"
                        ≡ do x <- putStr "foo"
                             y <- print "foo"
                             pure $ x <> y
                        ≡ do putStr "foo"
                             print "foo"
                             pure ()
                        ≡ putStr "foo" >> print "foo"
```
[Answer]
# Shorter syntax for local declarations
Sometimes you need to define a local function or operator, but it costs lots of bytes to write `where` or `let…in` or to lift it to top-level by adding extra arguments.
```
g~(a:b)=2!g b where k!l=k:take(a-1)l++(k+1)!drop(a-1)l
g~(a:b)=let k!l=k:take(a-1)l++(k+1)!drop(a-1)l in 2!g b
g~(a:b)=2!g b$a;(k!l)a=k:take(a-1)l++((k+1)!drop(a-1)l)a
```
Fortunately, Haskell has a confusing and seldom-used but reasonably terse syntax for [local declarations](https://www.haskell.org/onlinereport/haskell2010/haskellch3.html#x8-460003.13):
```
fun1 pattern1 | let fun2 pattern2 = expr2 = expr1
```
In this case:
```
g~(a:b)|let k!l=k:take(a-1)l++(k+1)!drop(a-1)l=2!g b
```
You can use this syntax with multi-statement declarations or multiple declarations, and it even nests:
```
fun1 pattern1 | let fun2 pattern2 = expr2; fun2 pattern2' = expr2' = expr1
fun1 pattern1 | let fun2 pattern2 = expr2; fun3 pattern3 = expr3 = expr1
fun1 pattern1 | let fun2 pattern2 | let fun3 pattern3 = expr3 = expr2 = expr1
```
It also works for binding variables or other patterns, though [pattern guards](https://codegolf.stackexchange.com/a/54684/39242) tend to be shorter for that unless you’re also binding functions.
[Answer]
# Lambda parsing rules
A lambda-expression doesn't actually need parentheses around it - it just rather greedily grabs everything so the whole thing still parses, e.g. until
* a closing paren - `(foo$ \x -> succ x)`
* an in - `let a = \x -> succ x in a 4`
* the end of the line - `main = getContents>>= \x -> head $ words x`
* etc..
is encountered, and there are some weird edge-cases where this can save you a byte or two. I believe `\` can also be used to define operators, so when exploiting this you will need a space when writing a lambda directly after an operator (like in the third example).
[Here is an example](https://codegolf.stackexchange.com/questions/32757/etaoin-shrdlu-golf/32771#32771) of where using a lambda was the shortest thing I could figure out. The code basically looks like:
```
a%f=...
f t=sortBy(% \c->...)['A'..'Z']
```
[Answer]
## Working with the minus sign
The minus sign `-` is an annoying exception to many syntax rules.
This tip lists some short ways of expressing negation and subtraction in Haskell.
Please let me know if I've missed something.
### Negation
* To negate an expression `e`, just do `-e`. For example, `-length[1,2]` gives `-2`.
* If `e` is even moderately complex, you will need parentheses around `e`, but you can usually save a byte by moving them around: `-length(take 3 x)` is shorter than `-(length$take 3 x)`.
* If `e` is preceded by `=` or an infix operator of [fixity](https://www.haskell.org/onlinereport/decls.html#fixity) less than 6, you need a space: `f= -2` defines `f` and `k< -2` tests if `k` is less than `-2`. If the fixity is 6 or greater, you need parens: `2^^(-2)` gives `0.25`. You can usually rearrange stuff to get rid of these: for example, do `-k>2` instead of `k< -2`.
* Similarly, if `!` is an operator, then `-a!b` is parsed as `(-a)!b` if the fixity of `!` is at most 6 (so `-1<1` gives `True`), and `-(a!b)` otherwise (so `-[1,2]!!0` gives `-1`). The default fixity of user-defined operators and backticked functions is 9, so they follow the second rule.
* To turn negation into a function (to use with `map` etc), use the section `(0-)`.
### Subtraction
* To get a function that subtracts `k`, use the section `(-k+)`, which adds `-k`. `k` can even be a pretty complex expression: `(-2*length x+)` works as expected.
* To subtract 1, use `pred` instead, unless it would require a space on both sides. This is rare and usually happens with `until` or a user-defined function, since `map pred x` can be replaced by `pred<$>x` and `iterate pred x` by `[x,x-1..]`. And if you have `f pred x` somewhere, you should probably define `f` as an infix function anyway. See [this tip](https://codegolf.stackexchange.com/a/19259/32014).
[Answer]
## Try rearranging function definitions and/or arguments
You can sometimes save a couple of bytes by changing the order of pattern-matching cases in a function definition.
These savings are cheap, but easy to overlook.
As an example, consider the following earlier version of (a part of) [this answer](https://codegolf.stackexchange.com/a/58605/32014):
```
(g?x)[]=x
(g?x)(a:b)=g(g?x$b)a
```
This is a recursive definition of `?`, with the base case being the empty list.
Since `[]` is not a useful value, we should swap the definitions and replace it with the wildcard `_` or a dummy argument `y`, saving a byte:
```
(g?x)(a:b)=g(g?x$b)a
(g?x)y=x
```
From the same answer, consider this definition:
```
f#[]=[]
f#(a:b)=f a:f#b
```
The empty list occurs in the return value, so we can save two bytes by swapping the cases:
```
f#(a:b)=f a:f#b
f#x=x
```
Also, the order of function arguments can sometimes make a difference by allowing you to remove unnecessary whitespace. Consider an earlier version of [this answer](https://codegolf.stackexchange.com/a/60833/32014):
```
h p q a|a>z=0:h p(q+2)(a-1%q)|1<2=1:h(p+2)q(a+1%p)
```
There's an annoying piece of whitespace between `h` and `p` in the first branch.
We can get rid of it by defining `h a p q` instead of `h p q a`:
```
h a p q|a>z=0:h(a-1%q)p(q+2)|1<2=1:h(a+1%p)(p+2)q
```
[Answer]
## Use `,` instead of `&&` in guards
Multiple conditions in a guard that all have to hold can be combined with `,` instead of `&&`.
```
f a b | a/=5 && b/=7 = ...
f a b | a/=5 ,  b/=7 = ...
```
[Answer]
# Avoid `repeat n`
```
-- 8 bytes, whitespace might be needed before and after
repeat n
-- 8 bytes, whitespace might be needed before
cycle[n]
-- 7 bytes, whitespace might be needed before and after, can be reused,
-- needs an assignment, n needs to be global
l=n:l;l
-- 7 bytes, never needs whitespace, n needs to derive from Enum,
-- n has to be short enough to be repeated twice
[n,n..]
```
Either of those four expressions will produce an infinite list of `n`'s.
It's a very specific tip but it can save up to **3** bytes!
[Answer]
## Get suffixes
Use `scanr(:)[]` to get the suffixes of a list:
```
λ scanr(:)[] "abc"
["abc","bc","c",""]
```
This is much shorter than `tails` after `import Data.List`. You can do prefixes with `scanr(\_->init)=<<id` (found by Ørjan Johansen).
```
λ  scanr(\_->init)=<<id $ "abc"
["","a","ab","abc"]
```
This saves a byte over
```
scanl(\s c->s++[c])[]
```
[Answer]
## Bind using guards
When defining a named function, you can bind an expression to a variable in a guard. For example,
```
f s|w<-words s=...
```
does the same as
```
f s=let w=words s in ...
f s=(\w->...)$words s
```
Use this to save on repeated expressions. When the expression is used twice, it breaks even at length 6, though spacing and precedence issues can change that.
(In the example, if the original variable `s` is not used, it's shorter to do
```
g w=...
f=g.words
```
but that's not true for binding more complex expressions.)
[Answer]
# Use `(0<$)` instead of `length` for comparisons
When testing if a list `a` is longer than a list `b`, one would usually write
```
length a>length b
```
However replacing each element of both lists with same value, e.g. `0`, and then comparing those two lists can be shorter:
```
(0<$a)>(0<$b)
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P1HBViHaUMdIxziWKwnKjuXKTczMA3JS8rkUCooy80oUVBRyUvPSSzIUEu2gjCSElIaBjUqiph2IStL8/x8A "Haskell – Try It Online")
The parenthesis are needed because `<$` and the comparison operators (`==`, `>`, `<=`, ...) have the same precedence level 4, though in some other cases they might not be needed, saving even more bytes.
[Answer]
# Shorter `transpose`
To use the `transpose` function `Data.List` has to be imported. If this is the only function needing the import, one can save a byte using the following `foldr` definition of `transpose`:
```
import Data.List;transpose
e=[]:e;foldr(zipWith(:))e
```
Note that the behaviour is only identical for a list of lists with the same length.
I successfully used this [here](https://codegolf.stackexchange.com/a/106587/56433).
]