-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | A collection of commonly used strict data structures
--   
--   A collection of commonly used strict data structures
@package strict-data
@version 0.2.0.2

module Data.StrictVector.Mutable

-- | <a>MVector</a> is a strict wrapper around <a>Data.Vector.Mutable</a>'s
--   <a>MVector</a>
newtype MVector s a
MVector :: (MVector s a) -> MVector s a
type IOVector = MVector RealWorld
type STVector s = MVector s
instance Data.Vector.Generic.Mutable.Base.MVector Data.StrictVector.Mutable.MVector a

module Data.StrictTuple
toLazyTuple :: a :!: b -> (a, b)
fromLazyTuple :: (a, b) -> a :!: b
fst' :: Pair a b -> a
snd' :: Pair a b -> b
uncurry' :: (a -> b -> c) -> Pair a b -> c
first :: (a -> b) -> (a :!: c) -> (b :!: c)
second :: (b -> c) -> (a :!: b) -> (a :!: c)

-- | Swap the components of a pair.
swap :: (a, b) -> (b, a)
swap' :: (a :!: b) -> (b :!: a)
fst3 :: (a, b, c) -> a
snd3 :: (a, b, c) -> b
thr3 :: (a, b, c) -> c
fst3' :: ((a :!: b) :!: c) -> a
snd3' :: ((a :!: b) :!: c) -> b
thr3' :: ((a :!: b) :!: c) -> c
instance (Data.Data.Data a, Data.Data.Data b) => Data.Data.Data (Data.Strict.Tuple.Pair a b)
instance (Data.Hashable.Class.Hashable a, Data.Hashable.Class.Hashable b) => Data.Hashable.Class.Hashable (Data.Strict.Tuple.Pair a b)
instance (Control.DeepSeq.NFData a, Control.DeepSeq.NFData b) => Control.DeepSeq.NFData (Data.Strict.Tuple.Pair a b)
instance (GHC.Base.Monoid a, GHC.Base.Monoid b) => GHC.Base.Monoid (Data.Strict.Tuple.Pair a b)
instance (Test.QuickCheck.Arbitrary.Arbitrary a, Test.QuickCheck.Arbitrary.Arbitrary b) => Test.QuickCheck.Arbitrary.Arbitrary (Data.Strict.Tuple.Pair a b)
instance (Data.Aeson.Types.ToJSON.ToJSON a, Data.Aeson.Types.ToJSON.ToJSON b) => Data.Aeson.Types.ToJSON.ToJSON (Data.Strict.Tuple.Pair a b)
instance (Data.Aeson.Types.FromJSON.FromJSON a, Data.Aeson.Types.FromJSON.FromJSON b) => Data.Aeson.Types.FromJSON.FromJSON (Data.Strict.Tuple.Pair a b)


