{-# LANGUAGE Safe #-}
module Data.List
(List,
(++),
head,
last,
tail,
init,
uncons,
unsnoc,
singleton,
null,
length,
compareLength,
map,
reverse,
intersperse,
intercalate,
transpose,
subsequences,
permutations,
foldl,
foldl',
foldl1,
foldl1',
foldr,
foldr1,
concat,
concatMap,
and,
or,
any,
all,
sum,
product,
maximum,
minimum,
scanl,
scanl',
scanl1,
scanr,
scanr1,
mapAccumL,
mapAccumR,
iterate,
iterate',
repeat,
replicate,
cycle,
unfoldr,
take,
drop,
splitAt,
takeWhile,
dropWhile,
dropWhileEnd,
span,
break,
stripPrefix,
group,
inits,
inits1,
tails,
tails1,
isPrefixOf,
isSuffixOf,
isInfixOf,
isSubsequenceOf,
elem,
notElem,
lookup,
find,
filter,
partition,
(!?),
(!!),
elemIndex,
elemIndices,
findIndex,
findIndices,
zip,
zip3,
zip4,
zip5,
zip6,
zip7,
zipWith,
zipWith3,
zipWith4,
zipWith5,
zipWith6,
zipWith7,
unzip,
unzip3,
unzip4,
unzip5,
unzip6,
unzip7,
lines,
words,
unlines,
unwords,
nub,
delete,
(\\),
union,
intersect,
sort,
sortOn,
insert,
nubBy,
deleteBy,
deleteFirstsBy,
unionBy,
intersectBy,
groupBy,
sortBy,
insertBy,
maximumBy,
minimumBy,
genericLength,
genericTake,
genericDrop,
genericSplitAt,
genericIndex,
genericReplicate
) where
import GHC.Internal.Data.Bool (otherwise)
import GHC.Internal.Data.List
import GHC.Internal.Data.List.NonEmpty (NonEmpty(..))
import GHC.Internal.Data.Ord (Ordering(..), (<), (>))
import GHC.Internal.Int (Int)
import GHC.Internal.Num ((-))
import GHC.List (build)
inits1, tails1 :: [a] -> [NonEmpty a]
inits1 :: forall a. [a] -> [NonEmpty a]
inits1 [] = []
inits1 (a
x : [a]
xs) = ([a] -> NonEmpty a) -> [[a]] -> [NonEmpty a]
forall a b. (a -> b) -> [a] -> [b]
map (a
x a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
:|) ([a] -> [[a]]
forall a. [a] -> [[a]]
inits [a]
xs)
{-# INLINABLE tails1 #-}
tails1 :: forall a. [a] -> [NonEmpty a]
tails1 [a]
lst = (forall b. (NonEmpty a -> b -> b) -> b -> b) -> [NonEmpty a]
forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
build (\NonEmpty a -> b -> b
c b
n ->
let tails1Go :: [a] -> b
tails1Go [] = b
n
tails1Go (a
x : [a]
xs) = (a
x a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
:| [a]
xs) NonEmpty a -> b -> b
`c` [a] -> b
tails1Go [a]
xs
in [a] -> b
tails1Go [a]
lst)
compareLength :: [a] -> Int -> Ordering
compareLength :: forall a. [a] -> Int -> Ordering
compareLength [a]
xs Int
n
| Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 = Ordering
GT
| Bool
otherwise = (a -> (Int -> Ordering) -> Int -> Ordering)
-> (Int -> Ordering) -> [a] -> Int -> Ordering
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr
(\a
_ Int -> Ordering
f Int
m -> if Int
m Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0 then Int -> Ordering
f (Int
m Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) else Ordering
GT)
(\Int
m -> if Int
m Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0 then Ordering
LT else Ordering
EQ)
[a]
xs
Int
n
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4