Fresh examples

hello = putStrLn "Hello DevFest Nantes!"

helloFred = do
  putStrLn "Hello Nantes,"
  putStrLn "my name is Fred!"

square x = x ^ 2

map square [1, 2, 3]

map square [1..10]

Function application

Signature

fun :: Type1 -> Type2 -> Type3 -> Type4
fun arg1 arg2 arg3 = expression

Every expression is a function

constant :: Int
constant = 2

increment :: Int -> Int
increment a = a + 1

Partially applied functions

increment a = add 1 a

simplified into

increment = add 1

Similarly

add a b = a + b

add a b = (+) a b

add = (+)

Let's compose

The dot operator

(.) :: (b -> c) -> (a -> b) -> a -> c

incrementTwice n = (increment . increment) n

incrementTwice = increment . increment

Polymorphism

Ad-hoc polymorphism & type classes

(+) :: Num a => a -> a -> a

+ is ad-hoc polymorphism: implementation is type dependent

Num is a type class : a trait that you can implement outside the datatype definition.

Polymorphism on return type

fromInteger :: Num a => Integer -> a

mempty :: Monoid a => a

Data structures made easy

data MyType = MyConstructor Attribute1 Attribute2

Multiple constructors possible

data Color = Red | Blue | Green

Data type can be parametric

data Vector a = Vector a

Functor

Generalize mapping over a parametric datatype

map :: (a -> b) -> [a] -> [b]

fmap :: Functor f => (a -> b) -> f a -> f b

fmap (+1) (Just 1)
fmap (+1) [1, 2, 3]

Various functors

Maybe

(*2) <$> Just 1
(*2) <$> Nothing

IO

getLine :: IO String

getInt :: IO Int
getInt = read <$> getLine

Applicatives

Generalize functors to multiple arguments functions

(+) <$> Just 1 <*> Just 2

(++) <$> getLine <*> getLine

Parser Combinator

Build parser by combining other parsers, with basic parsers

char :: Char -> Parser Char
string :: String -> Parser String

space :: Parser Char
space = char ' ' 

Parser Combinator

Build by combining and fmapping

oneOf :: [Char] -> Parser Char
many :: Parser a -> Parser [a]
many1 :: Parser a -> Parser [a]

parsePiece :: Parser Piece
parsePiece = decodePiece <$> oneOf "PNBRQK"

decodePiece 'P' = Pawn
decodePiece 'N' = Knight
decodePiece 'B' = Bishop
decodePiece 'R' = Rook
decodePiece 'Q' = Queen
decodePiece 'K' = King

Simple parsers

parseFile :: Parser File
parseFile = oneOf "abcdefgh"

parseRank :: Parser File
parseRank = oneOf "12345678"

parseSquare :: Parser Square
parseSquare = do
  file <- parseFile
  rank <- parseRank
  return (file, rank)

Half-moves and moves

parseInt :: Parser Int
parseInt = read <$> many1 digit

(,,) <$> parseInt <*> space <*> parseInt

(,) <$> parseInt <* space <*> parseInt

(,) <$> parseInt <* space
    <*> parseInt

Alternatives

instance Alternative Parser

parseColor :: Parser Color
parseColor = tries [ White <$ char 'w'
                   , Black <$ char 'b'
                   ]

More complex parsers

parseEnPassantSquare :: Parser Square
parseEnPassantSquare = (,) <$> parseFile <*> oneOf "36"

parseEnPassant :: Parser EnPassant
parseEnPassant =
  tries [ Nothing <$  char '-'
        , Just    <$> parseEnPassantSquare
        ]

More complex parsers

parseCastlingCapacity :: Parser CastlingCapacity
parseCastlingCapacity =
  tries [ CanLongCastle  White <$ char 'Q'
        , CanShortCastle White <$ char 'K'
        , CanLongCastle  Black <$ char 'q'
        , CanShortCastle Black <$ char 'k'
        ]

parseCastlingCapacities :: Parser [CastlingCapacity]
parseCastlingCapacities =
  tries [ [] <$ char '-'
        , many parseCastlingCapacity
        ]

Final boss

parseRow :: Parser [SquareContent]
parseRow = assuming (ofLength 8) $ mconcat <$> many parseSquareContent

parsePosition :: Parser Position
parsePosition = assuming (ofLength 8) $ parseRow `sepBy` char '/'

All together

boardParser :: Parser Board
boardParser = Board <$> parsePosition           <* space
                    <*> parseColor              <* space
                    <*> parseCastlingCapacities <* space
                    <*> parseEnPassant          <* space
                    <*> parseInt                <* space
                    <*> parseInt

Use our model (a bit)

colorToMove :: Board -> Color
colorToMove (Board _ color _ _ _ _) = color

canWhiteLongCastle :: Board -> Bool
canWhiteLongCastle (Board _ _ castles _ _ _) = elem whiteLongCastle castles
  where whiteLongCastle = CanLongCastle White