-- | An unordered, strict map.
module Data.Map.Unordered
data USMap k v
type Map = USMap
empty :: USMap k v
lookup :: (Eq k, Show k, Hashable k, Monad m) => k -> USMap k v -> m v
insert :: (Eq k, Hashable k) => k -> v -> USMap k v -> USMap k v
delete :: (Eq k, Hashable k) => k -> USMap k v -> USMap k v
fromList :: (Eq k, Hashable k) => [(k, v)] -> USMap k v
toList :: USMap k v -> [(k, v)]
map :: (v -> v') -> USMap k v -> USMap k v'
singleton :: Hashable k => k -> v -> USMap k v
insertWith :: (Eq k, Hashable k) => (v -> v -> v) -> k -> v -> USMap k v -> USMap k v
member :: (Eq k, Hashable k) => k -> USMap k v -> Bool
elems :: USMap k v -> [v]
unionWith :: (Hashable k, Eq k) => (v -> v -> v) -> USMap k v -> USMap k v -> USMap k v
difference :: (Eq k, Hashable k) => USMap k v -> USMap k w -> USMap k v
union :: (Hashable k, Eq k) => USMap k v -> USMap k v -> USMap k v
findWithDefault :: (Eq k, Hashable k) => a -> k -> USMap k a -> a
size :: USMap k v -> Int
null :: USMap k v -> Bool
isSubmapOf :: (Hashable k, Eq k) => USMap k a -> USMap k a -> Bool
intersection :: (Eq k, Hashable k) => USMap k v -> USMap k w -> USMap k v
foldrWithKey :: (k -> v -> a -> a) -> a -> USMap k v -> a

-- | <i>Warning: This function is strict. Better explicitly use
--   USMap.foldlWithKey'</i>
foldlWithKey :: (a -> k -> v -> a) -> a -> USMap k v -> a
foldlWithKey' :: (a -> k -> v -> a) -> a -> USMap k v -> a
keys :: USMap k v -> [k]
insertLookupWithKey :: (Eq k, Hashable k) => (k -> a -> a -> a) -> k -> a -> USMap k a -> (Maybe a, USMap k a)
updateLookupWithKey :: (Eq k, Hashable k) => (k -> a -> Maybe a) -> k -> USMap k a -> (Maybe a, USMap k a)
adjust :: (Eq k, Hashable k) => (a -> a) -> k -> USMap k a -> USMap k a
deleteLookup :: (Eq k, Hashable k) => k -> USMap k a -> (Maybe a, USMap k a)
assocs :: USMap k a -> [(k, a)]
insertWith' :: (Eq k, Hashable k) => (a -> a -> a) -> k -> a -> USMap k a -> USMap k a
update :: (Eq k, Hashable k) => (a -> Maybe a) -> k -> USMap k a -> USMap k a
alter :: (Eq k, Hashable k) => (Maybe a -> Maybe a) -> k -> USMap k a -> USMap k a
lookup' :: (Eq k, Hashable k) => k -> USMap k v -> Maybe v
unions :: (Hashable k, Eq k) => [USMap k a] -> USMap k a
toHashMap :: USMap k v -> HashMap k v
fromHashMap :: HashMap k v -> USMap k v
filter :: (v -> Bool) -> USMap k v -> USMap k v
filterWithKey :: (k -> v -> Bool) -> USMap k v -> USMap k v
keysSet :: (Eq k, Hashable k) => USMap k v -> HashSet k
lookupDefault :: (Eq k, Hashable k) => v -> k -> USMap k v -> v
fromListWith :: (Eq k, Hashable k) => (v -> v -> v) -> [(k, v)] -> USMap k v
mapMaybe :: (v -> Maybe v') -> USMap k v -> USMap k v'
unionsWith :: (Hashable k, Eq k) => (a -> a -> a) -> [USMap k a] -> USMap k a
instance (Data.Hashable.Class.Hashable k, GHC.Classes.Eq k) => GHC.Base.Monoid (Data.Map.Unordered.USMap k v)
instance (Data.Hashable.Class.Hashable k, GHC.Classes.Eq k, Data.Data.Data v, Data.Data.Data k) => Data.Data.Data (Data.Map.Unordered.USMap k v)
instance Data.Traversable.Traversable (Data.Map.Unordered.USMap k)
instance Data.Foldable.Foldable (Data.Map.Unordered.USMap k)
instance GHC.Base.Functor (Data.Map.Unordered.USMap k)
instance (GHC.Classes.Eq v, GHC.Classes.Eq k) => GHC.Classes.Eq (Data.Map.Unordered.USMap k v)
instance (Data.Hashable.Class.Hashable k, GHC.Classes.Eq k, GHC.Read.Read k, GHC.Read.Read v) => GHC.Read.Read (Data.Map.Unordered.USMap k v)
instance (GHC.Show.Show k, GHC.Show.Show v) => GHC.Show.Show (Data.Map.Unordered.USMap k v)
instance (Data.Hashable.Class.Hashable k, Data.Hashable.Class.Hashable v) => Data.Hashable.Class.Hashable (Data.Map.Unordered.USMap k v)
instance (Control.DeepSeq.NFData k, Control.DeepSeq.NFData v) => Control.DeepSeq.NFData (Data.Map.Unordered.USMap k v)
instance (Data.Hashable.Class.Hashable k, GHC.Classes.Eq k, Test.QuickCheck.Arbitrary.Arbitrary k, Test.QuickCheck.Arbitrary.Arbitrary v) => Test.QuickCheck.Arbitrary.Arbitrary (Data.Map.Unordered.USMap k v)


-- | An ordered, strict map.
--   
--   One might think that <a>Strict</a> already provides such a data type.
--   This is not correct. <a>Lazy</a> and <a>Strict</a> use the same,
--   non-strict <a>Map</a> datatype. <a>Strict</a> just provides functions
--   that evaluate the value argument before inserting it in the Map. The
--   problem is that the typeclass instances of the shared <a>Map</a>
--   datatype use the non-strict functions.
module Data.Map.Ordered
data OSMap k v
type Map = OSMap
empty :: OSMap k v
lookup :: (Ord k) => k -> OSMap k v -> Maybe v
insert :: (Ord k) => k -> v -> OSMap k v -> OSMap k v
delete :: (Ord k) => k -> OSMap k v -> OSMap k v
fromList :: (Ord k) => [(k, v)] -> OSMap k v
fromListWith :: (Ord k) => (v -> v -> v) -> [(k, v)] -> OSMap k v
toList :: OSMap k v -> [(k, v)]
map :: (v -> v') -> OSMap k v -> OSMap k v'
mapMaybe :: (v -> Maybe v') -> OSMap k v -> OSMap k v'
lookupLT :: (Ord k) => k -> OSMap k v -> Maybe (k, v)
lookupGT :: (Ord k) => k -> OSMap k v -> Maybe (k, v)
lookupLE :: (Ord k) => k -> OSMap k v -> Maybe (k, v)
lookupGE :: (Ord k) => k -> OSMap k v -> Maybe (k, v)
lookupM :: (Show k, Ord k, Monad m) => k -> OSMap k v -> m v
elemAt :: Int -> OSMap k a -> (k, a)
singleton :: k -> v -> OSMap k v
insertWith :: (Ord k) => (v -> v -> v) -> k -> v -> OSMap k v -> OSMap k v
member :: (Ord k) => k -> OSMap k v -> Bool
elems :: OSMap k v -> [v]
unionWith :: Ord k => (v -> v -> v) -> OSMap k v -> OSMap k v -> OSMap k v
difference :: (Ord k) => OSMap k v -> OSMap k w -> OSMap k v
union :: Ord k => OSMap k v -> OSMap k v -> OSMap k v
findWithDefault :: (Ord k) => a -> k -> OSMap k a -> a
size :: OSMap k v -> Int
null :: OSMap k v -> Bool
isSubmapOf :: (Ord k, Eq a) => OSMap k a -> OSMap k a -> Bool
unions :: Ord k => [OSMap k v] -> OSMap k v
intersection :: (Ord k) => OSMap k v -> OSMap k w -> OSMap k v
foldrWithKey :: (k -> v -> a -> a) -> a -> OSMap k v -> a
foldlWithKey :: (a -> k -> v -> a) -> a -> OSMap k v -> a
filter :: (v -> Bool) -> OSMap k v -> OSMap k v
filterWithKey :: (k -> v -> Bool) -> OSMap k v -> OSMap k v
keys :: OSMap k v -> [k]
toDescList :: OSMap k v -> [(k, v)]
updateLookupWithKey :: Ord k => (k -> a -> Maybe a) -> k -> OSMap k a -> (Maybe a, OSMap k a)
deleteLookup :: Ord k => k -> OSMap k v -> (Maybe v, OSMap k v)
insertLookupWithKey :: Ord k => (k -> a -> a -> a) -> k -> a -> OSMap k a -> (Maybe a, OSMap k a)
adjust :: Ord k => (a -> a) -> k -> Map k a -> Map k a
assocs :: OSMap k a -> [(k, a)]
insertWith' :: Ord k => (a -> a -> a) -> k -> a -> OSMap k a -> OSMap k a
alter :: Ord k => (Maybe a -> Maybe a) -> k -> OSMap k a -> OSMap k a
differenceWith :: Ord k => (a -> b -> Maybe a) -> OSMap k a -> OSMap k b -> OSMap k a
updateWithKey :: Ord k => (k -> a -> Maybe a) -> k -> OSMap k a -> OSMap k a
update :: Ord k => (a -> Maybe a) -> k -> OSMap k a -> OSMap k a
mapKeys :: Ord k2 => (k1 -> k2) -> OSMap k1 a -> OSMap k2 a
insertWithKey :: Ord k => (k -> a -> a -> a) -> k -> a -> Map k a -> Map k a
insertWithKey' :: Ord k => (k -> a -> a -> a) -> k -> a -> Map k a -> Map k a
keysSet :: OSMap k v -> Set k
maxView :: OSMap k a -> Maybe (a, OSMap k a)
maxViewWithKey :: OSMap k a -> Maybe ((k, a), OSMap k a)
minView :: OSMap k a -> Maybe (a, OSMap k a)
minViewWithKey :: OSMap k a -> Maybe ((k, a), OSMap k a)
intersectionWith :: Ord k => (a -> b -> c) -> OSMap k a -> OSMap k b -> OSMap k c
fromDistinctAscList :: [(k, v)] -> OSMap k v
toDataMap :: OSMap k v -> Map k v
fromDataMap :: Map k v -> OSMap k v
hasKey :: Int -> OSMap Int Int -> Bool
hasValue :: Int -> OSMap Int Int -> Bool
instance (GHC.Classes.Ord k, Data.Data.Data v, Data.Data.Data k) => Data.Data.Data (Data.Map.Ordered.OSMap k v)
instance (Control.DeepSeq.NFData v, Control.DeepSeq.NFData k) => Control.DeepSeq.NFData (Data.Map.Ordered.OSMap k v)
instance Data.Foldable.Foldable (Data.Map.Ordered.OSMap k)
instance (GHC.Show.Show v, GHC.Show.Show k) => GHC.Show.Show (Data.Map.Ordered.OSMap k v)
instance (GHC.Read.Read v, GHC.Read.Read k, GHC.Classes.Ord k) => GHC.Read.Read (Data.Map.Ordered.OSMap k v)
instance (GHC.Classes.Ord v, GHC.Classes.Ord k) => GHC.Classes.Ord (Data.Map.Ordered.OSMap k v)
instance (GHC.Classes.Eq v, GHC.Classes.Eq k) => GHC.Classes.Eq (Data.Map.Ordered.OSMap k v)
instance (Data.Hashable.Class.Hashable k, Data.Hashable.Class.Hashable v) => Data.Hashable.Class.Hashable (Data.Map.Ordered.OSMap k v)
instance GHC.Base.Functor (Data.Map.Ordered.OSMap k)
instance (GHC.Classes.Ord k, Test.QuickCheck.Arbitrary.Arbitrary k, Test.QuickCheck.Arbitrary.Arbitrary v) => Test.QuickCheck.Arbitrary.Arbitrary (Data.Map.Ordered.OSMap k v)
instance Data.Traversable.Traversable (Data.Map.Ordered.OSMap k)
instance GHC.Classes.Ord k => GHC.Base.Monoid (Data.Map.Ordered.OSMap k v)

module Data.Fail
data Fail a
Err :: !Text -> Fail a
Ok :: !a -> Fail a
isFail :: Fail a -> Bool
isOk :: Fail a -> Bool
newtype FailT m a
FailT :: m (Fail a) -> FailT m a
runFailT :: FailT m a -> m (Fail a)
type FIO a = FailT IO a
failEitherStr :: Either String a -> Fail a
failEitherShow :: Show a => Either a b -> Fail b
failEitherText :: Either Text a -> Fail a
runExceptTFail :: Monad m => ExceptT String m a -> m (Fail a)
failInM :: Monad m => Fail a -> m a
failInM' :: Monad m => Fail a -> (String -> String) -> m a
failInM'' :: Monad m => String -> Fail a -> m a
failToEither :: Fail a -> Either String a
failMaybe :: String -> Maybe a -> Fail a
failToMaybe :: Fail a -> Maybe a
mapFail :: (String -> String) -> Fail a -> Fail a
failSwitch :: (String -> c) -> (a -> c) -> Fail a -> c
fromFail :: (String -> a) -> Fail a -> a
class MonadFail m => MonadFailure m
catchFailure :: MonadFailure m => m a -> (String -> m a) -> m a
failForIOException :: IO a -> IO (Fail a)
catFails :: [Fail a] -> [a]
eitherToError :: MonadError e m => Either e a -> m a
errorToEither :: MonadError e m => m a -> m (Either e a)
liftError :: (MonadError e m, MonadError e m1) => (forall a. m a -> m1 a) -> m a -> m1 a
errorToDefault :: MonadError e m => a -> m a -> m a
errorToMaybe :: MonadError e m => m a -> m (Maybe a)
maybeToError :: MonadError e m => String -> Maybe a -> m a
runError :: forall a. (forall m. Monad m => m a) -> Either String a
runExceptTorFail :: (Monad m, Show e) => ExceptT e m a -> m a
maybeToFail :: Monad m => String -> Maybe a -> m a
eitherToFail :: Monad m => Either String a -> m a
fromFailString :: Fail a -> Maybe String
partitionFails :: [Fail a] -> ([a], [String])
safeFromOk :: (HasCallStack) => Fail a -> a

-- | When a value is bound in <tt>do</tt>-notation, the pattern on the left
--   hand side of <tt>&lt;-</tt> might not match. In this case, this class
--   provides a function to recover.
--   
--   A <a>Monad</a> without a <a>MonadFail</a> instance may only be used in
--   conjunction with pattern that always match, such as newtypes, tuples,
--   data types with only a single data constructor, and irrefutable
--   patterns (<tt>~pat</tt>).
--   
--   Instances of <a>MonadFail</a> should satisfy the following law:
--   <tt>fail s</tt> should be a left zero for <tt>&gt;&gt;=</tt>,
--   
--   <pre>
--   fail s &gt;&gt;= f  =  fail s
--   </pre>
--   
--   If your <a>Monad</a> is also <tt>MonadPlus</tt>, a popular definition
--   is
--   
--   <pre>
--   fail _ = mzero
--   </pre>
class Monad m => MonadFail (m :: * -> *)
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Data.Fail.Types.Fail a)
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Data.Fail.Types.FailT m)
instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (Data.Fail.Types.FailT m)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Data.Fail.Types.FailT m)
instance Control.Monad.Trans.Control.MonadTransControl Data.Fail.Types.FailT
instance GHC.Base.Monad m => Control.Monad.Error.Class.MonadError GHC.Base.String (Data.Fail.Types.FailT m)
instance Control.Monad.Trans.Class.MonadTrans Data.Fail.Types.FailT
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Data.Fail.Types.FailT m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Data.Fail.Types.FailT m)
instance Control.Monad.Trans.Resource.Internal.MonadResource m => Control.Monad.Trans.Resource.Internal.MonadResource (Data.Fail.Types.FailT m)
instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Data.Fail.Types.FailT m)
instance GHC.Base.Monad Data.Fail.Types.Fail
instance Control.Monad.Fail.MonadFail Data.Fail.Types.Fail
instance GHC.Base.MonadPlus Data.Fail.Types.Fail
instance GHC.Base.Applicative Data.Fail.Types.Fail
instance GHC.Base.Alternative Data.Fail.Types.Fail
instance Control.Monad.Fix.MonadFix Data.Fail.Types.Fail
instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Data.Fail.Types.FailT m)
instance GHC.Base.Monad m => GHC.Base.Monad (Data.Fail.Types.FailT m)
instance GHC.Base.Monad m => Control.Monad.Fail.MonadFail (Data.Fail.Types.FailT m)
instance (GHC.Base.Functor m, GHC.Base.Monad m) => GHC.Base.Applicative (Data.Fail.Types.FailT m)
instance GHC.Base.Monad m => GHC.Base.Alternative (Data.Fail.Types.FailT m)
instance GHC.Base.Monad m => GHC.Base.MonadPlus (Data.Fail.Types.FailT m)
instance Control.Monad.Error.Class.MonadError GHC.Base.String Data.Fail.Types.Fail
instance Data.Fail.MonadFailure GHC.Base.Maybe
instance Data.Fail.MonadFailure GHC.Types.IO
instance Data.Fail.MonadFailure Data.Fail.Types.Fail
instance GHC.Base.Monad m => Data.Fail.MonadFailure (Data.Fail.Types.FailT m)
instance (Control.Monad.Fail.MonadFail (Control.Monad.Trans.Reader.ReaderT r m), Data.Fail.MonadFailure m) => Data.Fail.MonadFailure (Control.Monad.Trans.Reader.ReaderT r m)

