CheatHaskell Pure functional language
Light · Postcard
102 × 152 mm · PDF
Dark · Postcard
102 × 152 mm · PDF
Ink saver · Postcard
102 × 152 mm · PDF
Light · A4 landscape
297 × 210 mm · PDF
Dark · A4 landscape
297 × 210 mm · PDF
Ink saver · A4 landscape
297 × 210 mm · PDF
Light · A3 landscape
420 × 297 mm · PDF
Dark · A3 landscape
420 × 297 mm · PDF
Ink saver · A3 landscape
420 × 297 mm · PDF
Start here
ghciInteractive REPL
ghc -O2 -o <out> Main.hs
Optimised build
runghc <file.hs>
Run a script
:t <expr>Show a type in GHCi
:rReload changed modules
cabal runBuild and run
cabal replGHCi for the project
ghcup tuiManage toolchains
Concepts
ghcup
installs ghc, cabal, stack, hls
cabal or stack
resolve packages, build, test
ghc
compiles modules, ghci is its REPL
GHC
ghc <file.hs>
Compile a program
Output goes next to the source.
ghc -o <out> <file.hs>
Name the executable
ghc -O2 <file.hs>
Optimise heavily
-O1 is the usual -O; the default is -O0.
ghc -Wall <file.hs>
Enable common warnings
ghc -e '<expr>'
Evaluate an expression and exit
ghc -c <file.hs>
Compile to an object file only
ghc --make Main.hs
Build all imported modules
Default when given source files.
ghc -i<dir> Main.hs
Add a module search directory
ghc -outputdir <dir> Main.hs
Put .o and .hi files elsewhere
ghc -threaded -rtsopts Main.hs
Threaded runtime with RTS flags
ghc -package <pkg> Main.hs
Expose a package
ghc -prof -fprof-auto Main.hs
Build with profiling
ghc -fno-code <file.hs>
Type-check only
ghc -XOverloadedStrings Main.hs
Enable a language extension
runghc <file.hs>
Run a source file directly
GHCi
ghciStart the REPL
:l <file>Load a module
:rReload the loaded modules
:t <expr>Show the type of an expression
:i <name>Show info on a name or class
:k <type>Show the kind of a type
:qQuit GHCi
Ctrl+D also works.
:browse <Module>
List what a module exports
:doc <name>
Show documentation for a name
:set +tPrint the type of each result
:m + <Module>
Bring a module into scope
:main <args>
Run main with arguments
:set -X<Ext>
Enable an extension
:! <cmd>Run a shell command
let x = 5Bind a name at the prompt
itResult of the last expression
Cabal
cabal initCreate a package
cabal buildBuild the targets
cabal run <exe>
Build and run an executable
Program arguments go after the target.
cabal testBuild and run test suites
cabal replGHCi with the package loaded
cabal updateRefresh the package index
cabal install <pkg>
Install an executable
cabal install --lib <pkg>
Add a library to the environment
cabal cleanRemove dist-newstyle
cabal haddockBuild API docs
cabal benchRun benchmarks
cabal freezePin solver versions
cabal list <text>
Search packages
cabal build --enable-profiling
Build with profiling
cabal run -- <args>
Separate program arguments
Stack and ghcup
stack new <name>
Create a project
stack buildBuild the project
Fetches the snapshot's GHC if needed.
stack runBuild and run
stack testBuild and run tests
stack ghciOpen GHCi for the project
stack exec <cmd>
Run a command in Stack's environment
stack install <pkg>
Install an executable
stack cleanDelete build artefacts
stack pathShow Stack's locations
ghcup listList available tools and versions
ghcup install ghc <ver>
Install a GHC version
ghcup set ghc <ver>
Select the active GHC
ghcup install cabal
Install cabal-install
ghcup upgradeUpdate ghcup itself
Types and classes
f :: Int -> Int
Type signature
data T = A | B Int
Sum type with a constructor field
data P = P { x :: Int }
Record with field accessors
newtype N = N Int
Zero-cost wrapper type
type S = StringType synonym
class C a whereDeclare a typeclass
instance C T where
Implement a class for a type
deriving (Show, Eq, Ord)
Auto-generate instances
f :: (Show a) => a -> String
Constrain a type variable
Maybe aValue that may be missing
Just x or Nothing.
Either e aSuccess or failure
Left is the error by convention.
[a]List of a
(a, b)Tuple
IO aAction that yields an a
Syntax
f 0 = 1; f n = n * f (n-1)
Pattern matching clauses
case m of Just x -> x
Pattern match an expression
f x | x > 0 = 1 | otherwise = 0
Guards
\x -> x + 1
Lambda
let y = 2 in y * 2
Local binding
f = g where g = 1
Bindings scoped to a definition
if c then a else b
Conditional, always needs else
do { x <- act; return x }
Do notation for monads
[x*2 | x <- xs, x > 1]
List comprehension
f . gCompose functions
f $ g xApply with low precedence
xs !! 2Index a list
import qualified Data.Map as M
Qualified import
-- note / {- note -}
Comments
Common functions
map f xsApply f to each element
filter p xsKeep elements matching p
foldr f z xsRight fold
foldl' f z xs
Strict left fold
From Data.List.
zip xs ysPair up two lists
fmap f m / f <$> m
Map inside a functor
mapM_ print xsRun an action per element
maybe d f mFold a Maybe
either f g eFold an Either
read s :: IntParse a string
show xConvert to a string
putStrLn sPrint a line
getLineRead a line of input
sequence_ / traverse
Run structures of actions
Recipes
main :: IO ()main = putStrLn "Hello"-- ghc -O2 -Wall -o hello Hello.hssafeDiv :: Int -> Int -> Maybe IntsafeDiv _ 0 = NothingsafeDiv a b = Just (a `div` b)main = print (safeDiv 4 2 >>= safeDiv 10)data Color = Red | Green deriving (Eq, Show)class Pretty a where pretty :: a -> Stringinstance Pretty Color where pretty Red = "red" pretty Green = "green"mkdir demo && cd democabal init --non-interactivecabal build && cabal runcabal repl
