relude-1.2.1.0: Safe, performant, user-friendly and lightweight Haskell Standard Library
Copyright(c) 2016 Stephen Diehl
(c) 2016-2018 Serokell
(c) 2018-2023 Kowainik
LicenseMIT
MaintainerKowainik <xrom.xkov@gmail.com>
StabilityStable
PortabilityPortable
Safe HaskellTrustworthy
LanguageHaskell2010

Relude.List.Reexport

Contents

Description

Reexports most of the Data.List.

Synopsis

List

group :: Eq a => [a] -> [[a]] #

drop :: Int -> [a] -> [a] #

(++) :: [a] -> [a] -> [a] #

break :: (a -> Bool) -> [a] -> ([a], [a]) #

dropWhile :: (a -> Bool) -> [a] -> [a] #

filter :: (a -> Bool) -> [a] -> [a] #

genericDrop :: Integral i => i -> [a] -> [a] #

genericLength :: Num i => [a] -> i #

genericReplicate :: Integral i => i -> a -> [a] #

genericSplitAt :: Integral i => i -> [a] -> ([a], [a]) #

genericTake :: Integral i => i -> [a] -> [a] #

inits :: [a] -> [[a]] #

intercalate :: [a] -> [[a]] -> [a] #

intersperse :: a -> [a] -> [a] #

isPrefixOf :: Eq a => [a] -> [a] -> Bool #

iterate :: (a -> a) -> a -> [a] #

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

permutations :: [a] -> [[a]] #

repeat :: a -> [a] #

replicate :: Int -> a -> [a] #

reverse :: [a] -> [a] #

scanl :: (b -> a -> b) -> b -> [a] -> [b] #

scanl' :: (b -> a -> b) -> b -> [a] -> [b] #

scanl1 :: (a -> a -> a) -> [a] -> [a] #

scanr :: (a -> b -> b) -> b -> [a] -> [b] #

scanr1 :: (a -> a -> a) -> [a] -> [a] #

sort :: Ord a => [a] -> [a] #

sortBy :: (a -> a -> Ordering) -> [a] -> [a] #

sortOn :: Ord b => (a -> b) -> [a] -> [a] #

span :: (a -> Bool) -> [a] -> ([a], [a]) #

splitAt :: Int -> [a] -> ([a], [a]) #

subsequences :: [a] -> [[a]] #

tails :: [a] -> [[a]] #

take :: Int -> [a] -> [a] #

takeWhile :: (a -> Bool) -> [a] -> [a] #

transpose :: [[a]] -> [[a]] #

uncons :: [a] -> Maybe (a, [a]) #

unfoldr :: (b -> Maybe (a, b)) -> b -> [a] #

unzip :: [(a, b)] -> ([a], [b]) #

unzip3 :: [(a, b, c)] -> ([a], [b], [c]) #

zip :: [a] -> [b] -> [(a, b)] #

zip3 :: [a] -> [b] -> [c] -> [(a, b, c)] #

zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] #

cycle :: [a] -> [a] Source #

Creates an infinite list from a finite list by appending the list to itself infinite times (i.e. by cycling the list). Unlike cycle from Data.List, this implementation doesn't throw error on empty lists, but returns an empty list instead.

>>> cycle []
[]
>>> take 10 $ cycle [1,2,3]
[1,2,3,1,2,3,1,2,3,1]

sortWith :: Ord b => (a -> b) -> [a] -> [a] #