module Data.Option
data Option a
None :: Option a
Some :: !a -> Option a
newtype OptionT m a
OptionT :: m (Option a) -> OptionT m a
[runOptionT] :: OptionT m a -> m (Option a)
runOptionTDef :: Functor m => a -> OptionT m a -> m a
class ToOptionT t
optionT :: (ToOptionT t, Monad m) => m (t a) -> OptionT m a
noneIf :: (a -> Bool) -> a -> Option a
fromOption :: a -> Option a -> a
isSome :: Option a -> Bool
isNone :: Option a -> Bool
optionToMaybe :: Option a -> Maybe a

-- | <pre>
--   maybeToOption (optionToMaybe x) == x
--   </pre>
maybeToOption :: Maybe a -> Option a
optionToList :: Option a -> [a]
optionToSL :: Option a -> StrictList a
listToOption :: [a] -> Option a
getSomeNote :: Monad m => String -> Option a -> m a
option :: b -> (a -> b) -> Option a -> b
catOptions :: [Option a] -> [a]
mapOption :: (a -> Option b) -> [a] -> [b]
forOptionM :: Monad m => [a] -> (a -> OptionT m b) -> m [b]
mapOptionM :: Monad m => (a -> OptionT m b) -> [a] -> m [b]
safeFromSome :: Option a -> a
failToOption :: Fail a -> Option a
optionToFail :: String -> Option a -> Fail a
optionToFailT :: Monad m => String -> Option a -> FailT m a
instance Data.Traversable.Traversable Data.Option.Option
instance Data.Foldable.Foldable Data.Option.Option
instance GHC.Base.Functor Data.Option.Option
instance Data.Data.Data a => Data.Data.Data (Data.Option.Option a)
instance GHC.Generics.Generic (Data.Option.Option a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Option.Option a)
instance GHC.Read.Read a => GHC.Read.Read (Data.Option.Option a)
instance GHC.Show.Show a => GHC.Show.Show (Data.Option.Option a)
instance GHC.Base.Applicative Data.Option.Option
instance GHC.Base.Monad Data.Option.Option
instance GHC.Base.Monoid a => GHC.Base.Monoid (Data.Option.Option a)
instance GHC.Base.Alternative Data.Option.Option
instance GHC.Base.MonadPlus Data.Option.Option
instance Data.Aeson.Types.ToJSON.ToJSON a => Data.Aeson.Types.ToJSON.ToJSON (Data.Option.Option a)
instance Data.Aeson.Types.FromJSON.FromJSON a => Data.Aeson.Types.FromJSON.FromJSON (Data.Option.Option a)
instance Data.Option.ToOptionT GHC.Base.Maybe
instance Data.Option.ToOptionT Data.Option.Option
instance GHC.Base.Functor m => GHC.Base.Functor (Data.Option.OptionT m)
instance (GHC.Base.Functor m, GHC.Base.Monad m) => GHC.Base.Applicative (Data.Option.OptionT m)
instance GHC.Base.Monad m => Control.Monad.Fail.MonadFail (Data.Option.OptionT m)
instance GHC.Base.Monad m => GHC.Base.Monad (Data.Option.OptionT m)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Option.Option a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Data.Option.Option a)
instance Control.Monad.Trans.Class.MonadTrans Data.Option.OptionT
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Data.Option.OptionT m)
instance Control.Monad.Fail.MonadFail Data.Option.Option
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Data.Option.Option a)
instance Data.Hashable.Class.Hashable a => Data.Hashable.Class.Hashable (Data.Option.Option a)

