Hola a todos!

He creado estas funciones con el fin de entender como funcionan cada una de ellas.
Por eso algunas ya están definidas como por ejemplo tail,reverse, zip, ...

fac 0 = 1
fac n = n * fac (n-1)
 
replicate' 0 n = [n]
replicate' x n = n:replicate (x-1) n
 
take' 0 xs = []
take' n [] = []
take' 1 xs = [head xs]
take' n xs = head xs:take (n-1) (tail xs)
 
reverse' [] = []
reverse' (x:xs)=last (x:xs):reverse'(init (x:xs))
 
haycero [] = False
haycero (x:xs) = (x==0) || haycero (xs)
 
todosceros [] = error "No está definido para una lista vacía"
todosceros [x] = (x==0)
todosceros (x':x:xs) = (x'==0) && todosceros(x:xs)
 
 
maximo n x = if (n>x) then n else x
minimo n x = if (n>x) then x else n
 
maximo' n x
  | n>=x = n
  | n<x = x
 
zip' xs []         = []
zip' [] ys         = []
zip' (x:xs) (y:ys) = [(x,y)]  ++  zip' xs ys
 
zip'' xs [] = []
zip'' [] ys = []
zip'' (x:xs) (y:ys) = (x,y) : zip'' xs ys
 
nth [] n = error "No está definida para lista vacía"
nth xs n = if (length xs > n) then xs !! n else error "No se puede acceder a esa posición ya que no existe"
 
 
 
{-
Comprueba si un elemento dado está en la lista
-}
 
elem' n []     = False
elem' n (x:xs) = (n==x) || elem' n xs
 
{-
ANALISIS POR CASOS
-}
 
elem'':: Eq a => a -> [a] -> Bool
elem'' n xs
  | length xs==0  = False
  | otherwise     = (n==head xs) || elem'' n (tail xs)
 
{-
quicksort [10,2,5,3,1,6,7,4,2,3,4,8,9] = [1,2,2,3,3,4,4,5,6,7,8,9,10]
-}
 
 
{-
zip [] []= []
zip [2] [5] = [(2,5)] ++ zip [] []
zip [1,2] [4,5] = [(1,4)] ++ zip[2][5]
-}
 
length' [] = 0
length' (x:xs) = 1 + length' xs
 
{-
repeat' 0
repeat'
-}
 
map' f [] = []
map' f (x:xs) = f x : map' f xs
 
tail' [] = []
tail' (x:xs) = xs
 
{-
filter (>3) [1,2,3,4,10,10,10,20,20,20] = [4,10,10,10,...]
-}
 
sumatoria [] = 0
sumatoria (x:xs) = x+sumatoria xs
 
multiplicar [] = 1
multiplicar (x:xs) = x*multiplicar xs
 
sumatoria' xs
  | length (xs) == 0 = 0
  | otherwise = head xs+sumatoria' (tail xs)
 
multidos [] = []
multidos (x:xs) = 2*x : multidos xs
 
multiPor n [] = []
multiPor n (x:xs) = n*x : multiPor n xs
 
h [] = [1]
h (x:xs) = (x+1) : h xs
 
test [] = []
test (5:[]) = error "Tu lista empieza por 5"
 
h' [] = [1]
h' (x:xs) = [(x+1)] ++ h xs
 
g 0 = error "El numero es cero"
g n = error "El numero no es cero"
 
multiplicar' xs
 | length xs == 0 = 1
 | length xs /= 0 = head xs*multiplicar'(tail xs)
 
 
filter' f [] = []
filter' f (x:xs)
      | f x =  x:filter' f xs
      | otherwise = filter' f xs

Ejecutan ghci y lo cargan con :l <nombre-del-archivo>
Después hagan los llamados que quieran.

Perdón como se ve, no hay una etiqueta para Haskell.

Saludos!