programación funcional con haskell

Programación Funcional en Haskell

Agustín Ramos Fonseca

2a parte

Un lenguaje de programación...

• Funcional.

Las funciones son construcciones de primera clase.

• Puro.

Las funciones no tienen efectos colaterales.

• De evaluación perezosa.

Las expresiones se evalúan hasta que es requerido.

• De tipado estático.

Con inferencia de tipos.

Características• List comprehensions.

• Pattern matching.

• Currying

• Function Composition

• Infinite data structures.

• Agebraic Data Types

• Type classes.

• Applicative Functors

• Monads

Ejemplos

¿Haskell Sweet Spot?

Algoritmos

Eight Queens

Eight Queens!

isValidSolution sol = all isValid fullPositions

where fullPositions = zip sol [1..8]

isValid pos = null $ intersect fullPositions $ diags pos

diags pos = diag1 pos ++ diag2 pos ++ diag3 pos ++ diag4 pos

diag1 (r,c) = [(r',c') | r' <- [r-1,r-2..1], r' >= 1, c' <- [c-1,c-2..1], c' >= 1, r'-c' == r-c ]

diag2 (r,c) = [(r',c') | r' <- [r+1..8], r' <= 8, c' <- [c+1..8], c' <= 8, r'-c' == r-c ]

diag3 (r,c) = [(r',c') | r' <- [r+1..8], r' <= 8, c' <- [c-1,c-2..1], c' >= 1, r'+c' == r+c ]

diag4 (r,c) = [(r',c') | r' <- [r-1,r-2..1], r' >= 1, c' <- [c+1..8], c' <= 8, r'+c' == r+c ]

!

eightQueens = filter isValidSolution $ permutations [1..8]

Knights Tour

Knights Tourtype Position = (Int,Int)

type Solution = [Position]

!

possibleMovs :: Int -> Position -> [Position]

possibleMovs n (r,c) = [(r',c') | r' <- [r-2..r+2],

c' <- [c-2..c+2],

isLMovement (r’,c'),

isWithinBoard (r',c')]

where isLMovement (r',c') = abs(r-r') + abs(c-c') == 3

isWithinBoard (r',c') = r' >= 1 && r' <= n && c' >= 1 && c' <= n

Knights Tourtours :: Int -> Position -> [Solution]

tours n from = tours' n from [[from]]

where tours' n from sols = filter fullTour $ concat $ solutions n from sols

solutions n from sols = parMap rpar (completeSols sols) $ possibleMovs n from

completeSols sols m = if isNewPosition m sols

then tours' n m $ appendToSolutions sols m

else sols

fullTour s = length s == n*n

isNewPosition p = all (isNothing . elemIndex p)

appendToSolutions [] mov = [[mov]]

appendToSolutions sols mov = map (\sol -> sol ++ [mov] ) sols

!knightsTour n = concat $ parMap rpar (tours n) allPositions

where allPositions = [(r,c) | r <- [1..n], c <- [1..n]]

Lattice Paths

http://projecteuler.net/problem=15

Lattice Pathsimport Control.Monad.Memo

!pathsm 0 0 = return 0

pathsm 0 _ = return 1

pathsm _ 0 = return 1

pathsm r d = do

r1 <- for2 memo pathsm (r - 1) d

d1 <- for2 memo pathsm r (d -1)

return (r1 + d1)

!evalPathsm :: (Num n, Ord n) => n -> n -> n

evalPathsm r d = startEvalMemo $ pathsm r d

!runPathsm n = evalPathsm n n

Proyectos Interesantes

HAXL

http://j.mp/1bWl9Oz

Elm

http://elm-lang.org/

Porque... #SoyPunk

¿Preguntas?

¡Gracias!

Agustín Ramos Fonseca @MachinesAreUs