module Data.StrictList
data StrictList a
Nil :: StrictList a
(:!) :: !a -> !(StrictList a) -> StrictList 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)

-- | Equivalent of <a>catMaybes</a> with <a>StrictList</a>.
catMaybes :: StrictList (Maybe a) -> StrictList a

-- | Equivalent to <a>catMaybes</a> with <a>Option</a> and
--   <a>StrictList</a>.
--   
--   <pre>
--   &gt;&gt;&gt; catOptions (sl [Some 1, None, Some 2, None, None, Some 3, Some 4])
--   [1,2,3,4]
--   </pre>
catOptions :: StrictList (Option a) -> StrictList a

-- | <pre>
--   &gt;&gt;&gt; catOptionsL [Some 1, None, Some 2, None, None, Some 3, Some 4]
--   [1,2,3,4]
--   </pre>
catOptionsL :: [Option a] -> StrictList a
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

-- | <a>delete</a> <tt>x</tt> removes the first occurrence of <tt>x</tt>
--   from its list argument. NOTE: Implementation copied from Data.List.
delete :: (Eq a) => a -> SL a -> SL a

-- | The <a>deleteBy</a> function behaves like <a>delete</a>, but takes a
--   user-supplied equality predicate. NOTE: Implementation copied from
--   Data.List.
deleteBy :: (a -> a -> Bool) -> a -> SL a -> SL a

