Data.StrictList

Documentation

data StrictList a

Constructors

Nil

!a :! !(StrictList a) infixr 5

Instances

Monad StrictList

Methods

(>>=) :: StrictList a -> (a -> StrictList b) -> StrictList b

(>>) :: StrictList a -> StrictList b -> StrictList b

return :: a -> StrictList a

fail :: String -> StrictList a

Functor StrictList

Methods

fmap :: (a -> b) -> StrictList a -> StrictList b

(<$) :: a -> StrictList b -> StrictList a

MonadFail StrictList

Methods

fail :: String -> StrictList a

Applicative StrictList

Methods

pure :: a -> StrictList a

(<*>) :: StrictList (a -> b) -> StrictList a -> StrictList b

(*>) :: StrictList a -> StrictList b -> StrictList b

(<*) :: StrictList a -> StrictList b -> StrictList a

Foldable StrictList

Methods

fold :: Monoid m => StrictList m -> m

foldMap :: Monoid m => (a -> m) -> StrictList a -> m

foldr :: (a -> b -> b) -> b -> StrictList a -> b

foldr' :: (a -> b -> b) -> b -> StrictList a -> b

foldl :: (b -> a -> b) -> b -> StrictList a -> b

foldl' :: (b -> a -> b) -> b -> StrictList a -> b

foldr1 :: (a -> a -> a) -> StrictList a -> a

foldl1 :: (a -> a -> a) -> StrictList a -> a

toList :: StrictList a -> [a]

null :: StrictList a -> Bool

length :: StrictList a -> Int

elem :: Eq a => a -> StrictList a -> Bool

maximum :: Ord a => StrictList a -> a

minimum :: Ord a => StrictList a -> a

sum :: Num a => StrictList a -> a

product :: Num a => StrictList a -> a

Traversable StrictList

Methods

traverse :: Applicative f => (a -> f b) -> StrictList a -> f (StrictList b)

sequenceA :: Applicative f => StrictList (f a) -> f (StrictList a)

mapM :: Monad m => (a -> m b) -> StrictList a -> m (StrictList b)

sequence :: Monad m => StrictList (m a) -> m (StrictList a)

Alternative StrictList

Methods

empty :: StrictList a

(<|>) :: StrictList a -> StrictList a -> StrictList a

some :: StrictList a -> StrictList [a]

many :: StrictList a -> StrictList [a]

IsList (StrictList a)

Associated Types

type Item (StrictList a) :: *

Methods

fromList :: [Item (StrictList a)] -> StrictList a

fromListN :: Int -> [Item (StrictList a)] -> StrictList a

toList :: StrictList a -> [Item (StrictList a)]

Eq a => Eq (StrictList a)

Methods

(==) :: StrictList a -> StrictList a -> Bool

(/=) :: StrictList a -> StrictList a -> Bool

Data a => Data (StrictList a)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> StrictList a -> c (StrictList a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (StrictList a)

toConstr :: StrictList a -> Constr

dataTypeOf :: StrictList a -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (StrictList a))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (StrictList a))

gmapT :: (forall b. Data b => b -> b) -> StrictList a -> StrictList a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> StrictList a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> StrictList a -> r

