Отладка кода

flag::Int->[Int]->Int
flag n[]=FALSE
flag n(x:xs) = if x ==n then TRUE
                    else flag n(xs)
 
udal::[Int]->[Int]
ufal[]=[]
udal (x:y:xs)= if flag x (y:xs)==TRUE then udal (xs)
                     else x:udal(y:xs)

udal::[Int] -> [Int]
udal l = reverse $ udal' l [] --аккумулятор пустой - []
    where 
        udal' [] acc = acc --кончилось, возвращаем результат
        udal' (x:xs) [] = udal' xs [x] -- инициализация аккумулятора
        udal' (x:xs) acc@(a:_)
            | x == a    = udal' xs acc          -- символ повторился, в аккумулятор не кладем
            | otherwise = udal' xs [x] ++ acc   -- символ новый, запоминаем и хвостик передаем дальше
 
main = do
    putStrLn $ show $ udal [1,2,3,3,4,5]

udal2:: [Int] -> [Int]
udal2 l = foldr rep [] l
    where   rep a [] = [a]
            rep a l@(b:_)
                | a == b = l
                | otherwise = [a] ++ l

udal2:: [Int] -> [Int]
udal2 (x:xs) = foldr rep [x] xs
    where   rep a l@(b:_)
                | a == b    = l
                | otherwise = [a] ++ l

udal2 l = foldr rep [] l
    where   rep a [] = [a] --иницаилизация
А стало:
udal2 (x:xs) = foldr rep [x] xs --тут сразу разбиваем список и пихаем голову в аккумулятор

udal3:: [Int] -> [Int]
udal3 (x:xs) = [last l] ++ init l
    where l = foldr (\x y@(b:_) -> if( b /= x ) then [x] ++ y else y) [x] xs

udal = fst.foldl (\(r,d) x -> if elem x d then (r,d) else (r++[x],x:d)) ([],[])
udal' = Data.List.nub

-- Простая рекурсия
 
uniq1 :: (Eq a) => [a] -> [a]  
uniq1 [] = []
uniq1 (x:xs) | (x `elem` rs) = rs
             | otherwise = x : rs
               where rs = uniq1 xs              
 
-- Хвостовая рекурсия
 
uniq2 :: (Eq a) => [a] -> [a] -> [a]
uniq2 [] acc = acc
uniq2 (x:xs) acc | (x `elem` acc) = uniq2 xs acc
                 | otherwise = uniq2 xs (x:acc)
                
-- Свертка
 
uniq3 :: (Eq a) => [a] -> [a]                
uniq3    = foldl (\ acc y -> if (y `elem` acc) then acc else y:acc) []
 
-- Реализация elem через свертку
 
el :: (Eq a) => a -> [a] -> Bool
el a = foldl (\ r x -> r || (x==a)) False
 
-- Только свертки
 
uniq4 :: (Eq a) => [a] -> [a]                
uniq4    = foldl (\ acc y -> if (foldl (\ r x -> r || (x==y)) False acc) then acc else y:acc) []

el a = foldr (\x r -> x == a || r) False

foldl        :: (b -> a -> b) -> b -> [a] -> b
foldl f z0 xs0 = lgo z0 xs0
             where
                lgo z []     =  z
                lgo z (x:xs) = lgo (f z x) xs

el a = any (a==)