-- | <a>deleteIdx</a> <tt>idx</tt> removes the element at index
--   <tt>idx</tt>.
--   
--   <pre>
--   not (null xs) ==&gt; Some (deleteIdx 0 xs) == tailOpt xs
--   </pre>
deleteIdx :: Int -> StrictList a -> StrictList a

-- | <pre>
--   &gt;&gt;&gt; drop 3 (sl [1, 2, 3, 4, 5])
--   [4,5]
--   </pre>
drop :: Int -> StrictList a -> StrictList a
dropWhile :: (a -> Bool) -> StrictList a -> StrictList a
dropWhileEnd :: (a -> Bool) -> SL a -> SL a
elem :: Eq a => a -> StrictList a -> Bool

-- | Equivalent of <a>filter</a> with <a>StrictList</a>.
filter :: (a -> Bool) -> StrictList a -> StrictList a
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

-- | <pre>
--   not (null xs) ==&gt; isSome (headOpt xs)
--   </pre>
headOpt :: StrictList a -> Option a
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

-- | <tt>lookupM'' showKey getKey getValue key list</tt> searches for
--   <tt>key</tt> in <tt>list</tt> using <tt>getKey</tt> as the key
--   extraction function and <tt>showKey</tt> to print all available keys
--   when no match is found.
lookupM'' :: (Monad m, Eq k) => (k -> String) -> (a -> Maybe k) -> k -> StrictList a -> m a
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 ()