gmapQ :: (forall d. Data d => d -> u) -> StrictList a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> StrictList a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> StrictList a -> m (StrictList a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> StrictList a -> m (StrictList a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> StrictList a -> m (StrictList a)

Ord a => Ord (StrictList a)

Methods

compare :: StrictList a -> StrictList a -> Ordering

(<) :: StrictList a -> StrictList a -> Bool

(<=) :: StrictList a -> StrictList a -> Bool

(>) :: StrictList a -> StrictList a -> Bool

(>=) :: StrictList a -> StrictList a -> Bool

max :: StrictList a -> StrictList a -> StrictList a

min :: StrictList a -> StrictList a -> StrictList a

Read a => Read (StrictList a)

Methods

readsPrec :: Int -> ReadS (StrictList a)

readList :: ReadS [StrictList a]

readPrec :: ReadPrec (StrictList a)

readListPrec :: ReadPrec [StrictList a]

Show a => Show (StrictList a)

Methods

showsPrec :: Int -> StrictList a -> ShowS

show :: StrictList a -> String

showList :: [StrictList a] -> ShowS

Generic (StrictList a)

Associated Types

type Rep (StrictList a) :: * -> *

Methods

from :: StrictList a -> Rep (StrictList a) x

to :: Rep (StrictList a) x -> StrictList a

Monoid (StrictList a)

Methods

mempty :: StrictList a

mappend :: StrictList a -> StrictList a -> StrictList a

mconcat :: [StrictList a] -> StrictList a

Arbitrary a => Arbitrary (StrictList a)

Methods

arbitrary :: Gen (StrictList a)

shrink :: StrictList a -> [StrictList a]

Hashable a => Hashable (StrictList a)

Methods

hashWithSalt :: Int -> StrictList a -> Int

hash :: StrictList a -> Int

ToJSON a => ToJSON (StrictList a)

Methods

toJSON :: StrictList a -> Value

toEncoding :: StrictList a -> Encoding

toJSONList :: [StrictList a] -> Value

toEncodingList :: [StrictList a] -> Encoding

FromJSON a => FromJSON (StrictList a)

Methods

parseJSON :: Value -> Parser (StrictList a)

parseJSONList :: Value -> Parser [StrictList a]

NFData a => NFData (StrictList a)

Methods

rnf :: StrictList a -> ()

type Rep (StrictList a)

type Rep (StrictList a) = D1 (MetaData "StrictList" "Data.StrictList.Types" "strict-data-0.2.0.2-FGPF9cVJpblGQAsBKh3DLB" False) ((:+:) (C1 (MetaCons "Nil" PrefixI False) U1) (C1 (MetaCons ":!" (InfixI RightAssociative 5) False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (StrictList a))))))

type Item (StrictList a)

type Item (StrictList a) = a

type SL = StrictList

(+!+) :: StrictList a -> StrictList a -> StrictList a infixr 5

(\!\) :: Eq a => SL a -> SL a -> SL a

all :: (a -> Bool) -> StrictList a -> Bool

any :: (a -> Bool) -> StrictList a -> Bool

atIdx :: Int -> StrictList a -> Option a

break :: (a -> Bool) -> StrictList a -> (StrictList a, StrictList a)

catMaybes :: StrictList (Maybe a) -> StrictList a

Equivalent of catMaybes with StrictList.

catOptions :: StrictList (Option a) -> StrictList a

Equivalent to catMaybes with Option and StrictList.

>>> catOptions (sl [Some 1, None, Some 2, None, None, Some 3, Some 4])
[1,2,3,4]

catOptionsL :: [Option a] -> StrictList a

>>> catOptionsL [Some 1, None, Some 2, None, None, Some 3, Some 4]
[1,2,3,4]

concat :: Foldable t => t (StrictList a) -> StrictList a

concatSL :: SL (SL a) -> SL a

concatMap :: Foldable t => (a -> StrictList b) -> t a -> StrictList b

concatMapSL :: (a -> StrictList b) -> SL a -> StrictList b

concatMapM :: Monad m => (a -> m (SL b)) -> SL a -> m (SL b)

concatText :: StrictList Text -> Text

delete :: Eq a => a -> SL a -> SL a

delete x removes the first occurrence of x from its list argument. NOTE: Implementation copied from Data.List.

deleteBy :: (a -> a -> Bool) -> a -> SL a -> SL a

The deleteBy function behaves like delete, but takes a user-supplied equality predicate. NOTE: Implementation copied from Data.List.

deleteIdx :: Int -> StrictList a -> StrictList a

deleteIdx idx removes the element at index idx.

not (null xs) ==> Some (deleteIdx 0 xs) == tailOpt xs

drop :: Int -> StrictList a -> StrictList a

>>> drop 3 (sl [1, 2, 3, 4, 5])
[4,5]

dropWhile :: (a -> Bool) -> StrictList a -> StrictList a

dropWhileEnd :: (a -> Bool) -> SL a -> SL a

elem :: Eq a => a -> StrictList a -> Bool

filter :: (a -> Bool) -> StrictList a -> StrictList a

Equivalent of filter with StrictList.

find :: (a -> Bool) -> StrictList a -> Maybe a

findIndex :: (a -> Bool) -> StrictList a -> Option Int

fromLazyList :: [a] -> StrictList a

toLazyList :: StrictList a -> [a]

groupBy :: (a -> a -> Bool) -> StrictList a -> StrictList (StrictList a)

headM :: Monad m => StrictList a -> m a

headOpt :: StrictList a -> Option a

not (null xs) ==> isSome (headOpt xs)

insert :: Ord a => a -> SL a -> SL a

insertBy :: (a -> a -> Ordering) -> a -> SL a -> SL a

intercalateString :: String -> SL String -> String

