All the Haskell golf tips I know of:
- Tips for golfing in Haskell on codegolf.stackexchange.com
- Haskell golf メモ by henkma (in Japanese, archived).
- mroman's Haskell golf tips (archived).
Here's some advice that is often useful on code.golf specifically.
import System.Environment main=getArgs>>=mapM(putStrLn.f).tail -- Apply `putStrLn.f` to each arg but the first main=do _:a<-getArgs;mapM putStrLn[f x a|x<-a] -- Also useful sometimes, if you need `a`.
Printing a bunch of numbers line by line
main=mapM print[n|n<-[1..100],some condition on n]
Iterating and halting
Write a recursive function without an "otherwise" guard to halt when a condition becomes false.
-- Count down from 5 to 1: main=f 5 f x|x>0=print x>>f(x-1)
1 and then crashes with
Non-exhaustive patterns in function f.
Try It Online and anagol don't export
<> in Prelude yet, but code.golf does, and it is often useful.
See this post for some
id<>reverse are nice.
Haskell math operators have generic types like
(^) :: (Num a, Integral b) => a -> b -> a, which means that the types of literal arguments may be inferred in surprising ways depending on the context of the result.
Usually Haskell prefers to infer
Integer (arbitrary-precision) as a concrete type for integer literals. But when some expression fills an
Int-typed parameter, type inference propagates
Int, a signed 64-bit integer type:
main=print $ 2^64+4 -- prints 18446744073709551620 main=print $ ['a'..]!!(2^64+4) -- prints 'e', because (!!) :: [a] -> Int -> a -- so (2^64+4) must be an Int
Watch out for
Int-typed parameters in
This kind of pattern is useful:
g '@'="Haskell" g '#'="golf" g c=[c] main = putStrLn ("Tips for @ #ing, that is, code # in @.">>=g)
mapM is often useful. See this answer for a nice example.