-- | Equivalent of <a>mapMaybe</a> with <a>StrictList</a>.
mapMaybe :: (a -> Maybe b) -> StrictList a -> StrictList b

-- | Equivalent of <a>mapMaybe</a> with <a>Option</a> and
--   <a>StrictList</a>.
--   
--   <pre>
--   &gt;&gt;&gt; mapOption (\x -&gt; if even x then Some (x * 2) else None) (sl [1, 2, 3, 4, 5])
--   [4,8]
--   </pre>
mapOption :: (a -> Option b) -> StrictList a -> StrictList b
maximumM :: (Ord a, Monad m) => SL a -> m a

-- | <pre>
--   &gt;&gt;&gt; maybeToStrictList (Just "bar")
--   ["bar"]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; maybeToStrictList Nothing
--   []
--   </pre>
maybeToStrictList :: Maybe a -> StrictList a
mconcatSL :: Monoid a => SL a -> a
notElem :: Eq a => a -> StrictList a -> Bool
nub :: (Eq a, Hashable a) => SL a -> SL a

-- | <pre>
--   &gt;&gt;&gt; null (sl [])
--   True
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; null (sl ["foo"])
--   False
--   </pre>
null :: StrictList a -> Bool

-- | <pre>
--   &gt;&gt;&gt; optionToStrictList (Some "foo")
--   ["foo"]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; optionToStrictList None
--   []
--   </pre>
optionToStrictList :: Option a -> StrictList a
partition :: (a -> Bool) -> SL a -> (SL a, SL a)
replicate :: Integral i => i -> a -> StrictList a

