114 righe
2.5 KiB
Haskell
114 righe
2.5 KiB
Haskell
{-# OPTIONS_HADDOCK ignore-exports #-}
|
|
|
|
module MyPrelude where
|
|
|
|
import Control.Arrow ((***))
|
|
import Data.List
|
|
|
|
|
|
-- |Used to create a common interface for default settings of data types.
|
|
class Def a where
|
|
def :: a
|
|
|
|
|
|
-- |For negating random types.
|
|
class Not b where
|
|
not' :: b -> b
|
|
|
|
|
|
-- |Split an array into subarrays depending on a given condition.
|
|
splitBy :: (a -> Bool) -- ^ condition
|
|
-> [a] -- ^ array to split
|
|
-> [[a]] -- ^ splitted array
|
|
splitBy f s =
|
|
case dropWhile f s of
|
|
[] -> []
|
|
s' -> w : splitBy f s''
|
|
where (w, s'') = break f s'
|
|
|
|
|
|
-- |Remove a given item from a list.
|
|
removeItem :: (Eq a) => a -> [a] -> [a]
|
|
removeItem x = foldr (\x' y -> if x' == x then y else x':y) []
|
|
|
|
|
|
-- |Sort a list of tuples lexicographically.
|
|
sortLex :: (Ord a) => [(a, a)] -> [(a, a)]
|
|
sortLex =
|
|
sortBy (\(x1, y1) (x2, y2) -> case compare x1 x2 of
|
|
EQ -> compare y1 y2
|
|
x -> x)
|
|
|
|
|
|
-- |Sort a list of tuples lexicographically, but start with second elem.
|
|
sortLexSwapped :: (Ord a) => [(a, a)] -> [(a, a)]
|
|
sortLexSwapped =
|
|
sortBy (\(x1, y1) (x2, y2) -> case compare y1 y2 of
|
|
EQ -> compare x1 x2
|
|
y -> y)
|
|
|
|
|
|
-- |Get the last x elements of a list.
|
|
getLastX :: Int -> [a] -> [a]
|
|
getLastX a xs
|
|
| length xs < a = []
|
|
| otherwise = snd . splitAt (length xs - a) $ xs
|
|
|
|
|
|
-- |Get a list with it's head and last element cut. If there are less
|
|
-- than 3 elements in the list, return an empty list.
|
|
tailInit :: [a] -> [a]
|
|
tailInit xs
|
|
| length xs > 2 = tail . init $ xs
|
|
| otherwise = []
|
|
|
|
|
|
-- |Remove duplicates from a list.
|
|
rmdups :: (Ord a) => [a] -> [a]
|
|
rmdups =
|
|
foldl (\seen x -> if x `elem` seen
|
|
then seen
|
|
else seen ++ [x]) []
|
|
|
|
|
|
-- |Apply a function to the first element of a tuple.
|
|
first :: (a -> b) -> (a,c) -> (b,c)
|
|
first = (*** id)
|
|
|
|
|
|
-- |Sequentialize a list, such as:
|
|
-- [1, 2, 3, 4, 5] -> [[1],[1,2],[1,2,3],[1,2,3,4],[1,2,3,4,5]]
|
|
seqList :: [a] -> [[a]]
|
|
seqList = tail. inits
|
|
|
|
|
|
-- |Duplicate the last element of a list and append it.
|
|
dupLast :: [a] -> [a]
|
|
dupLast [] = []
|
|
dupLast xs = xs ++ [last xs]
|
|
|
|
|
|
-- |Simpler version of if-then-else.
|
|
if' :: Bool -> a -> a -> a
|
|
if' True x _ = x
|
|
if' False _ y = y
|
|
|
|
|
|
-- |Shift a list k places.
|
|
shiftM :: Int -> [a] -> [a]
|
|
shiftM _ [] = []
|
|
shiftM 0 xs = xs
|
|
shiftM n xs = drop n xs ++ take n xs
|
|
|
|
|
|
-- |Shift a list.
|
|
-- E.g.: shiftM' (== 5)
|
|
shiftM' :: Eq a => a -> [a] -> [a]
|
|
shiftM' s xs = dropWhile (/= s) xs ++ takeWhile (/= s) xs
|
|
|
|
|
|
-- |Get the pivot of a list.
|
|
pivot :: [a] -> Maybe a
|
|
pivot [] = Nothing
|
|
pivot xs = Just . (!!) xs . flip div 2 . length $ xs
|