intercalateText :: Text -> StrictList Text -> Text

intersperse :: a -> StrictList a -> StrictList a

lastM :: Monad m => StrictList a -> m a

lastOpt :: StrictList a -> Option a

length :: StrictList a -> Int

ll :: SL a -> [a]

lookup :: Eq a => a -> StrictList (a :!: b) -> Option b

lookupM :: (Monad m, Show a, Eq a) => a -> StrictList (a :!: b) -> m b

lookupM' :: (Monad m, Eq a) => (a -> String) -> a -> StrictList (a :!: b) -> m b

lookupM'' :: (Monad m, Eq k) => (k -> String) -> (a -> Maybe k) -> k -> StrictList a -> m a

lookupM'' showKey getKey getValue key list searches for key in list using getKey as the key extraction function and showKey to print all available keys when no match is found.

map :: (a -> b) -> StrictList a -> StrictList b

mapM :: Monad m => (a -> m b) -> StrictList a -> m (StrictList b)

mapM_ :: Monad m => (a -> m b) -> StrictList a -> m ()

mapMaybe :: (a -> Maybe b) -> StrictList a -> StrictList b

Equivalent of mapMaybe with StrictList.

mapOption :: (a -> Option b) -> StrictList a -> StrictList b

Equivalent of mapMaybe with Option and StrictList.

>>> mapOption (\x -> if even x then Some (x * 2) else None) (sl [1, 2, 3, 4, 5])
[4,8]

maximumM :: (Ord a, Monad m) => SL a -> m a

maybeToStrictList :: Maybe a -> StrictList a

>>> maybeToStrictList (Just "bar")
["bar"]

>>> maybeToStrictList Nothing
[]

mconcatSL :: Monoid a => SL a -> a

notElem :: Eq a => a -> StrictList a -> Bool

nub :: (Eq a, Hashable a) => SL a -> SL a

null :: StrictList a -> Bool

>>> null (sl [])
True

>>> null (sl ["foo"])
False

optionToStrictList :: Option a -> StrictList a

>>> optionToStrictList (Some "foo")
["foo"]

>>> optionToStrictList None
[]

partition :: (a -> Bool) -> SL a -> (SL a, SL a)

replicate :: Integral i => i -> a -> StrictList a

reverse :: StrictList a -> StrictList a

reverse (reverse xs) == xs

singleton :: a -> StrictList a

sl :: [a] -> SL a

snoc :: SL a -> a -> SL a

Appends an element to the end of this list. This is really inefficient because the whole list needs to be copied. Use at your own risk.

merge :: Ord a => StrictList a -> StrictList a -> StrictList a

mergeBy :: (a -> a -> Ordering) -> StrictList a -> StrictList a -> StrictList a

sort :: Ord a => StrictList a -> StrictList a

sortBy :: (a -> a -> Ordering) -> StrictList a -> StrictList a

sortOn :: Ord b => (a -> b) -> StrictList a -> StrictList a

>>> sortOn snd (sl [("foo", 10), ("bar", 1), ("baz", 100)])
[("bar",1),("foo",10),("baz",100)]

span :: (a -> Bool) -> StrictList a -> (StrictList a, StrictList a)

stripPrefix :: Eq a => SL a -> SL a -> Maybe (SL a)

stripSuffix :: Eq a => SL a -> SL a -> Maybe (SL a)

tailOpt :: StrictList a -> Option (StrictList a)

Safe tail function: Returns None for an empty list, Some x for a non-empty list starting with x.

take :: Int -> StrictList a -> StrictList a

>>> take 3 (sl [1, 2, 3, 4, 5, 6, 7])
[1,2,3]

takeWhile :: (a -> Bool) -> StrictList a -> StrictList a

transpose :: SL (SL a) -> SL (SL a)

unzip :: SL (a :!: b) -> SL a :!: SL b

unzipL :: [a :!: b] -> SL a :!: SL b

unzipLL :: [(a, b)] -> SL a :!: SL b

zip :: StrictList a -> StrictList b -> StrictList (a :!: b)

zipLL :: [a] -> [b] -> StrictList (a :!: b)

zipLS :: [a] -> StrictList b -> StrictList (a :!: b)

zipSL :: StrictList a -> [b] -> StrictList (a :!: b)

zipWith :: (a -> b -> c) -> SL a -> SL b -> SL c

zipWithLS :: (a -> b -> c) -> [a] -> SL b -> SL c

zipWithSL :: (a -> b -> c) -> SL a -> [b] -> SL c