-- | <pre>
--   reverse (reverse xs) == xs
--   </pre>
reverse :: StrictList a -> StrictList a
singleton :: a -> StrictList a
sl :: [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.
snoc :: SL a -> a -> SL a
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

-- | <pre>
--   &gt;&gt;&gt; sortOn snd (sl [("foo", 10), ("bar", 1), ("baz", 100)])
--   [("bar",1),("foo",10),("baz",100)]
--   </pre>
sortOn :: (Ord b) => (a -> b) -> StrictList a -> StrictList a
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)

-- | Safe <a>tail</a> function: Returns <a>None</a> for an empty list,
--   <a>Some</a> <tt>x</tt> for a non-empty list starting with <tt>x</tt>.
tailOpt :: StrictList a -> Option (StrictList a)

-- | <pre>
--   &gt;&gt;&gt; take 3 (sl [1, 2, 3, 4, 5, 6, 7])
--   [1,2,3]
--   </pre>
take :: Int -> StrictList a -> StrictList a
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

module Data.StrictVector
data Vector a

-- | <i>O(1)</i> Test whether a vector if empty
null :: Vector a -> Bool

-- | <i>O(1)</i> Yield the length of the vector.
length :: Vector a -> Int

-- | O(1) Indexing
(!) :: Vector a -> Int -> a

-- | O(1) Safe indexing
(!?) :: Vector a -> Int -> Maybe a

-- | <i>O(1)</i> First element
head :: Vector a -> a

-- | <i>O(1)</i> Last element
last :: Vector a -> a
fromList :: [a] -> Vector a
fromListN :: Int -> [a] -> Vector a
toList :: Vector a -> [a]
empty :: Vector a
singleton :: a -> Vector a
generate :: Int -> (Int -> a) -> Vector a
generateM :: Monad m => Int -> (Int -> m a) -> m (Vector a)
catMaybes :: Vector (Maybe a) -> Vector a
mapMaybe :: (a -> Maybe b) -> Vector a -> Vector b
lastMay :: Vector a -> Maybe a
toHashSet :: (Eq a, Hashable a) => Vector a -> HashSet a
lookAround :: Vector a -> Vector (Maybe a, a, Maybe a)
dropWhileEnd :: (a -> Bool) -> Vector a -> Vector a
dropWhileLookingAround :: (Maybe a -> a -> Maybe a -> Bool) -> Vector a -> Vector a
fromSL :: SL a -> Vector a
imapM :: Monad m => (Int -> a -> m b) -> Vector a -> m (Vector b)
binarySearchL :: (e -> Ordering) -> Vector e -> Int
binarySearchR :: (e -> Ordering) -> Vector e -> Int
sort :: Ord a => Vector a -> Vector a
sortBy :: (a -> a -> Ordering) -> Vector a -> Vector a
sortOn :: Ord b => (a -> b) -> Vector a -> Vector a
groupBy :: (a -> a -> Bool) -> Vector a -> Vector (Vector a)
groupOn :: Eq b => (a -> b) -> Vector a -> Vector (b, Vector a)
toSL :: Vector a -> SL a
uncons :: Vector a -> Option (a, Vector a)
updateVector :: Int -> a -> a -> Vector a -> Vector a
updateVectorWith :: Int -> a -> (a -> a) -> Vector a -> Vector a
unfoldrM :: Monad m => (s -> m (Maybe (a, s))) -> s -> m (Vector a)
unfoldrNM :: Monad m => Int -> (s -> m (Maybe (a, s))) -> s -> m (Vector a)

-- | Returns <a>Just</a> the only element of the vector if there is exactly
--   one element or <a>Nothing</a> otherwise.
theOnlyOne :: Vector a -> Maybe a
instance Data.Data.Data a => Data.Data.Data (Data.StrictVector.Vector a)
instance Data.Foldable.Foldable Data.StrictVector.Vector
instance GHC.Base.Monoid (Data.StrictVector.Vector a)
instance Data.Aeson.Types.ToJSON.ToJSON a => Data.Aeson.Types.ToJSON.ToJSON (Data.StrictVector.Vector a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Data.StrictVector.Vector a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.StrictVector.Vector a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.StrictVector.Vector a)
instance Data.Vector.Generic.Base.Vector Data.StrictVector.Vector a
instance GHC.Show.Show a => GHC.Show.Show (Data.StrictVector.Vector a)
instance GHC.Read.Read a => GHC.Read.Read (Data.StrictVector.Vector a)
instance Data.Hashable.Class.Hashable a => Data.Hashable.Class.Hashable (Data.StrictVector.Vector a)
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Data.StrictVector.Vector a)
instance GHC.Base.Functor Data.StrictVector.Vector
instance Control.Monad.Fail.MonadFail Data.StrictVector.Vector
instance GHC.Base.Monad Data.StrictVector.Vector
instance GHC.Base.MonadPlus Data.StrictVector.Vector
instance GHC.Base.Applicative Data.StrictVector.Vector
instance GHC.Base.Alternative Data.StrictVector.Vector
instance Data.Traversable.Traversable Data.StrictVector.Vector
instance GHC.Exts.IsList (Data.StrictVector.Vector a)
instance Data.Aeson.Types.FromJSON.FromJSON a => Data.Aeson.Types.FromJSON.FromJSON (Data.StrictVector.Vector a)

module Data.Choice

-- | <a>Choice</a> is a version of <a>Either</a> that is strict on both the
--   <a>Left</a> side (called <a>This</a>) and the <a>Right</a> side
--   (called <a>That</a>).
--   
--   Note: <a>Choice</a> is not used as an error monad. Use <a>Fail</a> for
--   that.
data Choice a b
This :: !a -> Choice a b
That :: !b -> Choice a b

-- | <tt>Choice'</tt>s version of <a>either</a>
choice :: (a -> c) -> (b -> c) -> Choice a b -> c

-- | <pre>
--   &gt;&gt;&gt; this (This "foo") :: Maybe String
--   Just "foo"
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; this (That "bar") :: Maybe String
--   Nothing
--   </pre>
this :: Monad m => Choice a b -> m a

-- | <pre>
--   &gt;&gt;&gt; that (This "foo") :: Maybe String
--   Nothing
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; that (That "bar") :: Maybe String
--   Just "bar"
--   </pre>
that :: Monad m => Choice a b -> m b

-- | <pre>
--   &gt;&gt;&gt; these [This "foo", This "bar", That "baz", This "quux"]
--   ["foo","bar","quux"]
--   </pre>
these :: [Choice a b] -> [a]

-- | <pre>
--   &gt;&gt;&gt; those [This "foo", This "bar", That "baz", This "quux"]
--   ["baz"]
--   </pre>
those :: [Choice a b] -> [b]

-- | <pre>
--   &gt;&gt;&gt; eitherToChoice (Left 1)
--   This 1
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; eitherToChoice (Right 5)
--   That 5
--   </pre>
eitherToChoice :: Either a b -> Choice a b

-- | <pre>
--   &gt;&gt;&gt; mergeChoice (This 5 :: Choice Int Int)
--   5
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; mergeChoice (That 'c' :: Choice Char Char)
--   'c'
--   </pre>
mergeChoice :: Choice a a -> a
instance (Data.Data.Data b, Data.Data.Data a) => Data.Data.Data (Data.Choice.Choice a b)
instance (GHC.Show.Show b, GHC.Show.Show a) => GHC.Show.Show (Data.Choice.Choice a b)
instance (GHC.Read.Read b, GHC.Read.Read a) => GHC.Read.Read (Data.Choice.Choice a b)
instance (GHC.Classes.Ord b, GHC.Classes.Ord a) => GHC.Classes.Ord (Data.Choice.Choice a b)
instance (GHC.Classes.Eq b, GHC.Classes.Eq a) => GHC.Classes.Eq (Data.Choice.Choice a b)
instance Data.Bifunctor.Bifunctor Data.Choice.Choice
instance (Data.Hashable.Class.Hashable a, Data.Hashable.Class.Hashable b) => Data.Hashable.Class.Hashable (Data.Choice.Choice a b)
instance GHC.Base.Applicative (Data.Choice.Choice e)
instance GHC.Base.Functor (Data.Choice.Choice a)
instance GHC.Base.Monad (Data.Choice.Choice e)
instance (Test.QuickCheck.Arbitrary.Arbitrary a, Test.QuickCheck.Arbitrary.Arbitrary b) => Test.QuickCheck.Arbitrary.Arbitrary (Data.Choice.Choice a b)
instance (Control.DeepSeq.NFData a, Control.DeepSeq.NFData b) => Control.DeepSeq.NFData (Data.Choice.Choice a b)