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


-- | Simple Data Processing
--   
--   SDP provides generalized interface for simple data operations.
@package sdp
@version 0.2


-- | <a>Control.Exception.SDP</a> - service module that provide some useful
--   exceptions. Note that <a>SDP.SafePrelude</a> doesn't export this
--   module.
module Control.Exception.SDP

-- | A <a>UnreachableException</a> is used as an exception that should
--   never be thrown.
--   
--   <ul>
--   <li><a>ErrorCall</a> and <a>AssertionFailed</a> means that the
--   function is partially defined or missused (if some arguments shouldn't
--   be passed).</li>
--   <li><a>UnreachableException</a> means that some expression, by
--   definition, cannot be reached (for example, a default value when
--   initializing an array, if each value is guaranteed to be overwritten
--   before use).</li>
--   </ul>
data UnreachableException
UnreachableException :: String -> UnreachableException

-- | <a>IndexException</a> replaces the less informative
--   <a>ArrayException</a> and has more neutral names.
--   
--   <ul>
--   <li><a>UnacceptableExpansion</a> - occurs if the desired range exceed
--   the actual size</li>
--   <li><a>UnexpectedRank</a> - occurs when trying to convert a list into
--   a generalized index of inappropriate dimension</li>
--   <li><a>UndefinedValue</a> - occurs if the value is undefined</li>
--   <li><a>EmptyRange</a> - occurs if range is empty</li>
--   <li><a>IndexOverflow</a> - occurs if index overflows range</li>
--   <li><a>IndexUnderflow</a> - occurs if index underflows range</li>
--   </ul>
--   
--   <a>Exception</a> constructors are specified in the order of
--   definition, this is the recommended check order.
--   
--   If the error type may depend on the check order, it should be
--   indicated in the documentation. For example: overflow is checked
--   first, and then underflow. But if an overflow is detected, underflow
--   may not be noticed.
data IndexException
UnacceptableExpansion :: String -> IndexException
UndefinedValue :: String -> IndexException
UnexpectedRank :: String -> IndexException
IndexUnderflow :: String -> IndexException
IndexOverflow :: String -> IndexException
EmptyRange :: String -> IndexException
instance GHC.Classes.Eq Control.Exception.SDP.IndexException
instance GHC.Classes.Eq Control.Exception.SDP.UnreachableException
instance GHC.Show.Show Control.Exception.SDP.UnreachableException
instance GHC.Exception.Type.Exception Control.Exception.SDP.UnreachableException
instance GHC.Show.Show Control.Exception.SDP.IndexException
instance GHC.Exception.Type.Exception Control.Exception.SDP.IndexException


-- | <a>SDP.Comparing</a> provide common comparators and combinators.
module SDP.Comparing

-- | <a>Equal</a> is just synonym of <tt>(e -&gt; e -&gt; Bool)</tt>.
type Equal e = e -> e -> Bool

-- | <a>Compare</a> is just synonym of <tt>(e -&gt; e -&gt; Ordering)</tt>.
type Compare e = e -> e -> Ordering

-- | Spaceship operator - infix version of compare.
(<=>) :: Ord o => Compare o
infixl 4 <=>

-- | Compare tuples by first elements.
eqfst :: Eq e => Equal (e, s)

-- | Compare tuples by second elements.
eqsnd :: Eq e => Equal (f, e)

-- | Compare tuples by first elements.
cmpfst :: Ord o => Compare (o, s)

-- | Compare tuples by second elements.
cmpsnd :: Ord o => Compare (f, o)

-- | Common compare combinator
invertcmp :: Compare e -> Compare e


-- | <a>SDP.Estimate</a> provides <a>Estimate</a> class, type synonyms and
--   some common comparators. This module is exported by
--   <a>SDP.SafePrelude</a>.
module SDP.Estimate

-- | <a>Estimate</a> class provides the lazy comparsion structures by
--   length.
--   
--   For some types (e.g., lists), this allows you to speed up the
--   comparison or make it finite. For others (e.g., arrays), it may be
--   convenient abbreviation.
class Estimate e

-- | Left-side structure length with number comparison.
(<.=>) :: Estimate e => e -> Int -> Ordering

-- | Two structures by length comparison.
(<==>) :: Estimate e => Compare e

-- | Left-side structure length with number comparison.
(.==) :: Estimate e => e -> Int -> Bool

-- | Left-side structure length with number comparison.
(./=) :: Estimate e => e -> Int -> Bool

-- | Left-side structure length with number comparison.
(.<=) :: Estimate e => e -> Int -> Bool

-- | Left-side structure length with number comparison.
(.>=) :: Estimate e => e -> Int -> Bool

-- | Left-side structure length with number comparison.
(.<) :: Estimate e => e -> Int -> Bool

-- | Left-side structure length with number comparison.
(.>) :: Estimate e => e -> Int -> Bool

-- | Two structures comparison by length.
(.<.) :: Estimate e => e -> e -> Bool

-- | Two structures comparison by length.
(.>.) :: Estimate e => e -> e -> Bool

-- | Two structures comparison by length.
(.<=.) :: Estimate e => e -> e -> Bool

-- | Two structures comparison by length.
(.>=.) :: Estimate e => e -> e -> Bool

-- | Two structures comparison by length.
(.==.) :: Estimate e => e -> e -> Bool

-- | Two structures comparison by length.
(./=.) :: Estimate e => e -> e -> Bool
infixl 4 <==>
infixl 4 .<.
infixl 4 .>.
infixl 4 .<=.
infixl 4 .>=.
infixl 4 .==.
infixl 4 ./=.
infixl 4 <.=>
infixl 4 .<
infixl 4 .>
infixl 4 .<=
infixl 4 .>=
infixl 4 .==
infixl 4 ./=

-- | Right-side number with structure length comparison.
(<=.>) :: Estimate e => Int -> e -> Ordering
infixl 4 <=.>

-- | Right-side number with structure length comparison.
(<.) :: Estimate e => Int -> e -> Bool
infixl 4 <.

-- | Right-side number with structure length comparison.
(>.) :: Estimate e => Int -> e -> Bool
infixl 4 >.

-- | Right-side number with structure length comparison.
(<=.) :: Estimate e => Int -> e -> Bool
infixl 4 <=.

-- | Right-side number with structure length comparison.
(>=.) :: Estimate e => Int -> e -> Bool
infixl 4 >=.

-- | Right-side number with structure length comparison.
(==.) :: Estimate e => Int -> e -> Bool
infixl 4 ==.

-- | Right-side number with structure length comparison.
(/=.) :: Estimate e => Int -> e -> Bool
infixl 4 /=.
instance SDP.Estimate.Estimate [a]


-- | <a>SDP.Nullable</a> provides <a>Nullable</a> - class of types with
--   empty values.
module SDP.Nullable

-- | <a>Nullable</a> is class of types which value may be empty.
class Nullable e

-- | Empty value.
lzero :: Nullable e => e

-- | Is value empty?
isNull :: Nullable e => e -> Bool

-- | Originally defined in <tt>sdp-ctypes</tt> (now <tt>sdp-foreign</tt>),
--   same as <tt>Z</tt> now.
pattern NULL :: Nullable e => e
instance SDP.Nullable.Nullable (GHC.Maybe.Maybe e)
instance SDP.Nullable.Nullable [e]
instance SDP.Nullable.Nullable (GHC.Ptr.Ptr e)
instance SDP.Nullable.Nullable (GHC.ForeignPtr.ForeignPtr e)
instance SDP.Nullable.Nullable (GHC.Stable.StablePtr e)


-- | <a>SDP.Ratio</a> provides <tt>(<a>:%</a>)</tt> pattern for
--   <a>Ratio</a>.
module SDP.Ratio

-- | Crutch pattern: real (<a>:%</a>) is closed <a>Ratio</a> constructor.
pattern (:%) :: Integral a => a -> a -> Ratio a
infixl 7 :%


-- | <a>SDP.SafePrelude</a> module re-exports common <a>Prelude</a>
--   definitions except those overridden in this library and its extensions
--   (e.g. <tt>sdp-io</tt>).
--   
--   In addition, this module re-exports the most common definitions from
--   other <tt>base</tt> and <tt>sdp</tt> modules
--   (<a>Control.Applicative</a>, <a>Data.Bufunctor</a>,
--   <a>SDP.Estimate</a>, etc.) and some useful combinators that were used
--   in this library and may be useful to its users.
--   
--   Import <a>Prelude</a> without conflicting functions, may require
--   additional imports for functions overridden in other modules:
--   
--   <pre>
--   import Prelude ()
--   import SDP.SafePrelude
--   
--   </pre>
module SDP.SafePrelude

-- | Ternary operator.
--   
--   <pre>
--   (odd 1 ? "is True" $ "is False") == "is True"
--   </pre>
(?) :: Bool -> a -> a -> a
infixr 1 ?

-- | <tt>p ?+ f $ a</tt> returns <tt><a>Just</a> (f a)</tt> if <tt>(p
--   a)</tt> and <a>Nothing</a> otherwise.
(?+) :: (a -> Bool) -> (a -> b) -> a -> Maybe b
infixl 8 ?+

-- | <tt>p ?- f $ a</tt> returns <a>Nothing</a> if <tt>(p a)</tt> and
--   <tt><a>Just</a> (f a)</tt> otherwise.
(?-) :: (a -> Bool) -> (a -> b) -> a -> Maybe b
infixl 8 ?-

-- | Prepends <a>Maybe</a> to list.
(?:) :: Maybe a -> [a] -> [a]

-- | Short version of <a>fromMaybe</a>.
(+?) :: a -> Maybe a -> a

-- | <tt>(...) = (.) . (.)</tt>.
(...) :: (c -> d) -> (a -> b -> c) -> a -> b -> d
infixr 0 ...

-- | Lifted <tt>(<a>?</a>)</tt>.
(?^) :: Monad m => m Bool -> m a -> m a -> m a
infixr 1 ?^

-- | Monadic version of <tt>(<a>...</a>)</tt>.
(<=<<) :: Monad m => (c -> m d) -> (a -> b -> m c) -> a -> b -> m d

-- | Monadic vesion of <tt>(<a>...</a>)</tt> with reversed arguments.
(>>=>) :: Monad m => (a -> b -> m c) -> (c -> m d) -> a -> b -> m d

-- | <tt>ma &gt;&gt;=&lt;&lt; mb</tt> is composition of <a>join</a> and
--   <a>liftM2</a>.
(>>=<<) :: Monad m => m a -> m b -> (a -> b -> m c) -> m c

-- | Very useful combinator.
liftA4 :: Applicative t => (a -> b -> c -> d -> e) -> t a -> t b -> t c -> t d -> t e

-- | Very very useful combinator
liftA5 :: Applicative t => (a -> b -> c -> d -> e -> f) -> t a -> t b -> t c -> t d -> t e -> t f

-- | An even more useful combinator.
liftA6 :: Applicative t => (a -> b -> c -> d -> e -> f -> g) -> t a -> t b -> t c -> t d -> t e -> t f -> t g

-- | See <a>liftA6</a>.
liftM6 :: Monad m => (a -> b -> c -> d -> e -> f -> g) -> m a -> m b -> m c -> m d -> m e -> m f -> m g

-- | <a>stToMIO</a> is just <tt><a>liftIO</a> . <a>stToIO</a></tt>.
stToMIO :: MonadIO io => ST RealWorld e -> io e


-- | <a>SDP.Finite</a> provide generalized finite-dimensional index type
--   (<a>:&amp;</a>) based on <tt>repa</tt> <tt>(:.)</tt>.
--   
--   Since <tt>sdp-0.2</tt>, for (<a>:&amp;</a>) available
--   <tt>OverloadedLists</tt>-based syntactic sugar. For example, instead
--   of the inconvenient <tt>es!(ind4 0 1 2 3)</tt> or just awful
--   <tt>es!(E:&amp;0:&amp;1:&amp;1:&amp;2:&amp;3)</tt> you can write:
--   <tt>es![0, 1, 2, 3]</tt>.
--   
--   Note that <tt>OverloadedLists</tt> instances requires a strictly
--   defined number of subindexes.
module SDP.Finite

-- | Service type, that represents zero-dimensional index.
data E
E :: E

-- | N-dimensional index type. The type (head :&amp; tail) allows working
--   with any finite dimension number.
data tail :& head
(:&) :: !tail -> !head -> (:&) tail head

-- | 1-dimensional index (<tt>(E :&amp; i)</tt> without
--   <tt>TypeOperators</tt>).
type I1 i = E :& i

-- | 2-dimensional index
type I2 i = E :& i :& i

-- | 3-dimensional index
type I3 i = (I2 i) :& i

-- | 4-dimensional index
type I4 i = (I3 i) :& i

-- | 5-dimensional index
type I5 i = (I4 i) :& i

-- | 6-dimensional index
type I6 i = (I5 i) :& i

-- | 7-dimensional index
type I7 i = (I6 i) :& i

-- | 8-dimensional index
type I8 i = (I7 i) :& i

-- | 9-dimensional index
type I9 i = (I8 i) :& i

-- | 10-dimensional index
type I10 i = (I9 i) :& i

-- | 11-dimensional index
type I11 i = (I10 i) :& i

-- | 12-dimensional index
type I12 i = (I11 i) :& i

-- | 13-dimensional index
type I13 i = (I12 i) :& i

-- | 14-dimensional index
type I14 i = (I13 i) :& i

-- | 15-dimensional index
type I15 i = (I14 i) :& i

-- | 2-dimensional index constructor.
ind2 :: i -> i -> I2 i

-- | 3-dimensional index constructor.
ind3 :: i -> i -> i -> I3 i

-- | 4-dimensional index constructor.
ind4 :: i -> i -> i -> i -> I4 i

-- | 5-dimensional index constructor.
ind5 :: i -> i -> i -> i -> i -> I5 i

-- | 6-dimensional index constructor.
ind6 :: i -> i -> i -> i -> i -> i -> I6 i

-- | 7-dimensional index constructor.
ind7 :: i -> i -> i -> i -> i -> i -> i -> I7 i

-- | 8-dimensional index constructor.
ind8 :: i -> i -> i -> i -> i -> i -> i -> i -> I8 i

-- | 9-dimensional index constructor.
ind9 :: i -> i -> i -> i -> i -> i -> i -> i -> i -> I9 i

-- | 10-dimensional index constructor.
ind10 :: i -> i -> i -> i -> i -> i -> i -> i -> i -> i -> I10 i

-- | 11-dimensional index constructor.
ind11 :: i -> i -> i -> i -> i -> i -> i -> i -> i -> i -> i -> I11 i

-- | 12-dimensional index constructor.
ind12 :: i -> i -> i -> i -> i -> i -> i -> i -> i -> i -> i -> i -> I12 i

-- | 13-dimensional index constructor.
ind13 :: i -> i -> i -> i -> i -> i -> i -> i -> i -> i -> i -> i -> i -> I13 i

-- | 14-dimensional index constructor.
ind14 :: i -> i -> i -> i -> i -> i -> i -> i -> i -> i -> i -> i -> i -> i -> I14 i

-- | 15-dimensional index constructor.
ind15 :: i -> i -> i -> i -> i -> i -> i -> i -> i -> i -> i -> i -> i -> i -> i -> I15 i
instance GHC.Read.Read SDP.Finite.E
instance GHC.Show.Show SDP.Finite.E
instance GHC.Classes.Ord SDP.Finite.E
instance GHC.Classes.Eq SDP.Finite.E
instance (GHC.Classes.Ord tail, GHC.Classes.Ord head) => GHC.Classes.Ord (tail SDP.Finite.:& head)
instance (GHC.Classes.Eq tail, GHC.Classes.Eq head) => GHC.Classes.Eq (tail SDP.Finite.:& head)
instance GHC.Enum.Enum i => GHC.Enum.Enum (SDP.Finite.E SDP.Finite.:& i)
instance (Data.Default.Class.Default d, Data.Default.Class.Default d') => Data.Default.Class.Default (d SDP.Finite.:& d')
instance (GHC.Exts.IsList (i' SDP.Finite.:& i), GHC.Exts.Item (i' SDP.Finite.:& i) ~ i, GHC.Show.Show i) => GHC.Show.Show (i' SDP.Finite.:& i)
instance (GHC.Exts.IsList (i' SDP.Finite.:& i), GHC.Exts.Item (i' SDP.Finite.:& i) ~ i, GHC.Read.Read i) => GHC.Read.Read (i' SDP.Finite.:& i)
instance GHC.Exts.IsList (SDP.Finite.E SDP.Finite.:& i)
instance (GHC.Exts.Item (i' SDP.Finite.:& i) ~ i, GHC.Exts.IsList (i' SDP.Finite.:& i)) => GHC.Exts.IsList ((i' SDP.Finite.:& i) SDP.Finite.:& i)
instance Data.Default.Class.Default SDP.Finite.E
instance GHC.Exts.IsList SDP.Finite.E


-- | <a>SDP.SortM</a> provides <a>SortM</a> - class of sortable mutable
--   structures.
module SDP.SortM

-- | <a>SortM</a> is class of sortable mutable structures.
class SortM m s e | s -> m, s -> e

-- | Checks if structure is already sorted. Should always return
--   <a>True</a> for structures with less than 2 elements.
sortedMBy :: SortM m s e => (e -> e -> Bool) -> s -> m Bool

-- | <a>sortMBy</a> is common sorting algorithm.
sortMBy :: SortM m s e => Compare e -> s -> m ()

-- | Kind (* -&gt; *) version of <a>SortM</a>.
type SortM1 m s e = SortM m (s e) e

-- | <a>sortM</a> is just <tt><a>sortMBy</a> <a>compare</a></tt>
sortM :: (SortM m s e, Ord e) => s -> m ()

-- | Sort by comparing the results of a key function applied to each
--   element.
sortMOn :: (SortM m s e, Ord o) => (e -> o) -> s -> m ()

-- | Checks if the structure is sorted.
sortedM :: (SortM m s e, Ord e) => s -> m Bool

-- | Sort by comparing the results of a given function applied to each
--   element.
sortedMOn :: (SortM m s e, Ord o) => (e -> o) -> s -> m Bool


-- | <a>SDP.Tuple</a> provides tuple type synonyms.
module SDP.Tuple

-- | Tuple synonym
type T2 i = (i, i)

-- | Tuple synonym
type T3 i = (i, i, i)

-- | Tuple synonym
type T4 i = (i, i, i, i)

-- | Tuple synonym
type T5 i = (i, i, i, i, i)

-- | Tuple synonym
type T6 i = (i, i, i, i, i, i)

-- | Tuple synonym
type T7 i = (i, i, i, i, i, i, i)

-- | Tuple synonym
type T8 i = (i, i, i, i, i, i, i, i)

-- | Tuple synonym
type T9 i = (i, i, i, i, i, i, i, i, i)

-- | Tuple synonym
type T10 i = (i, i, i, i, i, i, i, i, i, i)

-- | Tuple synonym
type T11 i = (i, i, i, i, i, i, i, i, i, i, i)

-- | Tuple synonym
type T12 i = (i, i, i, i, i, i, i, i, i, i, i, i)

-- | Tuple synonym
type T13 i = (i, i, i, i, i, i, i, i, i, i, i, i, i)

-- | Tuple synonym
type T14 i = (i, i, i, i, i, i, i, i, i, i, i, i, i, i)

-- | Tuple synonym
type T15 i = (i, i, i, i, i, i, i, i, i, i, i, i, i, i, i)

-- | Return all first elements in pairs.
fsts :: Functor f => f (a, b) -> f a

-- | Return all first elements in pairs.
snds :: Functor f => f (a, b) -> f b

-- | Applies function to both elements of pair.
both :: (a -> b) -> (a, a) -> (b, b)


-- | <a>SDP.Shape</a> module provides <a>Shape</a> - class of generalized
--   indices.
module SDP.Shape

-- | <a>Shape</a> is service class that constraints <a>Index</a>.
--   
--   Rules:
--   
--   <pre>
--   rank i == rank   (j `asTypeOf` i)
--   rank i == length (sizes (i, i))
--   </pre>
--   
--   <pre>
--   rank (lastDim E) = 0
--   rank (lastDim i) = 1
--   rank (initDim E) = 0
--   rank (lastDim i) = rank i - 1
--   </pre>
--   
--   <pre>
--   fromGIndex . toGIndex = id
--   toGIndex . fromGIndex = id
--   </pre>
class Shape i where {
    
    -- | Type of index top dimension.
    type family DimLast i :: Type;
    
    -- | The type of subspace of <a>rank</a> <tt>n - 1</tt>, where <tt>n</tt>
    --   is the <a>rank</a> of the space specified by this <a>Index</a> type.
    type family DimInit i :: Type;
    type DimLast i = i;
    type DimInit i = E;
}

-- | Create index from generalized index.
fromGIndex :: (Shape i, RANK1 i) => GIndex i -> i

-- | Create index from generalized index.
fromGIndex :: Shape i => GIndex i -> i

-- | Create generalized index from index.
toGIndex :: (Shape i, RANK1 i) => i -> GIndex i

-- | Create generalized index from index.
toGIndex :: Shape i => i -> GIndex i

-- | Count of dimensions in represented space (must be finite and
--   constant).
rank :: Shape i => i -> Int

-- | Add new dimension.
consDim :: (Shape i, DimLast i ~~ i) => DimInit i -> DimLast i -> i

-- | Add new dimension.
consDim :: Shape i => DimInit i -> DimLast i -> i
initDim :: (Shape i, DimInit i ~~ E) => i -> DimInit i
initDim :: Shape i => i -> DimInit i
lastDim :: (Shape i, DimLast i ~~ i) => i -> DimLast i
lastDim :: Shape i => i -> DimLast i
unconsDim :: Shape i => i -> (DimInit i, DimLast i)

-- | Type operator <a>GIndex</a> returns generalized equivalent of index.
type family GIndex i

-- | Convert any index type bounds to generalized index bounds.
toGBounds :: Shape i => (i, i) -> (GIndex i, GIndex i)

-- | Convert generalized index bounds to any index type bounds.
fromGBounds :: Shape i => (GIndex i, GIndex i) -> (i, i)

-- | A constraint corresponding to rank 0 indices (<a>E</a>).
type RANK0 i = i ~~ E

-- | The restriction corresponding to rank indices 1 (сhecks
--   <a>GIndex</a>).
type RANK1 i = GIndex i ~~ (E :& i)

-- | The restriction corresponding to rank indices 2 (сhecks
--   <a>GIndex</a>).
type RANK2 i = GIndex i ~~ I2 i

-- | The restriction corresponding to rank indices 3 (сhecks
--   <a>GIndex</a>).
type RANK3 i = GIndex i ~~ I3 i

-- | The restriction corresponding to rank indices 4 (сhecks
--   <a>GIndex</a>).
type RANK4 i = GIndex i ~~ I4 i

-- | The restriction corresponding to rank indices 5 (сhecks
--   <a>GIndex</a>).
type RANK5 i = GIndex i ~~ I5 i

-- | The restriction corresponding to rank indices 6 (сhecks
--   <a>GIndex</a>).
type RANK6 i = GIndex i ~~ I6 i

-- | The restriction corresponding to rank indices 7 (сhecks
--   <a>GIndex</a>).
type RANK7 i = GIndex i ~~ I7 i

-- | The restriction corresponding to rank indices 8 (сhecks
--   <a>GIndex</a>).
type RANK8 i = GIndex i ~~ I8 i

-- | The restriction corresponding to rank indices 9 (сhecks
--   <a>GIndex</a>).
type RANK9 i = GIndex i ~~ I9 i

-- | The restriction corresponding to rank indices 10 (сhecks
--   <a>GIndex</a>).
type RANK10 i = GIndex i ~~ I10 i

-- | The restriction corresponding to rank indices 11 (сhecks
--   <a>GIndex</a>).
type RANK11 i = GIndex i ~~ I11 i

-- | The restriction corresponding to rank indices 12 (сhecks
--   <a>GIndex</a>).
type RANK12 i = GIndex i ~~ I12 i

-- | The restriction corresponding to rank indices 13 (сhecks
--   <a>GIndex</a>).
type RANK13 i = GIndex i ~~ I13 i

-- | The restriction corresponding to rank indices 14 (сhecks
--   <a>GIndex</a>).
type RANK14 i = GIndex i ~~ I14 i

-- | The restriction corresponding to rank indices 15 (сhecks
--   <a>GIndex</a>).
type RANK15 i = GIndex i ~~ I15 i
instance SDP.Shape.Shape SDP.Finite.E
instance SDP.Shape.Shape ()
instance SDP.Shape.Shape GHC.Types.Char
instance SDP.Shape.Shape GHC.Integer.Type.Integer
instance SDP.Shape.Shape GHC.Types.Int
instance SDP.Shape.Shape GHC.Int.Int8
instance SDP.Shape.Shape GHC.Int.Int16
instance SDP.Shape.Shape GHC.Int.Int32
instance SDP.Shape.Shape GHC.Int.Int64
instance SDP.Shape.Shape GHC.Types.Word
instance SDP.Shape.Shape GHC.Word.Word8
instance SDP.Shape.Shape GHC.Word.Word16
instance SDP.Shape.Shape GHC.Word.Word32
instance SDP.Shape.Shape GHC.Word.Word64
instance SDP.Shape.Shape Foreign.C.Types.CChar
instance SDP.Shape.Shape Foreign.C.Types.CUChar
instance SDP.Shape.Shape Foreign.C.Types.CSChar
instance SDP.Shape.Shape Foreign.C.Types.CWchar
instance SDP.Shape.Shape Foreign.C.Types.CShort
instance SDP.Shape.Shape Foreign.C.Types.CUShort
instance SDP.Shape.Shape Foreign.C.Types.CInt
instance SDP.Shape.Shape Foreign.C.Types.CUInt
instance SDP.Shape.Shape Foreign.C.Types.CLong
instance SDP.Shape.Shape Foreign.C.Types.CLLong
instance SDP.Shape.Shape Foreign.C.Types.CULong
instance SDP.Shape.Shape Foreign.C.Types.CULLong
instance SDP.Shape.Shape Foreign.C.Types.CIntPtr
instance SDP.Shape.Shape Foreign.C.Types.CUIntPtr
instance SDP.Shape.Shape Foreign.C.Types.CIntMax
instance SDP.Shape.Shape Foreign.C.Types.CUIntMax
instance SDP.Shape.Shape Foreign.C.Types.CSize
instance SDP.Shape.Shape Foreign.C.Types.CBool
instance SDP.Shape.Shape Foreign.C.Types.CPtrdiff
instance SDP.Shape.Shape Foreign.C.Types.CSigAtomic
instance SDP.Shape.Shape i => SDP.Shape.Shape (SDP.Finite.E SDP.Finite.:& i)
instance (SDP.Shape.Shape i, GHC.Enum.Enum i, GHC.Enum.Bounded i, SDP.Shape.Shape (i' SDP.Finite.:& i)) => SDP.Shape.Shape ((i' SDP.Finite.:& i) SDP.Finite.:& i)
instance (SDP.Shape.Shape i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Shape.Shape (SDP.Tuple.T2 i)
instance (SDP.Shape.Shape i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Shape.Shape (SDP.Tuple.T3 i)
instance (SDP.Shape.Shape i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Shape.Shape (SDP.Tuple.T4 i)
instance (SDP.Shape.Shape i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Shape.Shape (SDP.Tuple.T5 i)
instance (SDP.Shape.Shape i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Shape.Shape (SDP.Tuple.T6 i)
instance (SDP.Shape.Shape i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Shape.Shape (SDP.Tuple.T7 i)
instance (SDP.Shape.Shape i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Shape.Shape (SDP.Tuple.T8 i)
instance (SDP.Shape.Shape i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Shape.Shape (SDP.Tuple.T9 i)
instance (SDP.Shape.Shape i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Shape.Shape (SDP.Tuple.T10 i)
instance (SDP.Shape.Shape i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Shape.Shape (SDP.Tuple.T11 i)
instance (SDP.Shape.Shape i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Shape.Shape (SDP.Tuple.T12 i)
instance (SDP.Shape.Shape i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Shape.Shape (SDP.Tuple.T13 i)
instance (SDP.Shape.Shape i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Shape.Shape (SDP.Tuple.T14 i)
instance (SDP.Shape.Shape i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Shape.Shape (SDP.Tuple.T15 i)


-- | The <a>Index</a> class is a fork of <a>Ix</a> with a richer interface,
--   more convenient function names and generalized indexes.
module SDP.Index

-- | <tt>(<a>:|:</a>)</tt> is closed type family of shape differences.
type family i :|: j

-- | <a>SubIndex</a> is service constraint that corresponds closed
--   (internal) class <tt>Sub</tt>. <tt><a>SubIndex</a> i j </tt> matches
--   if <a>Index</a> type <tt>i</tt> is subspace of <a>Index</a> type
--   <tt>j</tt>.
type SubIndex = Sub

-- | Take some dimensions.
--   
--   <pre>
--   &gt;&gt;&gt; takeDim ([1, 2, 3, 4] :: I4 Int) :: I1 Int
--   [1]
--   
--   &gt;&gt;&gt; takeDim ([1, 2, 3, 4] :: I4 Int) :: E
--   E
--   </pre>
takeDim :: Sub i j => i -> j

-- | Drop some dimensions (second argument used as type variable).
--   
--   <pre>
--   &gt;&gt;&gt; dropDim ([1, 2, 3, 4] :: I4 Int) ([] :: E)
--   [1, 2, 3, 4]
--   
--   &gt;&gt;&gt; dropDim ([1, 2, 3, 4] :: I4 Int) ([1, 2] :: I2 Int)
--   [3, 4]
--   </pre>
dropDim :: Sub i j => i -> j -> i :|: j

-- | Join some dimensions.
--   
--   <pre>
--   &gt;&gt;&gt; joinDim ([1, 2] :: I2 Int) [3] :: I3 Int
--   [1, 2, 3]
--   
--   &gt;&gt;&gt; joinDim ([1, 2] :: I2 Int) [3, 4] :: I4 Int
--   [1, 2, 3, 4]
--   </pre>
joinDim :: Sub i j => j -> (i :|: j) -> i

-- | <a>splitDim</a> returns pair of shape difference and subshape.
splitDim :: SubIndex i j => i -> (i :|: j, j)

-- | Index is service class based on <tt>base</tt> Ix and <tt>repa</tt>
--   Shape.
--   
--   Basic rules:
--   
--   <pre>
--   size bnds &gt;= 0
--   size bnds == product (sizes bnds)
--   </pre>
--   
--   <pre>
--   isEmpty bnds == (size bnds == 0)
--   isEmpty bnds == inRange bnds (safeElem bnds i)
--   </pre>
--   
--   <pre>
--   isEmpty bnds =&gt; isOverflow  bnds i
--   isEmpty bnds =&gt; isUnderflow bnds i
--   </pre>
--   
--   <pre>
--   inRange bnds i /= isEmpty     bnds
--   inRange bnds i /= isOverflow  bnds i
--   inRange bnds i /= isUnderflow bnds i
--   inRange bnds i == (safeElem bnds i == i)
--   </pre>
--   
--   Note:
--   
--   <ul>
--   <li><a>E</a> is (and should remain) the one and only one index of
--   <tt>rank 0</tt>.</li>
--   <li><a>Index</a> is a generalization of <a>Enum</a>, so all <tt>rank
--   1</tt> indices must satisfy <a>Enum</a> laws.</li>
--   <li>The cardinality of the set of permissible values for indices
--   mustn't exceed 1 (cardinality of a series of natural numbers), so
--   <a>Fractional</a> types cannot be indices.</li>
--   </ul>
class (Ord i, Shape i, Shape (DimLast i), Shape (DimInit i), Shape (GIndex i)) => Index i

-- | Returns the size of range.
size :: Index i => (i, i) -> Int

-- | Returns the size of range.
size :: (Index i, Enum i) => (i, i) -> Int

-- | Returns the sizes of range dimensionwise.
sizes :: Index i => (i, i) -> [Int]

-- | Returns the sizes of range dimensionwise.
sizes :: (Index i, Index (GIndex i)) => (i, i) -> [Int]

-- | Returns the index belonging to the given range.
safeElem :: Index i => (i, i) -> i -> i

-- | Returns bounds of nonempty range (swaps bounds in each empty
--   subshape).
ordBounds :: Index i => (i, i) -> (i, i)

-- | Returns size of biggest range, that may be represented by this type.
defLimit :: Index i => i -> Integer

-- | Returns size of biggest range, that may be represented by this type.
defLimit :: (Index i, Integral i, Bounded i) => i -> Integer

-- | Returns default range by size.
defaultBounds :: Index i => Int -> (i, i)

-- | Returns index by offset in default range.
unsafeIndex :: Index i => Int -> i

-- | Returns index by offset in default range.
unsafeIndex :: (Index i, Enum i) => Int -> i

-- | Checks if the bounds is empty.
isEmpty :: Index i => (i, i) -> Bool

-- | Checks the index status in bounds.
inBounds :: Index i => (i, i) -> i -> InBounds

-- | Checks if the index is overflow.
isOverflow :: Index i => (i, i) -> i -> Bool

-- | Checks if the index is underflow.
isUnderflow :: Index i => (i, i) -> i -> Bool

-- | Checks if the index is in <a>range</a>.
inRange :: Index i => (i, i) -> i -> Bool

-- | Returns previous index in <a>range</a>.
prev :: Index i => (i, i) -> i -> i

-- | Returns previous index in <a>range</a>.
prev :: (Index i, Enum i) => (i, i) -> i -> i

-- | Returns next index in range.
next :: (Index i, Enum i) => (i, i) -> i -> i

-- | Returns next index in range.
next :: Index i => (i, i) -> i -> i

-- | Returns <a>offset</a> (indent) of <a>index</a> in <a>range</a>.
offset :: Index i => (i, i) -> i -> Int

-- | Returns <a>offset</a> (indent) of <a>index</a> in <a>range</a>.
offset :: (Index i, Enum i) => (i, i) -> i -> Int

-- | Returns <a>index</a> by this <a>offset</a> (indent) in <a>range</a>.
index :: Index i => (i, i) -> Int -> i

-- | Returns <a>index</a> by this <a>offset</a> (indent) in <a>range</a>.
index :: (Index i, Enum i) => (i, i) -> Int -> i

-- | Returns the ordered list of indices in this range.
range :: Index i => (i, i) -> [i]

-- | Returns the ordered list of indices in this range.
range :: (Index i, Enum i) => (i, i) -> [i]

-- | <tt>subshape bnds ij</tt> returns subshape of <tt>bnds</tt>.
--   
--   Checks if <tt>ij</tt> in <tt>bnds</tt> subshape, may <a>throw</a>
--   <a>IndexException</a>.
subshape :: (Index i, Sub i j, Index (i :|: j)) => (i, i) -> (i :|: j) -> (j, j)
slice :: (Index i, Sub i j, ij ~ (i :|: j), Index j) => (i, i) -> ij -> ((ij, ij), (j, j))

-- | InBounds - service type that specifies index and bounds status.
data InBounds

-- | Empty range
ER :: InBounds

-- | Underflow range
UR :: InBounds

-- | Index in range
IN :: InBounds

-- | Overflow range
OR :: InBounds

-- | Default <a>offset</a> for <a>Integral</a> types.
offsetIntegral :: (Index i, Integral i) => (i, i) -> i -> Int

-- | Default <a>defaultBounds</a> for unsigned types.
defaultBoundsUnsign :: (Index i, Bounded i) => Int -> (i, i)
instance GHC.Enum.Enum SDP.Index.InBounds
instance GHC.Read.Read SDP.Index.InBounds
instance GHC.Show.Show SDP.Index.InBounds
instance GHC.Classes.Eq SDP.Index.InBounds
instance (SDP.Index.Index i, SDP.Finite.E ~ (i SDP.Index.:|: i)) => SDP.Index.Sub i i
instance (ij ~ (i SDP.Index.:|: j), SDP.Shape.DimInit ij ~ (SDP.Shape.DimInit i SDP.Index.:|: j), SDP.Shape.DimLast ij ~ SDP.Shape.DimLast i, SDP.Index.Index i, SDP.Index.Index j, SDP.Index.Index ij, SDP.Index.Sub (SDP.Shape.DimInit i) j) => SDP.Index.Sub i j
instance SDP.Index.Index i => SDP.Estimate.Estimate (i, i)
instance SDP.Index.Index i => SDP.Nullable.Nullable (i, i)
instance SDP.Index.Index SDP.Finite.E
instance SDP.Index.Index ()
instance SDP.Index.Index GHC.Types.Char
instance SDP.Index.Index GHC.Integer.Type.Integer
instance SDP.Index.Index GHC.Types.Int
instance SDP.Index.Index GHC.Int.Int8
instance SDP.Index.Index GHC.Int.Int16
instance SDP.Index.Index GHC.Int.Int32
instance SDP.Index.Index GHC.Int.Int64
instance SDP.Index.Index GHC.Types.Word
instance SDP.Index.Index GHC.Word.Word8
instance SDP.Index.Index GHC.Word.Word16
instance SDP.Index.Index GHC.Word.Word32
instance SDP.Index.Index GHC.Word.Word64
instance SDP.Index.Index Foreign.C.Types.CChar
instance SDP.Index.Index Foreign.C.Types.CSChar
instance SDP.Index.Index Foreign.C.Types.CWchar
instance SDP.Index.Index Foreign.C.Types.CShort
instance SDP.Index.Index Foreign.C.Types.CInt
instance SDP.Index.Index Foreign.C.Types.CLong
instance SDP.Index.Index Foreign.C.Types.CLLong
instance SDP.Index.Index Foreign.C.Types.CIntPtr
instance SDP.Index.Index Foreign.C.Types.CIntMax
instance SDP.Index.Index Foreign.C.Types.CPtrdiff
instance SDP.Index.Index Foreign.C.Types.CSigAtomic
instance SDP.Index.Index Foreign.C.Types.CSize
instance SDP.Index.Index Foreign.C.Types.CBool
instance SDP.Index.Index Foreign.C.Types.CUChar
instance SDP.Index.Index Foreign.C.Types.CUShort
instance SDP.Index.Index Foreign.C.Types.CUInt
instance SDP.Index.Index Foreign.C.Types.CULong
instance SDP.Index.Index Foreign.C.Types.CULLong
instance SDP.Index.Index Foreign.C.Types.CUIntPtr
instance SDP.Index.Index Foreign.C.Types.CUIntMax
instance SDP.Index.Index i => SDP.Index.Index (SDP.Finite.E SDP.Finite.:& i)
instance (SDP.Index.Index i, GHC.Enum.Enum i, GHC.Enum.Bounded i, SDP.Index.Index (i' SDP.Finite.:& i)) => SDP.Index.Index ((i' SDP.Finite.:& i) SDP.Finite.:& i)
instance (GHC.Classes.Ord i, SDP.Index.Index i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Index.Index (SDP.Tuple.T2 i)
instance (GHC.Classes.Ord i, SDP.Index.Index i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Index.Index (SDP.Tuple.T3 i)
instance (GHC.Classes.Ord i, SDP.Index.Index i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Index.Index (SDP.Tuple.T4 i)
instance (GHC.Classes.Ord i, SDP.Index.Index i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Index.Index (SDP.Tuple.T5 i)
instance (GHC.Classes.Ord i, SDP.Index.Index i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Index.Index (SDP.Tuple.T6 i)
instance (GHC.Classes.Ord i, SDP.Index.Index i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Index.Index (SDP.Tuple.T7 i)
instance (GHC.Classes.Ord i, SDP.Index.Index i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Index.Index (SDP.Tuple.T8 i)
instance (GHC.Classes.Ord i, SDP.Index.Index i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Index.Index (SDP.Tuple.T9 i)
instance (GHC.Classes.Ord i, SDP.Index.Index i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Index.Index (SDP.Tuple.T10 i)
instance (GHC.Classes.Ord i, SDP.Index.Index i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Index.Index (SDP.Tuple.T11 i)
instance (GHC.Classes.Ord i, SDP.Index.Index i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Index.Index (SDP.Tuple.T12 i)
instance (GHC.Classes.Ord i, SDP.Index.Index i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Index.Index (SDP.Tuple.T13 i)
instance (GHC.Classes.Ord i, SDP.Index.Index i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Index.Index (SDP.Tuple.T14 i)
instance (GHC.Classes.Ord i, SDP.Index.Index i, GHC.Enum.Enum i, GHC.Enum.Bounded i) => SDP.Index.Index (SDP.Tuple.T15 i)


-- | <a>SDP.Unboxed</a> provide service class <a>Unboxed</a>, that needed
--   for <a>SDP.Prim.SBytes</a>-based structures.
module SDP.Unboxed

-- | <a>Unboxed</a> is a layer between untyped raw data and parameterized
--   unboxed data structures. Also it prevents direct interaction with
--   primitives.
class (Eq e) => Unboxed e

-- | <tt>sizeof e n</tt> returns the length (in bytes) of primitive, where
--   <tt>n</tt> - count of elements, <tt>e</tt> - type parameter.
sizeof :: Unboxed e => e -> Int -> Int

-- | <a>sizeof#</a> is unboxed <a>sizeof</a>.
sizeof# :: Unboxed e => e -> Int# -> Int#

-- | Unsafe <a>ByteArray#</a> reader with overloaded result type.
(!#) :: Unboxed e => ByteArray# -> Int# -> e

-- | Unsafe <a>MutableByteArray#</a> reader with overloaded result type.
(!>#) :: Unboxed e => MutableByteArray# s -> Int# -> State# s -> (# State# s, e #)

-- | Unsafe <a>MutableByteArray#</a> writer.
writeByteArray# :: Unboxed e => MutableByteArray# s -> Int# -> e -> State# s -> State# s

-- | Procedure for filling the array with the default value (like calloc).
fillByteArray# :: Unboxed e => MutableByteArray# s -> Int# -> e -> State# s -> State# s

-- | <a>newUnboxed</a> creates new <a>MutableByteArray#</a> of given count
--   of elements. First argument used as type variable.
newUnboxed :: Unboxed e => e -> Int# -> State# s -> (# State# s, MutableByteArray# s #)

-- | <a>newUnboxed'</a> is version of <a>newUnboxed</a>, that use first
--   argument as initial value. May fail when trying to write <a>error</a>
--   or <a>undefined</a>.
newUnboxed' :: Unboxed e => e -> Int# -> State# s -> (# State# s, MutableByteArray# s #)

-- | <tt><a>copyUnboxed#</a> e bytes# o1# mbytes# o2# n#</tt> unsafely
--   writes elements from <tt>bytes#</tt> to <tt>mbytes#</tt>, where o1#
--   and o2# - offsets (element count), <tt>n#</tt> - count of elements to
--   copy.
copyUnboxed# :: Unboxed e => e -> ByteArray# -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s

-- | <tt><a>copyUnboxedM#</a> e msrc# o1# mbytes# o2# n#</tt> unsafely
--   writes elements from <tt>msrc#</tt> to <tt>mbytes#</tt>, where o1# and
--   o2# - offsets (element count), <tt>n#</tt> - count of elements to
--   copy.
copyUnboxedM# :: Unboxed e => e -> MutableByteArray# s -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s

-- | <tt><a>hashUnboxedWith</a> e len bytes# salt</tt> returns
--   <tt>bytes#</tt> <tt>FNV-1</tt> hash, where <tt>off#</tt> and
--   <tt>len#</tt> is offset and length (in elements).
--   
--   Note: the standard definition of this function is written in Haskell
--   using low-level functions, but this implementation mayn't be as
--   efficient as the foreign procedure in the <tt>hashable</tt> package.
hashUnboxedWith :: Unboxed e => e -> Int# -> Int# -> ByteArray# -> Int# -> Int#

-- | <tt>cloneUnboxed# e o# c#</tt> creates byte array with <tt>c#</tt>
--   elements of same type as <tt>e</tt> beginning from <tt>o#</tt>
--   elements.
cloneUnboxed# :: Unboxed e => e -> ByteArray# -> Int# -> Int# -> ByteArray#

-- | <tt>(* -&gt; *)</tt> kind proxy version if <a>cloneUnboxed#</a>.
cloneUnboxed1# :: Unboxed e => proxy e -> ByteArray# -> Int# -> Int# -> ByteArray#

-- | <a>psizeof</a> is <tt>Proxy <a>sizeof</a></tt>.
psizeof :: Unboxed e => proxy e -> Int -> Int

-- | <tt>(* -&gt; *)</tt> kind proxy version of <a>newUnboxed</a>.
pnewUnboxed :: Unboxed e => proxy e -> Int# -> State# s -> (# State# s, MutableByteArray# s #)

-- | <tt>(* -&gt; *)</tt> kind proxy version if <a>copyUnboxed#</a>.
pcopyUnboxed :: Unboxed e => proxy e -> ByteArray# -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s

-- | Proxy version if <a>copyUnboxedM#</a>.
pcopyUnboxedM :: Unboxed e => proxy e -> MutableByteArray# s -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s

-- | Returns <a>undefined</a> of suitable type.
fromProxy :: proxy e -> e

-- | <tt>(* -&gt; * -&gt; *)</tt> kind proxy version of <a>newUnboxed</a>.
pnewUnboxed1 :: Unboxed e => m (proxy e) -> Int# -> State# s -> (# State# s, MutableByteArray# s #)

-- | <tt>(* -&gt; * -&gt; *)</tt> kind proxy version if
--   <a>copyUnboxed#</a>.
pcopyUnboxed1 :: Unboxed e => m (proxy e) -> ByteArray# -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s

-- | <tt>(* -&gt; * -&gt; *)</tt> kind proxy version if
--   <a>copyUnboxedM#</a>.
pcopyUnboxedM1 :: Unboxed e => m (proxy e) -> MutableByteArray# s -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s

-- | Returns <a>undefined</a> of suitable type.
fromProxy1 :: m (proxy e) -> e
instance SDP.Unboxed.Unboxed GHC.Types.Int
instance SDP.Unboxed.Unboxed GHC.Int.Int8
instance SDP.Unboxed.Unboxed GHC.Int.Int16
instance SDP.Unboxed.Unboxed GHC.Int.Int32
instance SDP.Unboxed.Unboxed GHC.Int.Int64
instance SDP.Unboxed.Unboxed GHC.Types.Word
instance SDP.Unboxed.Unboxed GHC.Word.Word8
instance SDP.Unboxed.Unboxed GHC.Word.Word16
instance SDP.Unboxed.Unboxed GHC.Word.Word32
instance SDP.Unboxed.Unboxed GHC.Word.Word64
instance SDP.Unboxed.Unboxed (GHC.Ptr.Ptr a)
instance SDP.Unboxed.Unboxed (GHC.Ptr.FunPtr a)
instance SDP.Unboxed.Unboxed (GHC.Stable.StablePtr a)
instance SDP.Unboxed.Unboxed Foreign.C.Types.CChar
instance SDP.Unboxed.Unboxed Foreign.C.Types.CSChar
instance SDP.Unboxed.Unboxed Foreign.C.Types.CWchar
instance SDP.Unboxed.Unboxed Foreign.C.Types.CShort
instance SDP.Unboxed.Unboxed Foreign.C.Types.CUShort
instance SDP.Unboxed.Unboxed Foreign.C.Types.CInt
instance SDP.Unboxed.Unboxed Foreign.C.Types.CUInt
instance SDP.Unboxed.Unboxed Foreign.C.Types.CLong
instance SDP.Unboxed.Unboxed Foreign.C.Types.CULong
instance SDP.Unboxed.Unboxed Foreign.C.Types.CLLong
instance SDP.Unboxed.Unboxed Foreign.C.Types.CULLong
instance SDP.Unboxed.Unboxed Foreign.C.Types.CIntPtr
instance SDP.Unboxed.Unboxed Foreign.C.Types.CUIntPtr
instance SDP.Unboxed.Unboxed Foreign.C.Types.CIntMax
instance SDP.Unboxed.Unboxed Foreign.C.Types.CUIntMax
instance SDP.Unboxed.Unboxed Foreign.C.Types.CPtrdiff
instance SDP.Unboxed.Unboxed Foreign.C.Types.CTime
instance SDP.Unboxed.Unboxed Foreign.C.Types.CClock
instance SDP.Unboxed.Unboxed Foreign.C.Types.CUSeconds
instance SDP.Unboxed.Unboxed Foreign.C.Types.CSUSeconds
instance SDP.Unboxed.Unboxed Foreign.C.Types.CSize
instance SDP.Unboxed.Unboxed Foreign.C.Types.CBool
instance SDP.Unboxed.Unboxed Foreign.C.Types.CFloat
instance SDP.Unboxed.Unboxed Foreign.C.Types.CDouble
instance SDP.Unboxed.Unboxed Foreign.C.Types.CSigAtomic
instance SDP.Unboxed.Unboxed ()
instance SDP.Unboxed.Unboxed GHC.Types.Bool
instance SDP.Unboxed.Unboxed GHC.Types.Char
instance SDP.Unboxed.Unboxed GHC.Types.Float
instance SDP.Unboxed.Unboxed GHC.Types.Double
instance (SDP.Unboxed.Unboxed a, GHC.Real.Integral a) => SDP.Unboxed.Unboxed (GHC.Real.Ratio a)
instance (SDP.Unboxed.Unboxed a, GHC.Num.Num a) => SDP.Unboxed.Unboxed (Data.Complex.Complex a)


-- | <a>SDP.Unboxed.IntAs</a> provides additional <a>Int</a> instances for
--   <a>Unboxed</a>.
module SDP.Unboxed.IntAs

-- | Int value as 1 byte.
newtype IntAs8
IntAs8 :: Int -> IntAs8

-- | Int value as 2 bytes.
newtype IntAs16
IntAs16 :: Int -> IntAs16

-- | Int value as 4 bytes.
newtype IntAs32
IntAs32 :: Int -> IntAs32

-- | Int value as 8 bytes.
newtype IntAs64
IntAs64 :: Int -> IntAs64
instance GHC.Real.Integral SDP.Unboxed.IntAs.IntAs8
instance GHC.Real.Real SDP.Unboxed.IntAs.IntAs8
instance GHC.Num.Num SDP.Unboxed.IntAs.IntAs8
instance GHC.Enum.Bounded SDP.Unboxed.IntAs.IntAs8
instance GHC.Enum.Enum SDP.Unboxed.IntAs.IntAs8
instance GHC.Classes.Ord SDP.Unboxed.IntAs.IntAs8
instance GHC.Classes.Eq SDP.Unboxed.IntAs.IntAs8
instance GHC.Real.Integral SDP.Unboxed.IntAs.IntAs16
instance GHC.Real.Real SDP.Unboxed.IntAs.IntAs16
instance GHC.Num.Num SDP.Unboxed.IntAs.IntAs16
instance GHC.Enum.Bounded SDP.Unboxed.IntAs.IntAs16
instance GHC.Enum.Enum SDP.Unboxed.IntAs.IntAs16
instance GHC.Classes.Ord SDP.Unboxed.IntAs.IntAs16
instance GHC.Classes.Eq SDP.Unboxed.IntAs.IntAs16
instance GHC.Real.Integral SDP.Unboxed.IntAs.IntAs32
instance GHC.Real.Real SDP.Unboxed.IntAs.IntAs32
instance GHC.Num.Num SDP.Unboxed.IntAs.IntAs32
instance GHC.Enum.Bounded SDP.Unboxed.IntAs.IntAs32
instance GHC.Enum.Enum SDP.Unboxed.IntAs.IntAs32
instance GHC.Classes.Ord SDP.Unboxed.IntAs.IntAs32
instance GHC.Classes.Eq SDP.Unboxed.IntAs.IntAs32
instance GHC.Real.Integral SDP.Unboxed.IntAs.IntAs64
instance GHC.Real.Real SDP.Unboxed.IntAs.IntAs64
instance GHC.Num.Num SDP.Unboxed.IntAs.IntAs64
instance GHC.Enum.Bounded SDP.Unboxed.IntAs.IntAs64
instance GHC.Enum.Enum SDP.Unboxed.IntAs.IntAs64
instance GHC.Classes.Ord SDP.Unboxed.IntAs.IntAs64
instance GHC.Classes.Eq SDP.Unboxed.IntAs.IntAs64
instance SDP.Shape.Shape SDP.Unboxed.IntAs.IntAs64
instance SDP.Index.Index SDP.Unboxed.IntAs.IntAs64
instance GHC.Show.Show SDP.Unboxed.IntAs.IntAs64
instance GHC.Read.Read SDP.Unboxed.IntAs.IntAs64
instance SDP.Unboxed.Unboxed SDP.Unboxed.IntAs.IntAs64
instance Foreign.Storable.Storable SDP.Unboxed.IntAs.IntAs64
instance SDP.Shape.Shape SDP.Unboxed.IntAs.IntAs32
instance SDP.Index.Index SDP.Unboxed.IntAs.IntAs32
instance GHC.Show.Show SDP.Unboxed.IntAs.IntAs32
instance GHC.Read.Read SDP.Unboxed.IntAs.IntAs32
instance SDP.Unboxed.Unboxed SDP.Unboxed.IntAs.IntAs32
instance Foreign.Storable.Storable SDP.Unboxed.IntAs.IntAs32
instance SDP.Shape.Shape SDP.Unboxed.IntAs.IntAs16
instance SDP.Index.Index SDP.Unboxed.IntAs.IntAs16
instance GHC.Show.Show SDP.Unboxed.IntAs.IntAs16
instance GHC.Read.Read SDP.Unboxed.IntAs.IntAs16
instance SDP.Unboxed.Unboxed SDP.Unboxed.IntAs.IntAs16
instance Foreign.Storable.Storable SDP.Unboxed.IntAs.IntAs16
instance SDP.Shape.Shape SDP.Unboxed.IntAs.IntAs8
instance SDP.Index.Index SDP.Unboxed.IntAs.IntAs8
instance GHC.Show.Show SDP.Unboxed.IntAs.IntAs8
instance GHC.Read.Read SDP.Unboxed.IntAs.IntAs8
instance SDP.Unboxed.Unboxed SDP.Unboxed.IntAs.IntAs8
instance Foreign.Storable.Storable SDP.Unboxed.IntAs.IntAs8


-- | <a>SDP.Unboxed.WordAs</a> provides additional <a>Word</a> instances
--   for <a>Unboxed</a>.
module SDP.Unboxed.WordAs

-- | Word value as 1 byte.
newtype WordAs8
WordAs8 :: Word -> WordAs8

-- | Word value as 2 bytes.
newtype WordAs16
WordAs16 :: Word -> WordAs16

-- | Word value as 4 bytes.
newtype WordAs32
WordAs32 :: Word -> WordAs32

-- | Word value as 8 bytes.
newtype WordAs64
WordAs64 :: Word -> WordAs64
instance GHC.Real.Integral SDP.Unboxed.WordAs.WordAs8
instance GHC.Real.Real SDP.Unboxed.WordAs.WordAs8
instance GHC.Num.Num SDP.Unboxed.WordAs.WordAs8
instance GHC.Enum.Bounded SDP.Unboxed.WordAs.WordAs8
instance GHC.Enum.Enum SDP.Unboxed.WordAs.WordAs8
instance GHC.Classes.Ord SDP.Unboxed.WordAs.WordAs8
instance GHC.Classes.Eq SDP.Unboxed.WordAs.WordAs8
instance GHC.Real.Integral SDP.Unboxed.WordAs.WordAs16
instance GHC.Real.Real SDP.Unboxed.WordAs.WordAs16
instance GHC.Num.Num SDP.Unboxed.WordAs.WordAs16
instance GHC.Enum.Bounded SDP.Unboxed.WordAs.WordAs16
instance GHC.Enum.Enum SDP.Unboxed.WordAs.WordAs16
instance GHC.Classes.Ord SDP.Unboxed.WordAs.WordAs16
instance GHC.Classes.Eq SDP.Unboxed.WordAs.WordAs16
instance GHC.Real.Integral SDP.Unboxed.WordAs.WordAs32
instance GHC.Real.Real SDP.Unboxed.WordAs.WordAs32
instance GHC.Num.Num SDP.Unboxed.WordAs.WordAs32
instance GHC.Enum.Bounded SDP.Unboxed.WordAs.WordAs32
instance GHC.Enum.Enum SDP.Unboxed.WordAs.WordAs32
instance GHC.Classes.Ord SDP.Unboxed.WordAs.WordAs32
instance GHC.Classes.Eq SDP.Unboxed.WordAs.WordAs32
instance GHC.Real.Integral SDP.Unboxed.WordAs.WordAs64
instance GHC.Real.Real SDP.Unboxed.WordAs.WordAs64
instance GHC.Num.Num SDP.Unboxed.WordAs.WordAs64
instance GHC.Enum.Bounded SDP.Unboxed.WordAs.WordAs64
instance GHC.Enum.Enum SDP.Unboxed.WordAs.WordAs64
instance GHC.Classes.Ord SDP.Unboxed.WordAs.WordAs64
instance GHC.Classes.Eq SDP.Unboxed.WordAs.WordAs64
instance SDP.Shape.Shape SDP.Unboxed.WordAs.WordAs64
instance SDP.Index.Index SDP.Unboxed.WordAs.WordAs64
instance GHC.Show.Show SDP.Unboxed.WordAs.WordAs64
instance GHC.Read.Read SDP.Unboxed.WordAs.WordAs64
instance SDP.Unboxed.Unboxed SDP.Unboxed.WordAs.WordAs64
instance Foreign.Storable.Storable SDP.Unboxed.WordAs.WordAs64
instance SDP.Shape.Shape SDP.Unboxed.WordAs.WordAs32
instance SDP.Index.Index SDP.Unboxed.WordAs.WordAs32
instance GHC.Show.Show SDP.Unboxed.WordAs.WordAs32
instance GHC.Read.Read SDP.Unboxed.WordAs.WordAs32
instance SDP.Unboxed.Unboxed SDP.Unboxed.WordAs.WordAs32
instance Foreign.Storable.Storable SDP.Unboxed.WordAs.WordAs32
instance SDP.Shape.Shape SDP.Unboxed.WordAs.WordAs16
instance SDP.Index.Index SDP.Unboxed.WordAs.WordAs16
instance GHC.Show.Show SDP.Unboxed.WordAs.WordAs16
instance GHC.Read.Read SDP.Unboxed.WordAs.WordAs16
instance SDP.Unboxed.Unboxed SDP.Unboxed.WordAs.WordAs16
instance Foreign.Storable.Storable SDP.Unboxed.WordAs.WordAs16
instance SDP.Shape.Shape SDP.Unboxed.WordAs.WordAs8
instance SDP.Index.Index SDP.Unboxed.WordAs.WordAs8
instance GHC.Show.Show SDP.Unboxed.WordAs.WordAs8
instance GHC.Read.Read SDP.Unboxed.WordAs.WordAs8
instance SDP.Unboxed.Unboxed SDP.Unboxed.WordAs.WordAs8
instance Foreign.Storable.Storable SDP.Unboxed.WordAs.WordAs8


-- | <a>SDP.Zip</a> provides <a>Zip</a> - class of
--   'Control.Applicative.ZipList"-like structures.
module SDP.Zip

-- | Zip is generalization of ZipList applicative semantics (but without
--   pure).
class (Functor z) => Zip z

-- | ZipList-like <a>&lt;*&gt;</a>
zap :: Zip z => z (a -> b) -> z a -> z b
all2 :: Zip z => (a -> b -> Bool) -> z a -> z b -> Bool
all3 :: Zip z => (a -> b -> c -> Bool) -> z a -> z b -> z c -> Bool
all4 :: Zip z => (a -> b -> c -> d -> Bool) -> z a -> z b -> z c -> z d -> Bool
all5 :: Zip z => (a -> b -> c -> d -> e -> Bool) -> z a -> z b -> z c -> z d -> z e -> Bool
all6 :: Zip z => (a -> b -> c -> d -> e -> f -> Bool) -> z a -> z b -> z c -> z d -> z e -> z f -> Bool
any2 :: Zip z => (a -> b -> Bool) -> z a -> z b -> Bool
any3 :: Zip z => (a -> b -> c -> Bool) -> z a -> z b -> z c -> Bool
any4 :: Zip z => (a -> b -> c -> d -> Bool) -> z a -> z b -> z c -> z d -> Bool
any5 :: Zip z => (a -> b -> c -> d -> e -> Bool) -> z a -> z b -> z c -> z d -> z e -> Bool
any6 :: Zip z => (a -> b -> c -> d -> e -> f -> Bool) -> z a -> z b -> z c -> z d -> z e -> z f -> Bool
zip :: Zip z => z a -> z b -> z (a, b)
zip3 :: Zip z => z a -> z b -> z c -> z (a, b, c)
zip4 :: Zip z => z a -> z b -> z c -> z d -> z (a, b, c, d)
zip5 :: Zip z => z a -> z b -> z c -> z d -> z e -> z (a, b, c, d, e)
zip6 :: Zip z => z a -> z b -> z c -> z d -> z e -> z f -> z (a, b, c, d, e, f)
zipWith :: Zip z => (a -> b -> c) -> z a -> z b -> z c
zipWith3 :: Zip z => (a -> b -> c -> d) -> z a -> z b -> z c -> z d
zipWith4 :: Zip z => (a -> b -> c -> d -> e) -> z a -> z b -> z c -> z d -> z e
zipWith5 :: Zip z => (a -> b -> c -> d -> e -> f) -> z a -> z b -> z c -> z d -> z e -> z f
zipWith6 :: Zip z => (a -> b -> c -> d -> e -> f -> g) -> z a -> z b -> z c -> z d -> z e -> z f -> z g
instance SDP.Zip.Zip []


-- | <a>SDP.Sort</a> provides <a>Sort</a> - class of sortable immutable
--   structures.
module SDP.Sort

-- | <a>Sort</a> is class of types that can be sorted.
class Sort s e | s -> e

-- | Checks if structure is already sorted. Should always return
--   <a>True</a> for structures with less than 2 elements.
sortedBy :: Sort s e => (e -> e -> Bool) -> s -> Bool

-- | <a>sortBy</a> function is common sorting algorithm.
sortBy :: Sort s e => Compare e -> s -> s

-- | <a>sort</a> is just <tt><a>sortBy</a> <a>compare</a></tt>
sort :: (Sort s e, Ord e) => s -> s

-- | Sort by comparing the results of a given function applied to each
--   element.
sortOn :: (Sort s e, Ord o) => (e -> o) -> s -> s

-- | Checks if the structure is <a>sorted</a>.
sorted :: (Sort s e, Ord e) => s -> Bool

-- | Sort by comparing the results of a given function applied to each
--   element.
sortedOn :: (Sort s e, Ord o) => (e -> o) -> s -> Bool
instance SDP.Sort.Sort [a] a


-- | <a>SDP.Linear</a> is a module that provides several convenient
--   interfaces for working with various linear data structures.
module SDP.Linear

-- | Class of bordered data structures.
class (Index i, Estimate b) => Bordered b i | b -> i

-- | Returns the exact <a>upper</a> and <a>lower</a> bounds of given
--   structure. If the structure doesn't have explicitly defined boundaries
--   (list, for example), use the <tt><a>defaultBounds</a> .
--   <a>sizeOf</a></tt>.
bounds :: Bordered b i => b -> (i, i)

-- | Returns lower bound of structure
lower :: Bordered b i => b -> i

-- | Returns upper bound of structure
upper :: Bordered b i => b -> i

-- | Returns actual size of structure.
sizeOf :: Bordered b i => b -> Int

-- | Returns actual sizes of structure.
sizesOf :: Bordered b i => b -> [Int]

-- | Checks if an index falls within the boundaries of the structure.
indexIn :: Bordered b i => b -> i -> Bool

-- | Returns index range list.
indices :: Bordered b i => b -> [i]

-- | Returns index by offset in structure.
indexOf :: Bordered b i => b -> Int -> i

-- | Returns index offset in structure bounds.
offsetOf :: Bordered b i => b -> i -> Int

-- | Kind <tt>(* -&gt; *)</tt> <a>Bordered</a> structure.
type Bordered1 l i e = Bordered (l e) i

-- | Kind <tt>(* -&gt; * -&gt; *)</tt> <a>Bordered</a> structure.
type Bordered2 l i e = Bordered (l i e) i

-- | Class of list-like data structures.
class (Nullable l) => Linear l e | l -> e

-- | Separates line to <a>head</a> and <a>tail</a>, deconstructor for
--   <a>:&gt;</a> pattern.
uncons :: Linear l e => l -> (e, l)

-- | Same as <tt><a>isNull</a> <a>?-</a> <a>uncons</a></tt>
uncons' :: Linear l e => l -> Maybe (e, l)

-- | Prepends element to line, constructor for <a>:&gt;</a> pattern.
toHead :: Linear l e => e -> l -> l

-- | Returns first element of line, may fail.
head :: Linear l e => l -> e

-- | Returns line except first, may fail.
tail :: Linear l e => l -> l

-- | Separates line to <a>init</a> and <a>last</a>, deconstructor for
--   <a>:&lt;</a> pattern.
unsnoc :: Linear l e => l -> (l, e)

-- | Same as <tt><a>isNull</a> <a>?-</a> <a>unsnoc</a></tt>
unsnoc' :: Linear l e => l -> Maybe (l, e)

-- | Appends element to line, constructor for <a>:&lt;</a> pattern.
toLast :: Linear l e => l -> e -> l

-- | Returns line except <a>last</a> element, may fail.
init :: Linear l e => l -> l

-- | Returns last element, may fail.
last :: Linear l e => l -> e

-- | Just singleton.
single :: Linear l e => e -> l

-- | Concatenation of two lines.
(++) :: Linear l e => l -> l -> l

-- | <tt>replicate n e</tt> returns a line of <tt>n</tt> repetitions of the
--   element <tt>e</tt>.
replicate :: Linear l e => Int -> e -> l

-- | Creates line from list.
fromList :: Linear l e => [e] -> l

-- | Create finite line from (possibly infinite) list.
fromListN :: Linear l e => Int -> [e] -> l

-- | Right to left view of line.
listR :: Linear l e => l -> [e]

-- | Left to right view of line, same to <a>toList</a>.
listL :: Linear l e => l -> [e]

-- | Generalized <a>fromList</a>.
fromFoldable :: (Linear l e, Foldable f) => f e -> l

-- | Returns the element of a sequence by offset, may be completely unsafe.
--   This is an optimistic read function and shouldn't perform checks for
--   efficiency reasons.
--   
--   If you need safety, use (!) or (!?). The generalization of this
--   function by index type (.!).
--   
--   <pre>
--   es !^ i = listL es !! i
--   </pre>
(!^) :: Linear l e => l -> Int -> e

-- | <tt>write es n e</tt> writes value <tt>e</tt> in position <tt>n</tt>
--   (offset), returns new structure. If <tt>n</tt> is out of range,
--   returns equal structure (<tt>es</tt> or copy).
write :: Linear l e => l -> Int -> e -> l

-- | Generalized concat.
concat :: (Linear l e, Foldable f) => f l -> l

-- | Generalized concatMap.
concatMap :: (Linear l e, Foldable f) => (a -> l) -> f a -> l

-- | Generalized intersperse.
intersperse :: Linear l e => e -> l -> l

-- | Generalized filter.
filter :: Linear l e => (e -> Bool) -> l -> l

-- | Inverted filter.
except :: Linear l e => (e -> Bool) -> l -> l

-- | Generalization of partition.
partition :: Linear l e => (e -> Bool) -> l -> (l, l)

-- | Generalization of partition, that select sublines by predicates.
partitions :: (Linear l e, Foldable f) => f (e -> Bool) -> l -> [l]

-- | <tt>select f es</tt> is selective map of <tt>es</tt> elements to new
--   list.
select :: Linear l e => (e -> Maybe a) -> l -> [a]

-- | <tt>select' f es</tt> is selective map of <tt>es</tt> elements to new
--   line.
select' :: (Linear l e, t e ~ l, Linear1 t a) => (e -> Maybe a) -> l -> t a

-- | <tt>extract f es</tt> returns a selective map of <tt>es</tt> elements
--   to new list and the remaining elements of the line.
extract :: Linear l e => (e -> Maybe a) -> l -> ([a], l)

-- | <tt>extract' f es</tt> returns a selective map of <tt>es</tt> elements
--   to new line and the remaining elements of the line.
extract' :: (Linear l e, t e ~ l, Linear1 t a) => (e -> Maybe a) -> l -> (t a, l)

-- | <tt>selects fs es</tt> sequentially applies the functions from
--   <tt>fs</tt> to the remainder of <tt>es</tt>, returns a list of
--   selections and the remainder of the last selection.
selects :: (Linear l e, Foldable f) => f (e -> Maybe a) -> l -> ([[a]], l)

-- | <tt>selects' fs es</tt> sequentially applies the functions from
--   <tt>fs</tt> to the remainder of <tt>es</tt>, returns a line of
--   selections and the remainder of the last selection.
selects' :: (Linear l e, Foldable f, t e ~ l, Linear1 t a) => f (e -> Maybe a) -> l -> ([t a], l)

-- | The <tt>isSubseqOf xs ys</tt> checks if all the elements of the
--   <tt>xs</tt> occur, in order, in the <tt>ys</tt>. The elements don't
--   have to occur consecutively.
isSubseqOf :: (Linear l e, Eq e) => l -> l -> Bool

-- | Generalized reverse.
reverse :: Linear l e => l -> l

-- | Create new line, equal to given.
force :: Linear l e => l -> l

-- | Generalized subsequences.
subsequences :: Linear l e => l -> [l]

-- | <tt>iterate n f x</tt> returns sequence of <tt>n</tt> applications of
--   <tt>f</tt> to <tt>x</tt>.
--   
--   Note that <tt>iterate</tt> returns finite sequence, instead
--   <a>Prelude</a> prototype.
iterate :: Linear l e => Int -> (e -> e) -> e -> l

-- | Same as <tt>nubBy (<a>==</a>)</tt>.
nub :: (Linear l e, Eq e) => l -> l

-- | Generalization of nubBy.
nubBy :: Linear l e => Equal e -> l -> l

-- | <a>ofoldr</a> is right fold with offset.
ofoldr :: Linear l e => (Int -> e -> b -> b) -> b -> l -> b

-- | <a>ofoldl</a> is left fold with offset.
ofoldl :: Linear l e => (Int -> b -> e -> b) -> b -> l -> b

-- | <a>ofoldr'</a> is strict version of <a>ofoldr</a>.
ofoldr' :: Linear l e => (Int -> e -> b -> b) -> b -> l -> b

-- | <a>ofoldl'</a> is strict version of <a>ofoldl</a>.
ofoldl' :: Linear l e => (Int -> b -> e -> b) -> b -> l -> b

-- | <a>o_foldr</a> is just <a>foldr</a> in <a>Linear</a> context.
o_foldr :: Linear l e => (e -> b -> b) -> b -> l -> b

-- | <a>o_foldl</a> is just <a>foldl</a> in <a>Linear</a> context.
o_foldl :: Linear l e => (b -> e -> b) -> b -> l -> b

-- | <a>o_foldr'</a> is just <a>foldr'</a> in <a>Linear</a> context.
o_foldr' :: Linear l e => (e -> b -> b) -> b -> l -> b

-- | <a>o_foldl'</a> is just <a>foldl'</a> in <a>Linear</a> context.
o_foldl' :: Linear l e => (b -> e -> b) -> b -> l -> b
infix 8 `filter`
infixr 5 ++
infix 8 `except`
infixl 9 !^

-- | Kind <tt>(* -&gt; *)</tt> <a>Linear</a> structure.
type Linear1 l e = Linear (l e) e

-- | Split - class of splittable data structures.
class (Linear s e) => Split s e | s -> e

-- | <tt>take n es</tt> takes first <tt>n</tt> elements of <tt>es</tt>.
take :: Split s e => Int -> s -> s

-- | <tt>take n es</tt> takes first <tt>n</tt> elements of <tt>es</tt>.
take :: (Split s e, Bordered s i) => Int -> s -> s

-- | <tt>drop n es</tt> drops first <tt>n</tt> elements of <tt>es</tt>.
drop :: Split s e => Int -> s -> s

-- | <tt>drop n es</tt> drops first <tt>n</tt> elements of <tt>es</tt>.
drop :: (Split s e, Bordered s i) => Int -> s -> s

-- | <tt>keep n es</tt> takes last <tt>n</tt> elements of <tt>es</tt>.
keep :: Split s e => Int -> s -> s

-- | <tt>keep n es</tt> takes last <tt>n</tt> elements of <tt>es</tt>.
keep :: (Split s e, Bordered s i) => Int -> s -> s

-- | <tt>sans n es</tt> drops last <tt>n</tt> elements of <tt>es</tt>.
sans :: Split s e => Int -> s -> s

-- | <tt>sans n es</tt> drops last <tt>n</tt> elements of <tt>es</tt>.
sans :: (Split s e, Bordered s i) => Int -> s -> s

-- | <tt>save n es</tt> takes first <tt>n</tt> elements of <tt>es</tt> if
--   <tt>n &gt; 0</tt> and last <tt>-n</tt> elements otherwise.
save :: Split s e => Int -> s -> s

-- | <tt>skip n es</tt> drops first <tt>n</tt> elements of <tt>es</tt> if
--   <tt>n &gt; 0</tt> and last <tt>-n</tt> elements otherwise.
skip :: Split s e => Int -> s -> s

-- | <tt>split n es</tt> is same to <tt>(take n es, drop n es)</tt>.
split :: Split s e => Int -> s -> (s, s)

-- | <tt>divide n es</tt> is same to <tt>(sans n es, keep n es)</tt>.
divide :: Split s e => Int -> s -> (s, s)

-- | Splits line into sequences of given sizes (left to right).
--   
--   <pre>
--   splits [5, 3, 12] ['a'..'z'] = ["abcde","fgh","ijklmnopqrst","uvwxyz"]
--   </pre>
splits :: (Split s e, Foldable f) => f Int -> s -> [s]

-- | Splits line into sequences of given sizes (right to left).
--   
--   <pre>
--   divides [5,3,12] ['a'..'z'] == ["abcdef","ghijk","lmn","opqrstuvwxyz"]
--   </pre>
divides :: (Split s e, Foldable f) => f Int -> s -> [s]

-- | Splits structures into parts by given offsets.
--   
--   <pre>
--   parts [0,5,6,12,26] ['a'..'z'] = ["","abcde","f","ghijkl","mnopqrstuvwxyz",""]
--   -- if previous offset is equal or greater, subline is empty and next
--   begins from previous:
--   parts [0, 5, 4, 12, 26] ['a' .. 'z'] = ["","abcde","","fghijklm","nopqrstuvwxyz",""]
--   </pre>
parts :: (Split s e, Foldable f) => f Int -> s -> [s]

-- | Splits structures into chunks of size <tt>n</tt> and the rest.
--   
--   <pre>
--   chunks x [] = [] -- forall x
--   chunks 0 es = [] -- forall es
--   </pre>
--   
--   <pre>
--   chunks 3 [1 .. 10] == [[1,2,3],[4,5,6],[7,8,9],[10]]
--   </pre>
chunks :: Split s e => Int -> s -> [s]

-- | Split line by first (left) separation element. If there is no such
--   element, <tt>splitBy es = (es, Z)</tt>.
--   
--   <pre>
--   splitBy (== '.') "foo" == ("foo","")
--   splitBy (== '.') "foo." == ("foo","")
--   splitBy (== '.') ".foo" == ("","foo")
--   splitBy (== '.') "foo.bar" == ("foo","bar")
--   splitBy (== '.') "foo.bar.baz" == ("foo","bar.baz")
--   </pre>
splitBy :: Split s e => (e -> Bool) -> s -> (s, s)

-- | Split line by last (right) separation element. If there is no such
--   element, <tt>divide es = (Z, es)</tt>.
--   
--   <pre>
--   divideBy (== '.') "foo" == ("","foo")
--   divideBy (== '.') ".foo" == ("","foo")
--   divideBy (== '.') "foo." == ("foo","")
--   divideBy (== '.') "foo.bar" == ("foo","bar")
--   divideBy (== '.') "foo.bar.baz" == ("foo.bar","baz")
--   </pre>
divideBy :: Split s e => (e -> Bool) -> s -> (s, s)

-- | Splits line by separation elements.
splitsBy :: Split s e => (e -> Bool) -> s -> [s]

-- | <tt>splitsOn sub line</tt> splits <tt>line</tt> by <tt>sub</tt>.
--   
--   <pre>
--   splitsOn "fo" "foobar bazfoobar1" == ["","obar baz","obar1"]
--   </pre>
splitsOn :: (Split s e, Eq e, Bordered s i) => s -> s -> [s]

-- | <tt>splitsOn sub line</tt> splits <tt>line</tt> by <tt>sub</tt>.
--   
--   <pre>
--   splitsOn "fo" "foobar bazfoobar1" == ["","obar baz","obar1"]
--   </pre>
splitsOn :: (Split s e, Eq e) => s -> s -> [s]

-- | <tt>replaceBy sub new line</tt> replace every non-overlapping
--   occurrence of <tt>sub</tt> in <tt>line</tt> with <tt>new</tt>.
--   
--   <pre>
--   replaceBy "foo" "bar" "foobafoorbaz" == "barbabarrbaz"
--   </pre>
replaceBy :: (Split s e, Eq e) => s -> s -> s -> s

-- | Removes every non-overlapping occurrence of <tt>sub</tt> with
--   <a>Z</a>.
--   
--   <pre>
--   removeAll = concat ... splitsOn
--   (`replaceBy` Z) = removeAll
--   </pre>
removeAll :: (Split s e, Eq e) => s -> s -> s

-- | <tt>combo f es</tt> returns the length of the <tt>es</tt> subsequence
--   (left to tight) whose elements are in order <tt>f</tt>.
--   
--   <pre>
--   combo (&lt;) [] == 0
--   combo (&lt;) [1] == 1
--   combo (&lt;) [7, 4, 12] == 1
--   combo (&lt;) [1, 7, 3, 12] == 2
--   </pre>
combo :: Split s e => Equal e -> s -> Int

-- | <tt>justifyL n e es</tt> appends <tt>e</tt> elements if the
--   <tt>es</tt> is shorter than <tt>n</tt>, takes <tt>n</tt> elements if
--   longer.
justifyL :: Split s e => Int -> e -> s -> s

-- | <tt>justifyR n e es</tt> prepends <tt>e</tt> elements if the
--   <tt>es</tt> is shorter than <tt>n</tt>, takes <tt>n</tt> elements if
--   longer.
justifyR :: Split s e => Int -> e -> s -> s

-- | <tt>each n es</tt> returns each nth element of structure. If <tt>n ==
--   1</tt>, returns <tt>es</tt>. If <tt>n &lt; 1</tt>, returns <a>Z</a>.
each :: Split s e => Int -> s -> s

-- | <tt>eachFrom o n es</tt> returns each nth element of structure,
--   beginning from o.
--   
--   <pre>
--   eachFrom o n = each n . drop o
--   </pre>
--   
--   <pre>
--   eachFrom 0 2 [1 .. 20] == [2, 4 .. 20]
--   eachFrom 1 2 [1 .. 20] == [3, 5 .. 19]
--   </pre>
eachFrom :: Split s e => Int -> Int -> s -> s

-- | isPrefixOf checks whether the first line is the beginning of the
--   second
isPrefixOf :: (Split s e, Eq e) => s -> s -> Bool

-- | isSuffixOf checks whether the first line is the ending of the second
isSuffixOf :: (Split s e, Eq e) => s -> s -> Bool

-- | isInfixOf checks whether the first line is the substring of the second
isInfixOf :: (Split s e, Eq e) => s -> s -> Bool

-- | prefix gives length of init, satisfying preducate.
prefix :: Split s e => (e -> Bool) -> s -> Int

-- | suffix gives length of tail, satisfying predicate.
suffix :: Split s e => (e -> Bool) -> s -> Int

-- | <tt>infixes inf es</tt> returns a list of <tt>inf</tt> positions in
--   <tt>es</tt>, without intersections.
--   
--   <pre>
--   "" `infixes` es = []
--   "abba" `infixes` "baababba" == [4]
--   "abab" `infixes` "baababab" == [2]
--   "aaaa" `infixes` "aaaaaaaa" == [0, 4]
--   </pre>
infixes :: (Split s e, Eq e) => s -> s -> [Int]

-- | <tt>dropSide f = dropWhile f . dropEnd f</tt>.
dropSide :: Split s e => (e -> Bool) -> s -> s

-- | Takes the longest init by predicate.
takeWhile :: Split s e => (e -> Bool) -> s -> s

-- | Drops the longest init by predicate.
dropWhile :: Split s e => (e -> Bool) -> s -> s

-- | Takes the longest suffix by predicate.
takeEnd :: Split s e => (e -> Bool) -> s -> s

-- | Drops the longest prefix by predicate.
dropEnd :: Split s e => (e -> Bool) -> s -> s

-- | Left-side span.
spanl :: Split s e => (e -> Bool) -> s -> (s, s)

-- | Left-side break.
breakl :: Split s e => (e -> Bool) -> s -> (s, s)

-- | Right-side span.
spanr :: Split s e => (e -> Bool) -> s -> (s, s)

-- | Right-side break.
breakr :: Split s e => (e -> Bool) -> s -> (s, s)

-- | <tt>selectWhile f es</tt> selects results of applying <tt>f</tt> to
--   <tt>es</tt> (left to right) untill first fail.
selectWhile :: Split s e => (e -> Maybe a) -> s -> [a]

-- | <tt>selectEnd f es</tt> selects results of applying <tt>f</tt> to
--   <tt>es</tt> (right to left) untill first fail.
selectEnd :: Split s e => (e -> Maybe a) -> s -> [a]

-- | <tt>extractWhile f es</tt> selects results of applying <tt>f</tt> to
--   <tt>es</tt> (left to right) untill first fail. Returns selected
--   results and rest of line.
extractWhile :: Split s e => (e -> Maybe a) -> s -> ([a], s)

-- | <tt>extractEnd f es</tt> selects results of applying <tt>f</tt> to
--   <tt>es</tt> (right to left) untill first fail. Returns rest of line
--   and selected results.
extractEnd :: Split s e => (e -> Maybe a) -> s -> (s, [a])

-- | <tt>selectWhile'</tt> is <a>selectWhile</a> version for generalized
--   structures.
selectWhile' :: (Split s e, t e ~ l, Split1 t a) => (e -> Maybe a) -> s -> t a

-- | <tt>selectEnd'</tt> is <a>selectEnd</a> version for generalized
--   structures.
selectEnd' :: (Split s e, t e ~ l, Split1 t a) => (e -> Maybe a) -> s -> t a

-- | <tt>extractWhile'</tt> is <a>extractWhile</a> version for generalized
--   structures.
extractWhile' :: (Split s e, t e ~ l, Split1 t a) => (e -> Maybe a) -> s -> (t a, s)

-- | <tt>extractEnd'</tt> is <a>extractEnd</a> version for generalized
--   structures.
extractEnd' :: (Split s e, t e ~ l, Split1 t a) => (e -> Maybe a) -> s -> (s, t a)

-- | Kind <tt>(* -&gt; *)</tt> <a>Split</a> structure.
type Split1 s e = Split (s e) e

-- | Pattern <tt>(<a>:&gt;</a>)</tt> is left-size view of line. Same as
--   <a>uncons</a> and <a>toHead</a>.
pattern (:>) :: Linear l e => e -> l -> l
infixr 5 :>

-- | Pattern <tt>(<a>:&lt;</a>)</tt> is right-size view of line. Same as
--   <a>unsnoc</a> and <a>toLast</a>.
pattern (:<) :: Linear l e => l -> e -> l
infixl 5 :<

-- | <a>Z</a> is overloaded empty (<a>lzero</a>) value constant. Pattern
--   <a>Z</a> corresponds to all empty (<a>isNull</a>) values.
pattern Z :: Nullable e => e

-- | intercalate is generalization of intercalate
intercalate :: (Foldable f, Linear1 f l, Linear l e) => l -> f l -> l

-- | <tt>tails es</tt> returns sequence of <tt>es</tt> tails.
tails :: Linear l e => l -> [l]

-- | tails is generalization of inits.
inits :: Linear l e => l -> [l]

-- | <tt>ascending es lens</tt> checks if the subsequences of <tt>es</tt>
--   of lengths <tt>lens</tt> is sorted.
ascending :: (Split s e, Sort s e, Ord e) => s -> [Int] -> Bool

-- | <tt>stripPrefix sub line</tt> strips prefix <tt>sub</tt> of
--   <tt>line</tt> (if any).
stripPrefix :: (Split s e, Bordered s i, Eq e) => s -> s -> s

-- | <tt>stripSuffix sub line</tt> strips suffix <tt>sub</tt> of
--   <tt>line</tt> (if any).
stripSuffix :: (Split s e, Bordered s i, Eq e) => s -> s -> s

-- | <tt>stripPrefix' sub line</tt> strips prefix <tt>sub</tt> of
--   <tt>line</tt> or returns <a>Nothing</a>.
stripPrefix' :: (Split s e, Bordered s i, Eq e) => s -> s -> Maybe s

-- | <tt>stripSuffix sub line</tt> strips suffix <tt>sub</tt> of
--   <tt>line</tt> or returns <a>Nothing</a>.
stripSuffix' :: (Split s e, Bordered s i, Eq e) => s -> s -> Maybe s
instance SDP.Linear.Linear [e] e
instance SDP.Linear.Split [e] e
instance SDP.Index.Index i => SDP.Linear.Bordered (i, i) i
instance SDP.Linear.Bordered [e] GHC.Types.Int


-- | <a>SDP.Shaped</a> provides advanced operations on <a>Indexed</a>
--   structures, generalized by <a>Index</a> type.
module SDP.Shaped

-- | Service class for structures with arbitrary bounds. Allows you to
--   extract subsequences corresponding to index subranges.
class Shaped s e

-- | <a>rebound</a> with <a>defaultBounds</a>.
defaultRebound :: (Shaped s e, Index i, Index j, Bordered2 s i e) => s i e -> s j e

-- | Set new bounds of same type, may shrink.
rebound :: (Shaped s e, Index i) => s i e -> (i, i) -> s i e

-- | Set new bounds, may shrink.
reshape :: (Shaped s e, Index i, Index j) => s i e -> (j, j) -> s j e

-- | <tt>es !! ij</tt> returns subshape <tt>ij</tt> of <tt>es</tt>.
(!!) :: (Shaped s e, SubIndex i j) => s i e -> (i :|: j) -> s j e

-- | Returns list of <tt>es</tt> subshapes.
slices :: (Shaped s e, SubIndex i j) => s i e -> [s j e]

-- | Unslice subshapes.
unslice :: (Shaped s e, Foldable f, SubIndex i j) => f (s j e) -> s i e


-- | <a>SDP.Set</a> provides <a>Set</a> - class for basic set operations.
module SDP.Set

-- | <a>SetWith</a> is a class of data structures, that can represent sets.
--   
--   <a>SetWith</a> doesn't provide data protection/validation before each
--   first action. All functions (except <a>setWith</a>) works correctly
--   only with correct sets. <a>SetWith</a> guarantee only that the
--   returned data is correct. So if you need maximum reliability and
--   security, use <tt>containers</tt>. But if you want simplicity,
--   openness and a lot of non-set functions without extra conversions,
--   then you are at the right place.
--   
--   Note that function of type <tt>Compare o</tt> must follow total order
--   laws (antisymmetry, transitivity and connexity). If you use the wrong
--   comparator, the result may become implementation-dependent.
class (Nullable s) => SetWith s o | s -> o

-- | Creates ordered set from linear structure.
setWith :: (SetWith s o, Linear s o) => Compare o -> s -> s

-- | Creates ordered set from linear structure.
setWith :: SetWith s o => Compare o -> s -> s

-- | Creates set from linear structure using additional function for
--   choice/merge equal elements.
groupSetWith :: (SetWith s o, Linear s o) => Compare o -> (o -> o -> o) -> s -> s

-- | Creates set from linear structure using additional function for
--   choice/merge equal elements.
groupSetWith :: SetWith s o => Compare o -> (o -> o -> o) -> s -> s

-- | Adding element to set.
insertWith :: (SetWith s o, Linear s o) => Compare o -> o -> s -> s

-- | Adding element to set.
insertWith :: SetWith s o => Compare o -> o -> s -> s

-- | Deleting element from set.
deleteWith :: (SetWith s o, Linear s o) => Compare o -> o -> s -> s

-- | Deleting element from set.
deleteWith :: SetWith s o => Compare o -> o -> s -> s

-- | Intersection of two sets.
intersectionWith :: SetWith s o => Compare o -> s -> s -> s

-- | Difference (relative complement, aka A / B) of two sets.
differenceWith :: SetWith s o => Compare o -> s -> s -> s

-- | Symmetric difference of two sets.
symdiffWith :: SetWith s o => Compare o -> s -> s -> s

-- | Union of two sets.
unionWith :: SetWith s o => Compare o -> s -> s -> s

-- | Fold by <a>intersectionWith</a>.
intersectionsWith :: (SetWith s o, Foldable f) => Compare o -> f s -> s

-- | Fold by <a>differenceWith</a>.
differencesWith :: (SetWith s o, Foldable f) => Compare o -> f s -> s

-- | Fold by <a>unionWith</a>.
unionsWith :: (SetWith s o, Foldable f) => Compare o -> f s -> s

-- | Fold by <a>symdiffWith</a>.
symdiffsWith :: (SetWith s o, Foldable f) => Compare o -> f s -> s

-- | Compares sets on intersection.
isIntersectsWith :: SetWith s o => Compare o -> s -> s -> Bool

-- | Compares sets on disjoint.
isDisjointWith :: SetWith s o => Compare o -> s -> s -> Bool

-- | Same as <a>elem</a>, but can work faster. By default, uses
--   <a>find</a>.
memberWith :: (SetWith s o, t o ~~ s, Foldable t) => Compare o -> o -> s -> Bool

-- | Same as <a>elem</a>, but can work faster. By default, uses
--   <a>find</a>.
memberWith :: SetWith s o => Compare o -> o -> s -> Bool

-- | Сhecks whether a first set is a subset of second.
isSubsetWith :: (SetWith s o, t o ~~ s, Foldable t) => Compare o -> s -> s -> Bool

-- | Сhecks whether a first set is a subset of second.
isSubsetWith :: SetWith s o => Compare o -> s -> s -> Bool

-- | Generates a list of different subsets (including empty and
--   equivalent).
subsets :: (SetWith s o, Linear s o, Ord o) => s -> [s]

-- | Generates a list of different subsets (including empty and
--   equivalent).
subsets :: (SetWith s o, Ord o) => s -> [s]

-- | <a>lookupLTWith</a> trying to find lesser element in set.
lookupLTWith :: SetWith s o => Compare o -> o -> s -> Maybe o

-- | <a>lookupGTWith</a> trying to find greater element in set.
lookupGTWith :: SetWith s o => Compare o -> o -> s -> Maybe o

-- | <a>lookupGEWith</a> trying to find greater or equal element in set.
lookupGEWith :: SetWith s o => Compare o -> o -> s -> Maybe o

-- | <a>lookupLEWith</a> trying to find lesser or equal element in set.
lookupLEWith :: SetWith s o => Compare o -> o -> s -> Maybe o

-- | Kind <tt>(* -&gt; *)</tt> <a>SetWith</a>.
type SetWith1 s o = SetWith (s o) o

-- | <a>Set</a> is a class of data structures, that can represent any sets.
--   <a>Set</a> is intended for more specific sets than ordered linear
--   structures. In particular, it may not work with an arbitrary
--   comparator, and also (unlike the early implementation) does not impose
--   restrictions on the element type.
--   
--   <a>Set</a>, as well as <a>SetWith</a>, doesn't provide data
--   protection/validation.
class (Nullable s) => Set s o | s -> o

-- | The same as <tt><a>setWith</a> <a>compare</a></tt>.
set :: (Set s o, SetWith s o, Ord o) => s -> s

-- | The same as <tt><a>setWith</a> <a>compare</a></tt>.
set :: Set s o => s -> s

-- | Same as <tt><a>insert</a> <a>compare</a></tt>.
insert :: (Set s o, SetWith s o, Ord o) => o -> s -> s

-- | Same as <tt><a>insert</a> <a>compare</a></tt>.
insert :: Set s o => o -> s -> s

-- | Same as <tt><a>deleteWith</a> <a>compare</a></tt>.
delete :: (Set s o, SetWith s o, Ord o) => o -> s -> s

-- | Same as <tt><a>deleteWith</a> <a>compare</a></tt>.
delete :: Set s o => o -> s -> s

-- | Same as <tt><a>intersectionWith</a> <a>compare</a></tt>.
(/\) :: (Set s o, SetWith s o, Ord o) => s -> s -> s

-- | Same as <tt><a>intersectionWith</a> <a>compare</a></tt>.
(/\) :: Set s o => s -> s -> s

-- | Same as <tt><a>unionWith</a> <a>compare</a></tt>.
(\/) :: (Set s o, SetWith s o, Ord o) => s -> s -> s

-- | Same as <tt><a>unionWith</a> <a>compare</a></tt>.
(\/) :: Set s o => s -> s -> s

-- | Same as <tt><a>differenceWith</a> <a>compare</a></tt>.
(\\) :: (Set s o, SetWith s o, Ord o) => s -> s -> s

-- | Same as <tt><a>differenceWith</a> <a>compare</a></tt>.
(\\) :: Set s o => s -> s -> s

-- | Same as <tt><a>symdiffWith</a> <a>compare</a></tt>.
(\^/) :: (Set s o, SetWith s o, Ord o) => s -> s -> s

-- | Same as <tt><a>symdiffWith</a> <a>compare</a></tt>.
(\^/) :: Set s o => s -> s -> s

-- | Same as <tt><a>isDisjointWith</a> <a>compare</a></tt>.
(/?\) :: (Set s o, SetWith s o, Ord o) => s -> s -> Bool

-- | Same as <tt><a>isDisjointWith</a> <a>compare</a></tt>.
(/?\) :: Set s o => s -> s -> Bool

-- | Same as <tt><a>isIntersectsWith</a> <a>compare</a></tt>.
(\?/) :: (Set s o, SetWith s o, Ord o) => s -> s -> Bool

-- | Same as <tt><a>isIntersectsWith</a> <a>compare</a></tt>.
(\?/) :: Set s o => s -> s -> Bool

-- | Same as <tt><a>isSubsetWith</a> <a>compare</a></tt>.
(\+/) :: (Set s o, SetWith s o, Ord o) => s -> s -> Bool

-- | Same as <tt><a>isSubsetWith</a> <a>compare</a></tt>.
(\+/) :: Set s o => s -> s -> Bool

-- | Same as <tt><a>intersectionsWith</a> <a>compare</a></tt>.
intersections :: (Set s o, Foldable f, SetWith s o, Ord o) => f s -> s

-- | Same as <tt><a>intersectionsWith</a> <a>compare</a></tt>.
intersections :: (Set s o, Foldable f) => f s -> s

-- | Same as <tt><a>unionsWith</a> <a>compare</a></tt>.
unions :: (Set s o, Foldable f, SetWith s o, Ord o) => f s -> s

-- | Same as <tt><a>unionsWith</a> <a>compare</a></tt>.
unions :: (Set s o, Foldable f) => f s -> s

-- | Same as <tt><a>differencesWith</a> <a>compare</a></tt>.
differences :: (Set s o, Foldable f, SetWith s o, Ord o) => f s -> s

-- | Same as <tt><a>differencesWith</a> <a>compare</a></tt>.
differences :: (Set s o, Foldable f) => f s -> s

-- | Same as <tt><a>symdiffsWith</a> compare'</tt>.
symdiffs :: (Set s o, Foldable f, SetWith s o, Ord o) => f s -> s

-- | Same as <tt><a>symdiffsWith</a> compare'</tt>.
symdiffs :: (Set s o, Foldable f) => f s -> s

-- | Same as <tt><a>memberWith</a> <a>compare</a></tt>.
member :: (Set s o, SetWith s o, Ord o) => o -> s -> Bool

-- | Same as <tt><a>memberWith</a> <a>compare</a></tt>.
member :: Set s o => o -> s -> Bool

-- | Same as <tt><a>lookupLTWith</a> <a>compare</a></tt>.
lookupLT :: (Set s o, SetWith s o, Ord o) => o -> s -> Maybe o

-- | Same as <tt><a>lookupLTWith</a> <a>compare</a></tt>.
lookupLT :: (Set s o, Ord o) => o -> s -> Maybe o

-- | Same as <tt><a>lookupGTWith</a> <a>compare</a></tt>.
lookupGT :: (Set s o, SetWith s o, Ord o) => o -> s -> Maybe o

-- | Same as <tt><a>lookupGTWith</a> <a>compare</a></tt>.
lookupGT :: (Set s o, Ord o) => o -> s -> Maybe o

-- | Same as <tt><a>lookupLEWith</a> <a>compare</a></tt>.
lookupLE :: (Set s o, SetWith s o, Ord o) => o -> s -> Maybe o

-- | Same as <tt><a>lookupLEWith</a> <a>compare</a></tt>.
lookupLE :: (Set s o, Ord o) => o -> s -> Maybe o

-- | Same as <tt><a>lookupGEWith</a> <a>compare</a></tt>.
lookupGE :: (Set s o, SetWith s o, Ord o) => o -> s -> Maybe o

-- | Same as <tt><a>lookupGEWith</a> <a>compare</a></tt>.
lookupGE :: (Set s o, Ord o) => o -> s -> Maybe o

-- | Kind <tt>(* -&gt; *)</tt> <a>Set</a>.
type Set1 s o = Set (s o) o
instance GHC.Classes.Ord o => SDP.Set.Set [o] o
instance SDP.Set.SetWith [o] o


-- | <a>SDP.Scan</a> provides <a>Scan</a> - class for overloaded scans.
--   <a>Scan</a> needed for generalization and not so useful is practice as
--   other <tt>sdp</tt> classes.
module SDP.Scan

-- | Scan is class of scans.
class (Linear s a) => Scan s a
scanl :: Scan s a => (b -> a -> b) -> b -> s -> [b]
scanl' :: Scan s a => (b -> a -> b) -> b -> s -> [b]
scanr :: Scan s a => (a -> b -> b) -> b -> s -> [b]
scanr' :: Scan s a => (a -> b -> b) -> b -> s -> [b]
scanl1 :: Scan s a => (a -> a -> a) -> s -> [a]
scanr1 :: Scan s a => (a -> a -> a) -> s -> [a]
instance SDP.Scan.Scan [a] a


-- | <a>SDP.Map</a> provides <a>Map</a> - class of immutable associative
--   arrays.
module SDP.Map

-- | <a>Map</a> is a class of dictionaries, simple associative arrays with
--   an arbitrary (implementation-dependent) key.
--   
--   In the current implementation, <a>Map</a> (since <tt>sdp-0.2</tt>) is
--   a superclass of <a>Indexed</a>. <a>Map</a> provides a set of
--   operations on associative arrays that aren't specific to <a>Linear</a>
--   data structures and aren't limited by the <a>Bordered</a> context
--   (doesn't restrict key type).
class (Nullable map) => Map map key e | map -> key, map -> e

-- | Returns list of associations <tt>(index, element)</tt>.
assocs :: (Map map key e, Bordered map key, Linear map e) => map -> [(key, e)]

-- | Returns list of associations <tt>(index, element)</tt>.
assocs :: Map map key e => map -> [(key, e)]

-- | A less specific version of "SDP.Indexed.Indexed.assoc" that creates a
--   new associative array. For <a>Linear</a> structures without gaps, it
--   may be less effective.
--   
--   <pre>
--   Z // ascs = toMap -- forall ascs
--   </pre>
toMap :: Map map key e => [(key, e)] -> map

-- | Strict version of <a>toMap</a> with default value.
--   
--   Note that the default value is set only for elements included in the
--   range of the created structure and will not be set for values outside
--   its range (when expanding, concatenating, etc.) for most structures
--   since they don't store it.
toMap' :: Map map key e => e -> [(key, e)] -> map

-- | <tt><a>insert'</a> key e map</tt> inserts <tt>e</tt> with <tt>key</tt>
--   to <tt>map</tt>. If <tt>map</tt> already contains an element with
--   <tt>key</tt>, the element will be overwritten.
--   
--   If <tt>map</tt> doesn't allow gaps, then the missing elements should
--   be filled with default values.
insert' :: (Map map key e, Bordered map key) => key -> e -> map -> map

-- | <tt><a>insert'</a> key e map</tt> inserts <tt>e</tt> with <tt>key</tt>
--   to <tt>map</tt>. If <tt>map</tt> already contains an element with
--   <tt>key</tt>, the element will be overwritten.
--   
--   If <tt>map</tt> doesn't allow gaps, then the missing elements should
--   be filled with default values.
insert' :: Map map key e => key -> e -> map -> map

-- | <a>delete'</a> removes element with given key.
--   
--   If the structure has boundaries, when removed from the beginning
--   (end), they should change accordingly. If the structure doesn't allow
--   gaps, then when removed from the middle, the actual value should be
--   replaced with the default value.
delete' :: Map map key e => key -> map -> map

-- | <a>delete'</a> removes element with given key.
--   
--   If the structure has boundaries, when removed from the beginning
--   (end), they should change accordingly. If the structure doesn't allow
--   gaps, then when removed from the middle, the actual value should be
--   replaced with the default value.
delete' :: (Map map key e, Eq key) => key -> map -> map

-- | <tt><a>member'</a> key map</tt> checks if <tt>key</tt> in
--   <tt>map</tt>.
member' :: (Map map key e, Bordered map key) => key -> map -> Bool

-- | <tt><a>member'</a> key map</tt> checks if <tt>key</tt> in
--   <tt>map</tt>.
member' :: Map map key e => key -> map -> Bool

-- | Update elements of immutable structure (by copying).
(//) :: Map map key e => map -> [(key, e)] -> map

-- | <tt>(<a>.!</a>)</tt> is unsafe reader, can be faster
--   <tt>(<a>!</a>)</tt> by skipping checks.
(.!) :: Map map key e => map -> key -> e

-- | <tt>(<a>!</a>)</tt> is well-safe reader, may <a>throw</a>
--   <a>IndexException</a>.
(!) :: Map map key e => map -> key -> e

-- | <tt>(<a>!</a>)</tt> is well-safe reader, may <a>throw</a>
--   <a>IndexException</a>.
(!) :: (Map map key e, Bordered map key) => map -> key -> e

-- | <tt>(<a>!?</a>)</tt> is completely safe, but very boring function.
(!?) :: Map map key e => map -> key -> Maybe e

-- | Filter with key.
filter' :: Map map key e => (key -> e -> Bool) -> map -> map

-- | <a>union'</a> is <a>groupSetWith</a> for maps but works with real
--   groups of elements, not with consequentive equal elements.
--   
--   <a>union'</a> merges/chooses elements with equal keys from two maps.
union' :: (Map map key e, Ord key) => (e -> e -> e) -> map -> map -> map

-- | <tt><a>difference'</a> f mx my</tt> applies <tt>comb</tt> to values
--   with equal keys. If <tt>f x y</tt> (where <tt>(k1, x) &lt;- mx</tt>,
--   <tt>(k2, y) &lt;- my</tt>, <tt>k1 == k2</tt>) is <a>Nothing</a>,
--   element isn't included to result map.
--   
--   Note that <a>difference'</a> is poorer than a similar functions in
--   containers.
difference' :: (Map map key e, Ord key) => (e -> e -> Maybe e) -> map -> map -> map

-- | <tt><a>intersection'</a> f mx my</tt> combines elements of
--   <a>intersection'</a> by <tt>f</tt>: if <tt>isJust (f x y)</tt> (where
--   <tt>(k1, x) &lt;- mx, (k2, y) &lt;- my, k1 == k2</tt>), then element
--   is added to result map.
intersection' :: (Map map key e, Ord key) => (e -> e -> e) -> map -> map -> map

-- | Update function, by default uses (<a>!</a>) and may throw
--   <a>IndexException</a>.
update :: Map map key e => map -> (key -> e -> e) -> map

-- | <tt>lookupLT' k map</tt> finds pair <tt>(key, value)</tt> with
--   smallest <tt>key</tt>, where <tt>key &lt; k</tt> (if any). <tt>k</tt>
--   may not be a <tt>map</tt> element.
lookupLT' :: (Map map key e, Ord key) => key -> map -> Maybe (key, e)

-- | <tt>lookupGT' k map</tt> finds pair <tt>(key, value)</tt> with
--   greatest <tt>key</tt>, where <tt>key &gt; k</tt> (if any). <tt>k</tt>
--   may not be a <tt>map</tt> element.
lookupGT' :: (Map map key e, Ord key) => key -> map -> Maybe (key, e)

-- | <tt>lookupLE' k map</tt> finds pair <tt>(key, value)</tt> with
--   smallest <tt>key</tt>, where <tt>key &lt;= k</tt> (if any). If
--   <tt>k</tt> is a <tt>map</tt> element, returns <tt>(k, e)</tt>.
lookupLE' :: (Map map key e, Ord key) => key -> map -> Maybe (key, e)

-- | <tt>lookupGE' k map</tt> finds pair <tt>(key, value)</tt> with
--   <tt>key</tt>, where <tt>key &gt;= k</tt> (if any).
lookupGE' :: (Map map key e, Ord key) => key -> map -> Maybe (key, e)

-- | Returns list of map keys.
keys :: Map map key e => map -> [key]

-- | Searches the key of first matching element.
(.$) :: Map map key e => (e -> Bool) -> map -> Maybe key

-- | Searches the keys of all matching elements.
(*$) :: Map map key e => (e -> Bool) -> map -> [key]

-- | <a>kfoldr</a> is <a>foldr</a> with key.
kfoldr :: Map map key e => (key -> e -> b -> b) -> b -> map -> b

-- | <a>kfoldl</a> is <a>foldl</a> with key.
kfoldl :: Map map key e => (key -> b -> e -> b) -> b -> map -> b

-- | <a>kfoldr'</a> is strict version of <a>kfoldr</a>.
kfoldr' :: Map map key e => (key -> e -> b -> b) -> b -> map -> b

-- | <a>kfoldl'</a> is strict version of <a>kfoldl</a>.
kfoldl' :: Map map key e => (key -> b -> e -> b) -> b -> map -> b
infixl 9 !
infixl 9 .!
infixl 9 !?

-- | Kind <tt>(* -&gt; *)</tt> <a>Map</a> structure.
type Map1 map key e = Map (map e) key e

-- | Kind <tt>(* -&gt; * -&gt; *)</tt> <a>Map</a> structure.
type Map2 map key e = Map (map key e) key e
instance SDP.Map.Map [e] GHC.Types.Int e


-- | <a>SDP.LinearM</a> is a module that provides <a>BorderedM</a> and
--   <a>LinearM</a> classes.
module SDP.LinearM

-- | <a>BorderedM</a> is <a>Bordered</a> version for mutable data
--   structures.
class (Monad m, Index i) => BorderedM m b i | b -> m, b -> i

-- | <a>getBounds</a> returns <a>bounds</a> of mutable data structure.
getBounds :: BorderedM m b i => b -> m (i, i)

-- | <a>getLower</a> returns <a>lower</a> bound of mutable data structure.
getLower :: BorderedM m b i => b -> m i

-- | <a>getUpper</a> returns <a>upper</a> bound of mutable data structure.
getUpper :: BorderedM m b i => b -> m i

-- | <a>getSizeOf</a> returns <a>size</a> of mutable data structure.
getSizeOf :: BorderedM m b i => b -> m Int

-- | <a>getSizesOf</a> returns <a>sizes</a> of mutable data structure.
getSizesOf :: BorderedM m b i => b -> m [Int]

-- | <a>nowIndexIn</a> is <a>indexIn</a> version for mutable structures.
nowIndexIn :: BorderedM m b i => b -> i -> m Bool

-- | <a>getOffsetOf</a> is <a>offsetOf</a> version for mutable structures.
getOffsetOf :: BorderedM m b i => b -> i -> m Int

-- | <a>getIndexOf</a> is <a>indexOf</a> version for mutable structures.
getIndexOf :: BorderedM m b i => b -> Int -> m i

-- | <a>getIndices</a> returns <a>indices</a> of mutable data structure.
getIndices :: BorderedM m b i => b -> m [i]

-- | Kind <tt>(* -&gt; *)</tt> <a>BorderedM</a> structure.
type BorderedM1 m l i e = BorderedM m (l e) i

-- | Kind <tt>(* -&gt; * -&gt; *)</tt> <a>BorderedM</a> structure.
type BorderedM2 m l i e = BorderedM m (l i e) i

-- | <a>LinearM</a> is <a>Linear</a> version for mutable data structures.
--   This class is designed with the possibility of in-place
--   implementation, so many operations from <a>Linear</a> have no
--   analogues here.
class (Monad m) => LinearM m l e | l -> m, l -> e

-- | Monadic <a>single</a>.
newNull :: LinearM m l e => m l

-- | Monadic <a>isNull</a>.
nowNull :: LinearM m l e => l -> m Bool

-- | Monadic <a>single</a>.
singleM :: LinearM m l e => e -> m l

-- | <a>getHead</a> is monadic version of <a>head</a>. This procedure
--   mustn't modify the source structure or return references to its
--   mutable fields.
getHead :: LinearM m l e => l -> m e

-- | <a>getLast</a> is monadic version of <a>last</a>. This procedure
--   mustn't modify the source structure or return references to its
--   mutable fields.
getLast :: LinearM m l e => l -> m e

-- | Prepends new element to the start of the structure (monadic
--   <a>toHead</a>). Like most size-changing operations, <tt>prepend</tt>
--   doesn't guarantee the correctness of the original structure after
--   conversion.
prepend :: LinearM m l e => e -> l -> m l

-- | Appends new element to the end of the structure (monadic
--   <a>toLast</a>). Like most size-changing operations, <tt>append</tt>
--   doesn't guarantee the correctness of the original structure after
--   conversion.
append :: LinearM m l e => l -> e -> m l

-- | Monadic <a>fromList</a>.
newLinear :: LinearM m l e => [e] -> m l

-- | Monadic <a>fromListN</a>.
newLinearN :: LinearM m l e => Int -> [e] -> m l

-- | Monadic <a>fromFoldable</a>.
fromFoldableM :: (LinearM m l e, Foldable f) => f e -> m l

-- | Left view of line.
getLeft :: LinearM m l e => l -> m [e]

-- | Right view of line.
getRight :: LinearM m l e => l -> m [e]

-- | (!#&gt;) is unsafe monadic offset-based reader.
(!#>) :: LinearM m l e => l -> Int -> m e

-- | Unsafe monadic offset-based writer.
writeM :: LinearM m l e => l -> Int -> e -> m ()

-- | Create copy.
copied :: LinearM m l e => l -> m l

-- | <tt>copied' es l n</tt> returns the slice of <tt>es</tt> from
--   <tt>l</tt> of length <tt>n</tt>.
copied' :: LinearM m l e => l -> Int -> Int -> m l

-- | Monadic <a>reverse</a>.
reversed :: LinearM m l e => l -> m l

-- | Monadic <a>concat</a>.
merged :: (LinearM m l e, Foldable f) => f l -> m l

-- | Monadic version of <a>replicate</a>.
filled :: LinearM m l e => Int -> e -> m l

-- | <tt>copyTo source soff target toff count</tt> writes <tt>count</tt>
--   elements of <tt>source</tt> from <tt>soff</tt> to <tt>target</tt>
--   starting with <tt>toff</tt>.
copyTo :: LinearM m l e => l -> Int -> l -> Int -> Int -> m ()

-- | <a>ofoldrM</a> is right monadic fold with offset.
ofoldrM :: LinearM m l e => (Int -> e -> r -> m r) -> r -> l -> m r

-- | <a>ofoldlM</a> is left monadic fold with offset.
ofoldlM :: LinearM m l e => (Int -> r -> e -> m r) -> r -> l -> m r

-- | <a>ofoldrM'</a> is strict version of <a>ofoldrM</a>.
ofoldrM' :: LinearM m l e => (Int -> e -> r -> m r) -> r -> l -> m r

-- | <a>ofoldrM'</a> is strict version of <a>ofoldrM</a>.
ofoldlM' :: LinearM m l e => (Int -> r -> e -> m r) -> r -> l -> m r

-- | <a>foldrM</a> is just <a>ofoldrM</a> in <a>Linear</a> context.
foldrM :: LinearM m l e => (e -> r -> m r) -> r -> l -> m r

-- | <a>foldlM</a> is just <a>ofoldlM</a> in <a>Linear</a> context.
foldlM :: LinearM m l e => (r -> e -> m r) -> r -> l -> m r

-- | <a>foldrM'</a> is strict version of <a>foldrM</a>.
foldrM' :: LinearM m l e => (e -> r -> m r) -> r -> l -> m r

-- | <a>foldlM'</a> is strict version of <a>foldlM</a>.
foldlM' :: LinearM m l e => (r -> e -> m r) -> r -> l -> m r

-- | Just swap two elements.
swapM :: LinearM m l e => l -> Int -> Int -> m ()
infixl 5 !#>

-- | Kind <tt>(* -&gt; *)</tt> <a>LinearM</a> structure.
type LinearM1 m l e = LinearM m (l e) e

-- | <a>SplitM</a> is <a>Split</a> version for mutable data structures.
--   This class is designed with the possibility of in-place
--   implementation, so many operations from <a>Split</a> have no analogues
--   here.
class (LinearM m s e) => SplitM m s e

-- | <tt>takeM n es</tt> returns a reference to the <tt>es</tt>, keeping
--   first <tt>n</tt> elements. Changes in the source and result must be
--   synchronous.
takeM :: SplitM m s e => Int -> s -> m s

-- | <tt>takeM n es</tt> returns a reference to the <tt>es</tt>, keeping
--   first <tt>n</tt> elements. Changes in the source and result must be
--   synchronous.
takeM :: (SplitM m s e, BorderedM m s i) => Int -> s -> m s

-- | <tt>dropM n es</tt> returns a reference to the <tt>es</tt>, discarding
--   first <tt>n</tt> elements. Changes in the source and result must be
--   synchronous.
dropM :: SplitM m s e => Int -> s -> m s

-- | <tt>dropM n es</tt> returns a reference to the <tt>es</tt>, discarding
--   first <tt>n</tt> elements. Changes in the source and result must be
--   synchronous.
dropM :: (SplitM m s e, BorderedM m s i) => Int -> s -> m s

-- | <tt>keepM n es</tt> returns a reference to the <tt>es</tt>, keeping
--   last <tt>n</tt> elements. Changes in the source and result must be
--   synchronous.
keepM :: SplitM m s e => Int -> s -> m s

-- | <tt>keepM n es</tt> returns a reference to the <tt>es</tt>, keeping
--   last <tt>n</tt> elements. Changes in the source and result must be
--   synchronous.
keepM :: (SplitM m s e, BorderedM m s i) => Int -> s -> m s

-- | <tt>sansM n es</tt> returns a reference to the <tt>es</tt>, discarding
--   last <tt>n</tt> elements. Changes in the source and result must be
--   synchronous.
sansM :: SplitM m s e => Int -> s -> m s

-- | <tt>sansM n es</tt> returns a reference to the <tt>es</tt>, discarding
--   last <tt>n</tt> elements. Changes in the source and result must be
--   synchronous.
sansM :: (SplitM m s e, BorderedM m s i) => Int -> s -> m s

-- | <tt>splitM n es</tt> returns pair of references to the <tt>es</tt>:
--   keeping and discarding first <tt>n</tt> elements. Changes in the
--   source and result must be synchronous.
splitM :: SplitM m s e => Int -> s -> m (s, s)

-- | <tt>divideM n es</tt> returns pair of references to the <tt>es</tt>:
--   discarding and keeping last <tt>n</tt> elements. Changes in the source
--   and results must be synchronous.
divideM :: SplitM m s e => Int -> s -> m (s, s)

-- | <tt>splitM ns es</tt> returns the sequence of <tt>es</tt> prefix
--   references of length <tt>n &lt;- ns</tt>. Changes in the source and
--   results must be synchronous.
splitsM :: (SplitM m s e, Foldable f) => f Int -> s -> m [s]

-- | <tt>dividesM ns es</tt> returns the sequence of <tt>es</tt> suffix
--   references of length <tt>n &lt;- ns</tt>. Changes in the source and
--   results must be synchronous.
dividesM :: (SplitM m s e, Foldable f) => f Int -> s -> m [s]

-- | <tt>partsM n es</tt> returns the sequence of <tt>es</tt> prefix
--   references, splitted by offsets in <tt>es</tt>. Changes in the source
--   and results must be synchronous.
partsM :: (SplitM m s e, Foldable f) => f Int -> s -> m [s]

-- | <tt>chunksM n es</tt> returns the sequence of <tt>es</tt> prefix
--   references of length <tt>n</tt>. Changes in the source and results
--   must be synchronous.
chunksM :: SplitM m s e => Int -> s -> m [s]

-- | <tt>eachM n es</tt> returns new sequence of <tt>es</tt> elements with
--   step <tt>n</tt>. eachM shouldn't return references to <tt>es</tt>.
eachM :: SplitM m s e => Int -> s -> m s

-- | <tt>prefixM p es</tt> returns the longest <tt>es</tt> prefix size,
--   satisfying <tt>p</tt>.
prefixM :: SplitM m s e => (e -> Bool) -> s -> m Int

-- | <tt>suffixM p es</tt> returns the longest <tt>es</tt> suffix size,
--   satisfying <tt>p</tt>.
suffixM :: SplitM m s e => (e -> Bool) -> s -> m Int

-- | <tt>mprefix p es</tt> returns the longest <tt>es</tt> prefix size,
--   satisfying <tt>p</tt>.
mprefix :: SplitM m s e => (e -> m Bool) -> s -> m Int

-- | <tt>msuffix p es</tt> returns the longest <tt>es</tt> suffix size,
--   satisfying <tt>p</tt>.
msuffix :: SplitM m s e => (e -> m Bool) -> s -> m Int

-- | Kind <tt>(* -&gt; *)</tt> <a>SplitM</a> structure.
type SplitM1 m l e = SplitM m (l e) e


-- | <a>SDP.MapM</a> provides <a>MapM</a> - class of mutable associative
--   arrays.
module SDP.MapM

-- | <a>MapM</a> is class of mutable associative arrays.
class (Monad m) => MapM m map key e | map -> m, map -> key, map -> e

-- | Create new mutable map from list of <tt>(key, element)</tt>
--   associations.
newMap :: MapM m map key e => [(key, e)] -> m map

-- | Create new mutable map from list of <tt>(key, element)</tt>
--   associations.
newMap' :: MapM m map key e => e -> [(key, e)] -> m map

-- | <a>getAssocs</a> is version of <a>assocs</a> for mutable maps.
getAssocs :: (MapM m map key e, LinearM m map e) => map -> m [(key, e)]

-- | <a>getAssocs</a> is version of <a>assocs</a> for mutable maps.
getAssocs :: MapM m map key e => map -> m [(key, e)]

-- | <tt>(<a>&gt;!</a>)</tt> is unsafe monadic reader.
(>!) :: MapM m map key e => map -> key -> m e

-- | <tt>(<a>!&gt;</a>)</tt> is well-safe monadic reader.
(!>) :: (MapM m map key e, BorderedM m map key) => map -> key -> m e

-- | <tt>(<a>!&gt;</a>)</tt> is well-safe monadic reader.
(!>) :: MapM m map key e => map -> key -> m e

-- | <tt>(<a>!?&gt;</a>)</tt> is completely safe monadic reader.
(!?>) :: MapM m map key e => map -> key -> m (Maybe e)

-- | Update elements by mapping with indices.
updateM :: MapM m map key e => map -> (key -> e -> e) -> m map

-- | This function designed to overwrite large enough fragments of the
--   structure (unlike <a>writeM</a> and <a>writeM'</a>)
--   
--   In addition to write operations, <a>overwrite</a> can move and clean,
--   optimize data presentation, etc. of a particular structure. Since the
--   reference to the original structure may not be the same as reference
--   to the result (which implementation is undesirable, but acceptable),
--   the original reference (argument) shouldn't be used after
--   <a>overwrite</a>.
--   
--   All standard <tt>sdp</tt> structures support safe in-place
--   <a>overwrite</a>.
--   
--   If the structure uses unmanaged memory, then all unused fragments in
--   the resulting structure must be deallocated, regardless of
--   reachability by original reference (argument).
--   
--   Please note that <tt>overwrite</tt> require a list of associations
--   with indices in the current structure bounds and ignore any other,
--   therefore:
--   
--   <pre>
--   fromAssocs bnds ascs /= (fromAssocs bnds ascs &gt;&gt;= flip overwrite ascs)
--   </pre>
overwrite :: MapM m map key e => map -> [(key, e)] -> m map

-- | Checks if key in map.
memberM' :: (MapM m map key e, BorderedM m map key) => map -> key -> m Bool

-- | Checks if key in map.
memberM' :: MapM m map key e => map -> key -> m Bool

-- | Returns list of map keys.
getKeys :: (MapM m map key e, BorderedM m map key) => map -> m [key]

-- | Returns list of map keys.
getKeys :: MapM m map key e => map -> m [key]

-- | (.?) is monadic version of (.$).
(.?) :: MapM m map key e => (e -> Bool) -> map -> m (Maybe key)

-- | (*?) is monadic version of (*$).
(*?) :: MapM m map key e => (e -> Bool) -> map -> m [key]

-- | <a>kfoldrM</a> is right monadic fold with key.
kfoldrM :: MapM m map key e => (key -> e -> acc -> m acc) -> acc -> map -> m acc

-- | <a>kfoldlM</a> is left monadic fold with key.
kfoldlM :: MapM m map key e => (key -> acc -> e -> m acc) -> acc -> map -> m acc

-- | <a>kfoldrM'</a> is strict version of <a>kfoldrM</a>.
kfoldrM' :: MapM m map key e => (key -> e -> acc -> m acc) -> acc -> map -> m acc

-- | <a>kfoldlM'</a> is strict version of <a>kfoldlM</a>.
kfoldlM' :: MapM m map key e => (key -> acc -> e -> m acc) -> acc -> map -> m acc
infixl 5 >!
infixl 5 !>
infixl 5 !?>

-- | Rank <tt>(* -&gt; *)</tt> <a>MapM</a>.
type MapM1 m map key e = MapM m (map e) key e

-- | Rank <tt>(* -&gt; * -&gt; *)</tt> <a>MapM</a>.
type MapM2 m map key e = MapM m (map key e) key e


-- | <a>SDP.Indexed</a> provides <a>Indexed</a> and <a>Freeze</a> classes.
module SDP.Indexed

-- | <a>Indexed</a> is class of ordered associative arrays with static
--   bounds.
class (Linear v e, Bordered v i, Map v i e) => Indexed v i e | v -> i, v -> e

-- | <tt>assoc bnds ascs</tt> create new structure from list of
--   associations, without default element. Note that <tt>bnds</tt> is
--   <tt>ascs</tt> bounds and may not match with the result bounds (not
--   always possible).
assoc :: Indexed v i e => (i, i) -> [(i, e)] -> v

-- | <tt>assoc' bnds def ascs</tt> creates new structure from list of
--   associations with default element. Note that <tt>bnds</tt> is
--   <tt>ascs</tt> bounds and may not match with the result bounds (not
--   always possible).
assoc' :: Indexed v i e => (i, i) -> e -> [(i, e)] -> v

-- | <a>fromIndexed</a> converts this indexed structure to another one.
fromIndexed :: (Indexed v i e, Indexed m j e) => m -> v

-- | Safe index-based immutable writer.
write' :: Indexed v i e => v -> i -> e -> v

-- | <tt><a>accum</a> f es ies</tt> create a new structure from <tt>es</tt>
--   elements selectively updated by function <tt>f</tt> and <tt>ies</tt>
--   associations list.
accum :: Indexed v i e => (e -> e' -> e) -> v -> [(i, e')] -> v

-- | <a>imap</a> creates new indexed structure from old with reshaping.
imap :: (Indexed v i e, Map m j e) => (i, i) -> m -> (i -> j) -> v

-- | Update element by given function.
update' :: Indexed v i e => v -> (e -> e) -> i -> v

-- | Create new structure from old by mapping with index.
updates' :: Indexed v i e => v -> (i -> e -> e) -> v

-- | Kind <tt>(* -&gt; *)</tt> <a>Indexed</a> structure.
type Indexed1 v i e = Indexed (v e) i e

-- | Kind <tt>(* -&gt; * -&gt; *)</tt> <a>Indexed</a> structure.
type Indexed2 v i e = Indexed (v i e) i e

-- | binaryContain checks that sorted structure has equal element.
binaryContain :: (Linear v e, Bordered v i) => Compare e -> e -> v -> Bool

-- | Service class of mutable to immutable conversions.
class (Monad m) => Freeze m v' v | v' -> m

-- | <tt>freeze</tt> is a safe way to convert a mutable structure to a
--   immutable. <tt>freeze</tt> should copy the old structure or ensure
--   that it will not be used after calling the procedure.
freeze :: Freeze m v' v => v' -> m v

-- | <tt>unsafeFreeze</tt> is unsafe version of <a>freeze</a>.
--   <tt>unsafeFreeze</tt> doesn't guarantee that the structure will be
--   copied or locked. It only guarantees that if the old structure isn't
--   used, no error will occur.
unsafeFreeze :: Freeze m v' v => v' -> m v

-- | Kind <tt>(* -&gt; *)</tt> <a>Freeze</a>.
type Freeze1 m v' v e = Freeze m (v' e) (v e)
instance SDP.Indexed.Indexed [e] GHC.Types.Int e


-- | <a>SDP.IndexedM</a> provides <a>IndexedM</a> and <a>Thaw</a> classes.
module SDP.IndexedM

-- | Class for work with mutable indexed structures.
class (LinearM m v e, BorderedM m v i, MapM m v i e) => IndexedM m v i e

-- | <tt>fromAssocs bnds ascs</tt> creates new structure from list of
--   associations, without default element. Note that <tt>bnds</tt> is
--   <tt>ascs</tt> bounds and may not match with the result bounds (not
--   always possible).
fromAssocs :: IndexedM m v i e => (i, i) -> [(i, e)] -> m v

-- | <tt>fromAssocs' bnds defvalue ascs</tt> creates new structure from
--   list of associations, with default element. Note that <tt>bnds</tt> is
--   <tt>ascs</tt> bounds and may not match with the result bounds (not
--   always possible).
fromAssocs' :: IndexedM m v i e => (i, i) -> e -> [(i, e)] -> m v

-- | <tt><a>writeM</a> map key e</tt> writes element <tt>e</tt> to
--   <tt>key</tt> position safely (if <tt>key</tt> is out of <tt>map</tt>
--   range, do nothing). The <a>writeM</a> function is intended to
--   overwrite only existing values, so its behavior is identical for
--   structures with both static and dynamic boundaries.
writeM' :: IndexedM m v i e => v -> i -> e -> m ()

-- | Just swap two elements.
swapM' :: IndexedM m v i e => v -> i -> i -> m ()

-- | fromIndexed' is overloaded version of thaw.
fromIndexed' :: (IndexedM m v i e, Indexed v' j e) => v' -> m v

-- | fromIndexed converts one mutable structure to other.
fromIndexedM :: (IndexedM m v i e, IndexedM m v' j e) => v' -> m v

-- | reshaped creates new indexed structure from old with reshaping
--   function.
reshaped :: (IndexedM m v i e, IndexedM m v' j e) => (i, i) -> v' -> (i -> j) -> m v

-- | <tt><a>fromAccum</a> f es ies</tt> create a new structure from
--   <tt>es</tt> elements selectively updated by function <tt>f</tt> and
--   <tt>ies</tt> associations list.
fromAccum :: IndexedM m v i e => (e -> e' -> e) -> v -> [(i, e')] -> m v

-- | Update element by given function.
updateM' :: IndexedM m v i e => v -> (e -> e) -> i -> m ()

-- | Kind <tt>(* -&gt; *)</tt> <a>IndexedM</a>.
type IndexedM1 m v i e = IndexedM m (v e) i e

-- | Kind <tt>(* -&gt; * -&gt; *)</tt> <a>IndexedM</a>.
type IndexedM2 m v i e = IndexedM m (v i e) i e

-- | Service class of immutable to mutable conversions.
class (Monad m) => Thaw m v v' | v' -> m

-- | <tt>thaw</tt> is safe way to convert a immutable structure to a
--   mutable. <tt>thaw</tt> should copy the old structure or ensure that it
--   will not be used after the procedure calling.
thaw :: Thaw m v v' => v -> m v'

-- | <tt>unsafeThaw</tt> is unsafe version of <a>thaw</a>.
--   <tt>unsafeThaw</tt> doesn't guarantee that the structure will be
--   copied or locked. It only guarantees that if the old structure isn't
--   used, no error will occur.
unsafeThaw :: Thaw m v v' => v -> m v'

-- | Kind <tt>(* -&gt; *)</tt> <a>Thaw</a>.
type Thaw1 m v v' e = Thaw m (v e) (v' e)


-- | <a>SDP.SortM.Insertion</a> provides insertion sort - simple sorting
--   algorithm.
module SDP.SortM.Insertion

-- | <a>insertionSort</a> is just synonym for <tt><a>insertionSortBy</a>
--   <a>compare</a></tt>.
insertionSort :: (LinearM m v e, BorderedM m v i, Ord e) => v -> m ()

-- | <a>insertionSortBy</a> is naive service sorting procedure, that have
--   <tt>O(n^2)</tt> complexity in all cases.
insertionSortBy :: (LinearM m v e, BorderedM m v i) => Compare e -> v -> m ()

-- | <a>insertionSortOn</a> is a version of <a>insertionSortBy</a> that
--   uses a cast function to <a>compare</a> elements.
insertionSortOn :: (LinearM m v e, BorderedM m v i, Ord o) => (e -> o) -> v -> m ()

-- | unsafeInsertionSort cmp es b s e is internal sorting procedure, where
--   <tt>cmp</tt> - compare function, <tt>es</tt> - data structure, <tt>[b
--   .. s]</tt> - sorted range, <tt>[b .. e]</tt> - sortable range.
unsafeInsertionSort :: LinearM m v e => Compare e -> v -> Int -> Int -> Int -> m ()


-- | <a>SDP.SortM.Tim</a> provides <tt>InsertionSort</tt> and
--   <tt>TimSort</tt> algorithms.
module SDP.SortM.Tim

-- | <a>timSort</a> is just synonym for <tt><a>timSortBy</a>
--   <a>compare</a></tt>.
timSort :: (LinearM m v e, BorderedM m v i, Ord e) => v -> m ()

-- | <a>timSortBy</a> is a sorting procedure for mutable random access data
--   structures using any comparison function and having <tt>O(nlogn)</tt>
--   complexity in the worst case.
timSortBy :: (LinearM m v e, BorderedM m v i) => Compare e -> v -> m ()

-- | <a>timSortOn</a> is a version of <a>timSortBy</a> that uses a
--   conversion function to compare elements.
timSortOn :: (LinearM m v e, BorderedM m v i, Ord o) => (e -> o) -> v -> m ()

-- | <a>minrunTS</a> returns <tt>TimSort</tt> chunk size by given length.
minrunTS :: Int -> Int


-- | <a>SDP.Prim.SBytes</a> provides strict unboxed array pseudo-primitive
--   types <a>SBytes#</a>, <a>STBytes#</a> and <a>IOBytes#</a>.
module SDP.Prim.SBytes

-- | <a>MIOBytes#</a> is mutable pseudo-primitive <a>Int</a>-indexed strict
--   unboxed array.
newtype MIOBytes# (io :: Type -> Type) e
MIOBytes# :: STBytes# RealWorld e -> MIOBytes# (io :: Type -> Type) e

-- | <a>IOBytes#</a> is mutable pseudo-primitive <a>Int</a>-indexed strict
--   unboxed array.
type IOBytes# = MIOBytes# IO

-- | <a>STBytes#</a> is mutable pseudo-primitive <a>Int</a>-indexed strict
--   unboxed array type.
data STBytes# s e

-- | <a>SBytes#</a> is immutable pseudo-primitive <a>Int</a>-indexed strict
--   unboxed array type.
--   
--   <a>SBytes#</a> isn't real Haskell primitive (like <a>GHC.Exts</a>
--   types) but for reliability and stability, I made it inaccessible to
--   direct work.
data SBytes# e

-- | <a>fromSBytes#</a> returns new <a>ByteArray#</a>.
fromSBytes# :: Unboxed e => SBytes# e -> ByteArray#

-- | <a>packSBytes#</a> creates new <a>SBytes#</a> from sized
--   <a>ByteArray#</a>.
packSBytes# :: Unboxed e => Int -> ByteArray# -> SBytes# e

-- | <a>unpackSBytes#</a> returns <a>ByteArray#</a> field of
--   <a>SBytes#</a>.
unpackSBytes# :: Unboxed e => SBytes# e -> ByteArray#

-- | <a>offsetSBytes#</a> returns <a>SBytes#</a> offset in elements.
offsetSBytes# :: Unboxed e => SBytes# e -> Int

-- | <a>fromSTBytes#</a> returns new <a>MutableByteArray#</a>.
fromSTBytes# :: Unboxed e => STBytes# s e -> State# s -> (# State# s, MutableByteArray# s #)

-- | <a>packSTBytes#</a> creates new <a>STBytes#</a> from sized
--   <a>MutableByteArray#</a>.
packSTBytes# :: Unboxed e => Int -> MutableByteArray# s -> STBytes# s e

-- | <a>unpackSTBytes#</a> returns <a>MutableByteArray#</a> field of
--   <a>STBytes#</a>.
unpackSTBytes# :: Unboxed e => STBytes# s e -> MutableByteArray# s

-- | <a>offsetSTBytes#</a> returns <a>STBytes#</a> offset in bytes.
offsetSTBytes# :: Unboxed e => STBytes# s e -> Int#

-- | <a>unsafeCoerceSBytes#</a> is unsafe low-lowel coerce of an array with
--   recounting the number of elements and offset (with possible rounding).
unsafeCoerceSBytes# :: (Unboxed a, Unboxed b) => SBytes# a -> SBytes# b

-- | <a>unsafeCoerceSTBytes#</a> is unsafe low-lowel coerce of an mutable
--   array with recounting the number of elements and offset (with possible
--   rounding).
unsafeCoerceSTBytes# :: (Unboxed a, Unboxed b) => STBytes# s a -> STBytes# s b

-- | <tt><a>unsafeSBytesToPtr#</a> es</tt> byte-wise stores <a>SBytes#</a>
--   content to <a>Ptr</a>. Returns the number of overwritten elements and
--   a pointer to <tt>psizeof es (sizeOf es)</tt> bytes of allocated
--   memory.
unsafeSBytesToPtr# :: Unboxed e => SBytes# e -> IO (Int, Ptr e)

-- | <tt><a>unsafePtrToSBytes#</a> n ptr</tt> byte-wise stores <tt>n</tt>
--   elements of <a>Ptr</a> <tt>ptr</tt> to <a>SBytes#</a>.
unsafePtrToSBytes# :: Unboxed e => (Int, Ptr e) -> IO (SBytes# e)

-- | Calculate hash <a>SBytes#</a> using <a>hashUnboxedWith</a>.
hashSBytesWith# :: Unboxed e => Int -> SBytes# e -> Int
instance GHC.Classes.Eq (SDP.Prim.SBytes.MIOBytes# io e)
instance SDP.Estimate.Estimate (SDP.Prim.SBytes.MIOBytes# io e)
instance SDP.Linear.Bordered (SDP.Prim.SBytes.MIOBytes# io e) GHC.Types.Int
instance Control.Monad.IO.Class.MonadIO io => SDP.LinearM.BorderedM io (SDP.Prim.SBytes.MIOBytes# io e) GHC.Types.Int
instance (Control.Monad.IO.Class.MonadIO io, SDP.Unboxed.Unboxed e) => SDP.LinearM.LinearM io (SDP.Prim.SBytes.MIOBytes# io e) e
instance (Control.Monad.IO.Class.MonadIO io, SDP.Unboxed.Unboxed e) => SDP.LinearM.SplitM io (SDP.Prim.SBytes.MIOBytes# io e) e
instance (Control.Monad.IO.Class.MonadIO io, SDP.Unboxed.Unboxed e) => SDP.MapM.MapM io (SDP.Prim.SBytes.MIOBytes# io e) GHC.Types.Int e
instance (Control.Monad.IO.Class.MonadIO io, SDP.Unboxed.Unboxed e) => SDP.IndexedM.IndexedM io (SDP.Prim.SBytes.MIOBytes# io e) GHC.Types.Int e
instance (Control.Monad.IO.Class.MonadIO io, SDP.Unboxed.Unboxed e) => SDP.SortM.SortM io (SDP.Prim.SBytes.MIOBytes# io e) e
instance (Control.Monad.IO.Class.MonadIO io, SDP.Unboxed.Unboxed e) => SDP.IndexedM.Thaw io (SDP.Prim.SBytes.SBytes# e) (SDP.Prim.SBytes.MIOBytes# io e)
instance (Control.Monad.IO.Class.MonadIO io, SDP.Unboxed.Unboxed e) => SDP.Indexed.Freeze io (SDP.Prim.SBytes.MIOBytes# io e) (SDP.Prim.SBytes.SBytes# e)
instance (Foreign.Storable.Storable e, SDP.Unboxed.Unboxed e) => SDP.Indexed.Freeze GHC.Types.IO (GHC.Types.Int, GHC.Ptr.Ptr e) (SDP.Prim.SBytes.SBytes# e)
instance SDP.Nullable.Nullable (SDP.Prim.SBytes.SBytes# e)
instance Data.Default.Class.Default (SDP.Prim.SBytes.SBytes# e)
instance SDP.Unboxed.Unboxed e => SDP.Linear.Linear (SDP.Prim.SBytes.SBytes# e) e
instance SDP.Unboxed.Unboxed e => SDP.IndexedM.Thaw (GHC.ST.ST s) (SDP.Prim.SBytes.SBytes# e) (SDP.Prim.SBytes.STBytes# s e)
instance SDP.Unboxed.Unboxed e => SDP.Indexed.Freeze (GHC.ST.ST s) (SDP.Prim.SBytes.STBytes# s e) (SDP.Prim.SBytes.SBytes# e)
instance GHC.Classes.Eq (SDP.Prim.SBytes.STBytes# s e)
instance SDP.Estimate.Estimate (SDP.Prim.SBytes.STBytes# s e)
instance SDP.Linear.Bordered (SDP.Prim.SBytes.STBytes# s e) GHC.Types.Int
instance SDP.LinearM.BorderedM (GHC.ST.ST s) (SDP.Prim.SBytes.STBytes# s e) GHC.Types.Int
instance SDP.Unboxed.Unboxed e => SDP.LinearM.LinearM (GHC.ST.ST s) (SDP.Prim.SBytes.STBytes# s e) e
instance SDP.Unboxed.Unboxed e => SDP.LinearM.SplitM (GHC.ST.ST s) (SDP.Prim.SBytes.STBytes# s e) e
instance SDP.Unboxed.Unboxed e => SDP.MapM.MapM (GHC.ST.ST s) (SDP.Prim.SBytes.STBytes# s e) GHC.Types.Int e
instance SDP.Unboxed.Unboxed e => SDP.IndexedM.IndexedM (GHC.ST.ST s) (SDP.Prim.SBytes.STBytes# s e) GHC.Types.Int e
instance SDP.Unboxed.Unboxed e => SDP.SortM.SortM (GHC.ST.ST s) (SDP.Prim.SBytes.STBytes# s e) e
instance SDP.Unboxed.Unboxed e => GHC.Classes.Eq (SDP.Prim.SBytes.SBytes# e)
instance (SDP.Unboxed.Unboxed e, GHC.Classes.Ord e) => GHC.Classes.Ord (SDP.Prim.SBytes.SBytes# e)
instance (SDP.Unboxed.Unboxed e, GHC.Show.Show e) => GHC.Show.Show (SDP.Prim.SBytes.SBytes# e)
instance (SDP.Unboxed.Unboxed e, GHC.Read.Read e) => GHC.Read.Read (SDP.Prim.SBytes.SBytes# e)
instance Data.String.IsString (SDP.Prim.SBytes.SBytes# GHC.Types.Char)
instance SDP.Unboxed.Unboxed e => GHC.Exts.IsList (SDP.Prim.SBytes.SBytes# e)
instance SDP.Unboxed.Unboxed e => GHC.Base.Semigroup (SDP.Prim.SBytes.SBytes# e)
instance SDP.Unboxed.Unboxed e => GHC.Base.Monoid (SDP.Prim.SBytes.SBytes# e)
instance SDP.Estimate.Estimate (SDP.Prim.SBytes.SBytes# e)
instance SDP.Unboxed.Unboxed e => SDP.Linear.Split (SDP.Prim.SBytes.SBytes# e) e
instance SDP.Linear.Bordered (SDP.Prim.SBytes.SBytes# e) GHC.Types.Int
instance (SDP.Unboxed.Unboxed e, GHC.Classes.Ord e) => SDP.Set.Set (SDP.Prim.SBytes.SBytes# e) e
instance SDP.Unboxed.Unboxed e => SDP.Set.SetWith (SDP.Prim.SBytes.SBytes# e) e
instance SDP.Unboxed.Unboxed e => SDP.Scan.Scan (SDP.Prim.SBytes.SBytes# e) e
instance SDP.Unboxed.Unboxed e => SDP.Sort.Sort (SDP.Prim.SBytes.SBytes# e) e
instance SDP.Unboxed.Unboxed e => SDP.Map.Map (SDP.Prim.SBytes.SBytes# e) GHC.Types.Int e
instance SDP.Unboxed.Unboxed e => SDP.Indexed.Indexed (SDP.Prim.SBytes.SBytes# e) GHC.Types.Int e
instance (Foreign.Storable.Storable e, SDP.Unboxed.Unboxed e) => SDP.IndexedM.Thaw GHC.Types.IO (SDP.Prim.SBytes.SBytes# e) (GHC.Types.Int, GHC.Ptr.Ptr e)


-- | <a>SDP.Prim.SArray</a> provides lazy boxed array pseudo-primitive
--   types <a>SArray#</a>, <a>STArray#</a> and <a>IOArray#</a>.
module SDP.Prim.SArray

-- | <a>MIOArray#</a> is mutable preudo-primitive <a>Int</a>-indexed lazy
--   boxed array.
newtype MIOArray# (io :: Type -> Type) e
MIOArray# :: STArray# RealWorld e -> MIOArray# (io :: Type -> Type) e

-- | <a>IOArray#</a> is mutable preudo-primitive <a>Int</a>-indexed lazy
--   boxed array.
type IOArray# = MIOArray# IO

-- | <a>STArray#</a> is mutable preudo-primitive <a>Int</a>-indexed lazy
--   boxed array type.
data STArray# s e

-- | <a>SArray#</a> is immutable pseudo-primitive <a>Int</a>-indexed lazy
--   boxed array type.
--   
--   <a>SArray#</a> isn't real Haskell primitive (like <a>GHC.Exts</a>
--   types) but for reliability and stability, I made it inaccessible to
--   direct work.
data SArray# e

-- | <a>fromSArray#</a> returns new <a>Array#</a> (uses
--   <a>cloneArray#</a>).
fromSArray# :: SArray# e -> Array# e

-- | <a>fromSTArray#</a> returns new <a>MutableArray#</a>.
fromSTArray# :: STArray# s e -> State# s -> (# State# s, MutableArray# s e #)

-- | <a>unpackSArray#</a> returns <a>MutableArray#</a> field of
--   <a>SArray#</a>.
unpackSArray# :: SArray# e -> Array# e

-- | <a>offsetSArray#</a> returns <a>SArray#</a> offset in elements.
offsetSArray# :: SArray# e -> Int#

-- | <a>unpackSTArray#</a> returns <a>MutableArray#</a> field of
--   <a>STArray#</a> or fails.
unpackSTArray# :: STArray# s e -> MutableArray# s e

-- | <a>offsetSTArray#</a> returns <a>STArray#</a> offset in elements.
offsetSTArray# :: STArray# s e -> Int#

-- | <a>packSArray#</a> creates new <a>SArray#</a> from sized
--   <a>Array#</a>.
packSArray# :: Int -> Array# e -> SArray# e

-- | <a>packSTArray#</a> creates new <a>STArray#</a> from sized
--   <a>MutableArray#</a>.
packSTArray# :: Int -> MutableArray# s e -> STArray# s e

-- | <a>coerceSArray#</a> is <a>coerce</a> alias.
coerceSArray# :: Coercible a b => SArray# a -> SArray# b

-- | <a>coerceSTArray#</a> is <a>coerce</a> alias.
coerceSTArray# :: Coercible a b => STArray# s a -> STArray# s b
instance GHC.Classes.Eq (SDP.Prim.SArray.MIOArray# io e)
instance SDP.Estimate.Estimate (SDP.Prim.SArray.MIOArray# io e)
instance SDP.Linear.Bordered (SDP.Prim.SArray.MIOArray# io e) GHC.Types.Int
instance Control.Monad.IO.Class.MonadIO io => SDP.LinearM.BorderedM io (SDP.Prim.SArray.MIOArray# io e) GHC.Types.Int
instance Control.Monad.IO.Class.MonadIO io => SDP.LinearM.LinearM io (SDP.Prim.SArray.MIOArray# io e) e
instance Control.Monad.IO.Class.MonadIO io => SDP.LinearM.SplitM io (SDP.Prim.SArray.MIOArray# io e) e
instance Control.Monad.IO.Class.MonadIO io => SDP.MapM.MapM io (SDP.Prim.SArray.MIOArray# io e) GHC.Types.Int e
instance Control.Monad.IO.Class.MonadIO io => SDP.IndexedM.IndexedM io (SDP.Prim.SArray.MIOArray# io e) GHC.Types.Int e
instance Control.Monad.IO.Class.MonadIO io => SDP.SortM.SortM io (SDP.Prim.SArray.MIOArray# io e) e
instance Control.Monad.IO.Class.MonadIO io => SDP.IndexedM.Thaw io (SDP.Prim.SArray.SArray# e) (SDP.Prim.SArray.MIOArray# io e)
instance Control.Monad.IO.Class.MonadIO io => SDP.Indexed.Freeze io (SDP.Prim.SArray.MIOArray# io e) (SDP.Prim.SArray.SArray# e)
instance Foreign.Storable.Storable e => SDP.Indexed.Freeze GHC.Types.IO (GHC.Types.Int, GHC.Ptr.Ptr e) (SDP.Prim.SArray.SArray# e)
instance SDP.Linear.Linear (SDP.Prim.SArray.SArray# e) e
instance SDP.IndexedM.Thaw (GHC.ST.ST s) (SDP.Prim.SArray.SArray# e) (SDP.Prim.SArray.STArray# s e)
instance SDP.Indexed.Freeze (GHC.ST.ST s) (SDP.Prim.SArray.STArray# s e) (SDP.Prim.SArray.SArray# e)
instance GHC.Classes.Eq (SDP.Prim.SArray.STArray# s e)
instance SDP.Estimate.Estimate (SDP.Prim.SArray.STArray# s e)
instance SDP.Linear.Bordered (SDP.Prim.SArray.STArray# s e) GHC.Types.Int
instance SDP.LinearM.BorderedM (GHC.ST.ST s) (SDP.Prim.SArray.STArray# s e) GHC.Types.Int
instance SDP.LinearM.LinearM (GHC.ST.ST s) (SDP.Prim.SArray.STArray# s e) e
instance SDP.LinearM.SplitM (GHC.ST.ST s) (SDP.Prim.SArray.STArray# s e) e
instance SDP.MapM.MapM (GHC.ST.ST s) (SDP.Prim.SArray.STArray# s e) GHC.Types.Int e
instance SDP.IndexedM.IndexedM (GHC.ST.ST s) (SDP.Prim.SArray.STArray# s e) GHC.Types.Int e
instance SDP.SortM.SortM (GHC.ST.ST s) (SDP.Prim.SArray.STArray# s e) e
instance GHC.Classes.Eq e => GHC.Classes.Eq (SDP.Prim.SArray.SArray# e)
instance Data.Functor.Classes.Eq1 SDP.Prim.SArray.SArray#
instance GHC.Classes.Ord e => GHC.Classes.Ord (SDP.Prim.SArray.SArray# e)
instance Data.Functor.Classes.Ord1 SDP.Prim.SArray.SArray#
instance GHC.Show.Show e => GHC.Show.Show (SDP.Prim.SArray.SArray# e)
instance GHC.Read.Read e => GHC.Read.Read (SDP.Prim.SArray.SArray# e)
instance Data.String.IsString (SDP.Prim.SArray.SArray# GHC.Types.Char)
instance GHC.Exts.IsList (SDP.Prim.SArray.SArray# e)
instance SDP.Nullable.Nullable (SDP.Prim.SArray.SArray# e)
instance GHC.Base.Semigroup (SDP.Prim.SArray.SArray# e)
instance GHC.Base.Monoid (SDP.Prim.SArray.SArray# e)
instance Data.Default.Class.Default (SDP.Prim.SArray.SArray# e)
instance SDP.Estimate.Estimate (SDP.Prim.SArray.SArray# e)
instance GHC.Base.Functor SDP.Prim.SArray.SArray#
instance SDP.Zip.Zip SDP.Prim.SArray.SArray#
instance GHC.Base.Applicative SDP.Prim.SArray.SArray#
instance Data.Foldable.Foldable SDP.Prim.SArray.SArray#
instance Data.Traversable.Traversable SDP.Prim.SArray.SArray#
instance SDP.Linear.Split (SDP.Prim.SArray.SArray# e) e
instance SDP.Linear.Bordered (SDP.Prim.SArray.SArray# e) GHC.Types.Int
instance GHC.Classes.Ord e => SDP.Set.Set (SDP.Prim.SArray.SArray# e) e
instance SDP.Set.SetWith (SDP.Prim.SArray.SArray# e) e
instance SDP.Scan.Scan (SDP.Prim.SArray.SArray# e) e
instance SDP.Sort.Sort (SDP.Prim.SArray.SArray# e) e
instance SDP.Map.Map (SDP.Prim.SArray.SArray# e) GHC.Types.Int e
instance SDP.Indexed.Indexed (SDP.Prim.SArray.SArray# e) GHC.Types.Int e
instance Foreign.Storable.Storable e => SDP.IndexedM.Thaw GHC.Types.IO (SDP.Prim.SArray.SArray# e) (GHC.Types.Int, GHC.Ptr.Ptr e)


-- | <a>SDP.Prim.TArray</a> provides lazy boxed array of <tt>stm</tt>
--   <a>TVar</a>s. Note that <a>TArray#</a> stores each element in
--   <a>TVar</a>.
module SDP.Prim.TArray

-- | <a>SArray#</a> of <tt>stm</tt> <a>TVar</a>s.
newtype TArray# e
TArray# :: SArray# (TVar e) -> TArray# e

-- | A monad supporting atomic memory transactions.
data STM a

-- | Shared memory locations that support atomic memory transactions.
data TVar a
instance GHC.Classes.Eq (SDP.Prim.TArray.TArray# e)
instance SDP.Nullable.Nullable (SDP.Prim.TArray.TArray# e)
instance SDP.Estimate.Estimate (SDP.Prim.TArray.TArray# e)
instance SDP.Linear.Bordered (SDP.Prim.TArray.TArray# e) GHC.Types.Int
instance SDP.LinearM.BorderedM GHC.Conc.Sync.STM (SDP.Prim.TArray.TArray# e) GHC.Types.Int
instance SDP.LinearM.LinearM GHC.Conc.Sync.STM (SDP.Prim.TArray.TArray# e) e
instance SDP.LinearM.SplitM GHC.Conc.Sync.STM (SDP.Prim.TArray.TArray# e) e
instance SDP.MapM.MapM GHC.Conc.Sync.STM (SDP.Prim.TArray.TArray# e) GHC.Types.Int e
instance SDP.IndexedM.IndexedM GHC.Conc.Sync.STM (SDP.Prim.TArray.TArray# e) GHC.Types.Int e
instance SDP.IndexedM.Thaw GHC.Conc.Sync.STM (SDP.Prim.SArray.SArray# e) (SDP.Prim.TArray.TArray# e)
instance SDP.Indexed.Freeze GHC.Conc.Sync.STM (SDP.Prim.TArray.TArray# e) (SDP.Prim.SArray.SArray# e)


-- | <a>Text.Read.SDP</a> provides common <a>ReadPrec</a> parsers and
--   related stuff.
module Text.Read.SDP

expect :: Lexeme -> ReadP ()
appPrec :: Int

-- | <tt><a>linearPrec</a> ident</tt> is common parser of <a>Linear</a>
--   structure with name <tt>ident</tt>:
--   
--   <pre>
--   read "Z" == read "[]" == []
--   read "['l','g','p','l']" == fromList "lgpl"
--   read "4 [1,5,-1,45,12,6,0,0,12]" == fromListN 4 [1,5,-1,45,12,6,0,0,12]
--   </pre>
linearPrec :: (Linear l e, Read e) => String -> ReadPrec l

-- | <tt><a>indexedPrec</a> ident</tt> is common parser of <a>Indexed</a>
--   structure with name <tt>ident</tt>:
--   
--   <pre>
--   read "ident (0,1) [(0,0),(1,1)]" == read "(0,1) [(0,0),(1,1)]" == assoc (0,1) [(0,0),(1,1)]
--   </pre>
indexedPrec :: (Indexed v i e, Read i, Read e) => String -> ReadPrec v

-- | <a>indexedPrec'</a> is common <a>Linear</a> and <a>Indexed</a> parser
--   (recommended).
indexedPrec' :: (Indexed v i e, Read i, Read e) => String -> ReadPrec v

-- | <a>readZeroPrec</a> is just <a>Z</a> parser, see <a>linearPrec</a>.
readZeroPrec :: Linear l e => ReadPrec l

-- | <a>readAsList</a> is <a>fromList</a>-based parser, see
--   <a>linearPrec</a>.
readAsList :: (Linear l e, Read e) => ReadPrec l

-- | <a>readAsListN</a> is <a>fromListN</a>-based parser, see
--   <a>linearPrec</a>.
readAsListN :: (Linear l e, Read e) => ReadPrec l

-- | <a>readAssocsPrec</a> is <tt>sdp</tt> recommended format
--   <a>ReadPrec</a> parser for <a>Indexed</a>.
readAssocsPrec :: (Indexed v i e, Read i, Read e) => ReadPrec v

-- | <tt>allPrec</tt> is just <tt><a>allPrecWith</a> <a>readPrec</a></tt>
allPrec :: Read e => ReadPrec [e]

-- | allPrecWith is <a>manyTill</a>-based combinator, which reads a
--   sequence of elements without any separators:
--   
--   <pre>
--   readBy allPrecWith readPrec "1 2 3 4 5 6 7" :: [Int] == [1 .. 7]
--   </pre>
allPrecWith :: ReadPrec e -> ReadPrec [e]

-- | Just lifted <a>expect</a>.
expectPrec :: Lexeme -> ReadPrec ()

-- | <tt><a>namedPrec</a> readprec name</tt> is <a>readPrec</a> with
--   optional <tt>name</tt> prefix.
namedPrec :: ReadPrec e -> String -> ReadPrec e

-- | <a>read</a> with implicit default value.
readDef :: (Read e, Default e) => String -> e

-- | <a>readBy</a> is generalized <a>read</a>.
readBy :: ReadPrec e -> String -> e

-- | <a>readMaybeBy</a> is generalized <a>readMaybe</a>.
readMaybeBy :: ReadPrec e -> String -> Maybe e

-- | <a>readEitherBy</a> is generalized <a>readEither</a>.
readEitherBy :: ReadPrec e -> String -> Either String e

-- | <a>readBy</a> with implicit default value.
readDefBy :: Default e => ReadPrec e -> String -> e

-- | Common <a>Enum</a> parser.
readAsEnum :: (Linear l e, Read e, Enum e) => ReadPrec l

-- | <a>enumFrom</a> parser:
--   
--   <pre>
--   take 5 (readBy enumFromPrec "[1 ..]") == take 5 [1 ..] = [1,2,3,4,5]
--   </pre>
enumFromPrec :: (Linear l e, Read e, Enum e) => ReadPrec l

-- | <a>enumFromTo</a> parser:
--   
--   <pre>
--   readBy enumFromToPrec "[9 .. 12]" == [9 .. 12] == [9,10,11,12]
--   </pre>
enumFromToPrec :: (Linear l e, Read e, Enum e) => ReadPrec l

-- | <a>enumFromThen</a> parser:
--   
--   <pre>
--   take 4 (readBy enumFromThenPrec "[17, -6 .. ]") == take 4 [17, -6 ..] == [17,-6,-29,-52]
--   </pre>
enumFromThenPrec :: (Linear l e, Read e, Enum e) => ReadPrec l

-- | <a>enumFromThenTo</a> parser:
--   
--   <pre>
--   take 4 (readBy enumFromThenToPrec "[17, -6 .. 4]") == [17, -6 .. 4] == [17]
--   </pre>
enumFromThenToPrec :: (Linear l e, Read e, Enum e) => ReadPrec l


-- | <a>Text.Show.SDP</a> provides common <a>ShowS</a> stuff.
module Text.Show.SDP

-- | <a>assocsPrec</a> is <a>showsPrec</a> template.
assocsPrec :: (Indexed v i e, Show i, Show e) => String -> Int -> v -> ShowS

-- | <a>showsRaw</a> is a primitive list-to-string conversion pattern.
--   
--   Note that attempting to parse the resulting string with standard
--   <tt>ReadS</tt>-based functions will cause an error (ambiguous parse).
--   To properly parse a string, use the <tt>readRawSequence</tt> function
--   from the <a>SDP.Text.Read</a> module.
showsRaw :: Show e => Int -> [e] -> ShowS

-- | Just <a>showsRaw</a> version for <a>Linear</a>.
showsRawLinear :: (Linear l e, Show e) => Int -> l -> ShowS


-- | <a>SDP.Templates.AnyChunks</a> provides <a>AnyChunks</a> - list of
--   data chunks.
module SDP.Templates.AnyChunks

-- | <a>AnyChunks</a> is list of data chunks. AnyChunks shouldn't contain
--   empty chunks, so the <a>AnyChunks</a> constructor is made private (see
--   <a>fromChunks</a> and <a>fromChunksM</a>).
--   
--   <ul>
--   <li>Efficiency of operations on <tt><a>AnyChunks</a> rep e</tt> are
--   very sensitive in the efficiency of <a>Bordered</a>, <a>Linear</a> and
--   <a>Split</a> on <tt>rep e</tt>.</li>
--   <li><tt><a>AnyChunks</a> rep e</tt> is only defined for Int-indexed
--   <tt>rep e</tt>.</li>
--   <li><a>Eq</a>, <a>Ord</a>, <a>Eq1</a> and <a>Ord1</a> instances
--   compare <tt><a>AnyChunks</a> rep e</tt> as streams of equal size
--   chunks. To do this, the comparison <tt>rep e</tt> must also be
--   lexicographic, also for <tt>rep e</tt> must implement <a>Bordered</a>
--   and <a>Split</a>.</li>
--   <li><a>Freeze</a> and <a>Thaw</a> for <tt><a>AnyChunks</a> rep e</tt>
--   are defined for all <tt>rep e</tt> that already have <a>Freeze</a> and
--   <a>Thaw</a> instances.</li>
--   </ul>
data AnyChunks rep e

-- | Construct immutable <a>AnyChunks</a> safely.
fromChunks :: Nullable (rep e) => [rep e] -> AnyChunks rep e

-- | Construct mutable <a>AnyChunks</a> safely.
fromChunksM :: BorderedM1 m rep Int e => [rep e] -> m (AnyChunks rep e)

-- | Extract immutable <a>AnyChunks</a> chunks safely.
toChunks :: AnyChunks rep e -> [rep e]
instance GHC.Generics.Generic (SDP.Templates.AnyChunks.AnyChunks rep e)
instance (Data.Typeable.Internal.Typeable rep, Data.Typeable.Internal.Typeable e, Data.Data.Data (rep e)) => Data.Data.Data (SDP.Templates.AnyChunks.AnyChunks rep e)
instance (GHC.Classes.Eq (rep e), SDP.Linear.Bordered1 rep GHC.Types.Int e, SDP.Linear.Split1 rep e) => GHC.Classes.Eq (SDP.Templates.AnyChunks.AnyChunks rep e)
instance (GHC.Classes.Ord (rep e), SDP.Linear.Bordered1 rep GHC.Types.Int e, SDP.Linear.Split1 rep e) => GHC.Classes.Ord (SDP.Templates.AnyChunks.AnyChunks rep e)
instance (SDP.Indexed.Indexed1 rep GHC.Types.Int e, GHC.Show.Show e) => GHC.Show.Show (SDP.Templates.AnyChunks.AnyChunks rep e)
instance SDP.Indexed.Indexed1 rep GHC.Types.Int GHC.Types.Char => GHC.Show.Show (SDP.Templates.AnyChunks.AnyChunks rep GHC.Types.Char)
instance (SDP.Indexed.Indexed1 rep GHC.Types.Int e, GHC.Read.Read e) => GHC.Read.Read (SDP.Templates.AnyChunks.AnyChunks rep e)
instance SDP.Nullable.Nullable (SDP.Templates.AnyChunks.AnyChunks rep e)
instance GHC.Base.Semigroup (SDP.Templates.AnyChunks.AnyChunks rep e)
instance GHC.Base.Monoid (SDP.Templates.AnyChunks.AnyChunks rep e)
instance Data.Default.Class.Default (SDP.Templates.AnyChunks.AnyChunks rep e)
instance SDP.Linear.Bordered1 rep GHC.Types.Int e => SDP.Estimate.Estimate (SDP.Templates.AnyChunks.AnyChunks rep e)
instance SDP.Linear.Linear1 (SDP.Templates.AnyChunks.AnyChunks rep) GHC.Types.Char => Data.String.IsString (SDP.Templates.AnyChunks.AnyChunks rep GHC.Types.Char)
instance SDP.Linear.Linear1 (SDP.Templates.AnyChunks.AnyChunks rep) e => GHC.Exts.IsList (SDP.Templates.AnyChunks.AnyChunks rep e)
instance GHC.Base.Functor rep => GHC.Base.Functor (SDP.Templates.AnyChunks.AnyChunks rep)
instance GHC.Base.Applicative rep => GHC.Base.Applicative (SDP.Templates.AnyChunks.AnyChunks rep)
instance Data.Foldable.Foldable rep => Data.Foldable.Foldable (SDP.Templates.AnyChunks.AnyChunks rep)
instance Data.Traversable.Traversable rep => Data.Traversable.Traversable (SDP.Templates.AnyChunks.AnyChunks rep)
instance SDP.Linear.Bordered1 rep GHC.Types.Int e => SDP.Linear.Bordered (SDP.Templates.AnyChunks.AnyChunks rep e) GHC.Types.Int
instance (SDP.Linear.Bordered1 rep GHC.Types.Int e, SDP.Linear.Linear1 rep e) => SDP.Linear.Linear (SDP.Templates.AnyChunks.AnyChunks rep e) e
instance (SDP.Linear.Bordered1 rep GHC.Types.Int e, SDP.Linear.Split1 rep e) => SDP.Linear.Split (SDP.Templates.AnyChunks.AnyChunks rep e) e
instance SDP.LinearM.BorderedM1 m rep GHC.Types.Int e => SDP.LinearM.BorderedM m (SDP.Templates.AnyChunks.AnyChunks rep e) GHC.Types.Int
instance (SDP.LinearM.BorderedM1 m rep GHC.Types.Int e, SDP.LinearM.SplitM1 m rep e) => SDP.LinearM.LinearM m (SDP.Templates.AnyChunks.AnyChunks rep e) e
instance (SDP.LinearM.BorderedM1 m rep GHC.Types.Int e, SDP.LinearM.SplitM1 m rep e) => SDP.LinearM.SplitM m (SDP.Templates.AnyChunks.AnyChunks rep e) e
instance (SDP.Nullable.Nullable (SDP.Templates.AnyChunks.AnyChunks rep e), SDP.Set.SetWith1 (SDP.Templates.AnyChunks.AnyChunks rep) e, GHC.Classes.Ord e) => SDP.Set.Set (SDP.Templates.AnyChunks.AnyChunks rep e) e
instance (SDP.Set.SetWith1 rep e, SDP.Linear.Linear1 rep e, GHC.Classes.Ord (rep e), SDP.Linear.Bordered1 rep GHC.Types.Int e) => SDP.Set.SetWith (SDP.Templates.AnyChunks.AnyChunks rep e) e
instance SDP.Linear.Linear1 (SDP.Templates.AnyChunks.AnyChunks rep) e => SDP.Scan.Scan (SDP.Templates.AnyChunks.AnyChunks rep e) e
instance SDP.Indexed.Indexed1 rep GHC.Types.Int e => SDP.Map.Map (SDP.Templates.AnyChunks.AnyChunks rep e) GHC.Types.Int e
instance SDP.Indexed.Indexed1 rep GHC.Types.Int e => SDP.Indexed.Indexed (SDP.Templates.AnyChunks.AnyChunks rep e) GHC.Types.Int e
instance (SDP.LinearM.SplitM1 m rep e, SDP.MapM.MapM1 m rep GHC.Types.Int e, SDP.LinearM.BorderedM1 m rep GHC.Types.Int e) => SDP.MapM.MapM m (SDP.Templates.AnyChunks.AnyChunks rep e) GHC.Types.Int e
instance (SDP.LinearM.SplitM1 m rep e, SDP.IndexedM.IndexedM1 m rep GHC.Types.Int e) => SDP.IndexedM.IndexedM m (SDP.Templates.AnyChunks.AnyChunks rep e) GHC.Types.Int e
instance (SDP.LinearM.BorderedM1 m rep GHC.Types.Int e, SDP.SortM.SortM1 m rep e, SDP.LinearM.SplitM1 m rep e, SDP.LinearM.LinearM1 m rep e) => SDP.SortM.SortM m (SDP.Templates.AnyChunks.AnyChunks rep e) e
instance (SDP.Linear.Linear1 imm e, SDP.IndexedM.Thaw1 m imm mut e) => SDP.IndexedM.Thaw m (SDP.Templates.AnyChunks.AnyChunks imm e) (mut e)
instance SDP.IndexedM.Thaw1 m imm mut e => SDP.IndexedM.Thaw m (imm e) (SDP.Templates.AnyChunks.AnyChunks mut e)
instance SDP.IndexedM.Thaw1 m imm mut e => SDP.IndexedM.Thaw m (SDP.Templates.AnyChunks.AnyChunks imm e) (SDP.Templates.AnyChunks.AnyChunks mut e)
instance SDP.Indexed.Freeze1 m mut imm e => SDP.Indexed.Freeze m (mut e) (SDP.Templates.AnyChunks.AnyChunks imm e)
instance (SDP.LinearM.LinearM1 m mut e, SDP.Indexed.Freeze1 m mut imm e) => SDP.Indexed.Freeze m (SDP.Templates.AnyChunks.AnyChunks mut e) (imm e)
instance SDP.Indexed.Freeze1 m mut imm e => SDP.Indexed.Freeze m (SDP.Templates.AnyChunks.AnyChunks mut e) (SDP.Templates.AnyChunks.AnyChunks imm e)


-- | <a>SDP.Unrolled.Unlist</a> provides <a>Unlist</a> - lazy boxed
--   unrolled linked list.
module SDP.Unrolled.Unlist

-- | <a>Unlist</a> is unrolled linked list of boxed values.
type Unlist = AnyChunks SArray#
instance Data.Functor.Classes.Eq1 SDP.Unrolled.Unlist.Unlist
instance Data.Functor.Classes.Ord1 SDP.Unrolled.Unlist.Unlist
instance SDP.Zip.Zip SDP.Unrolled.Unlist.Unlist
instance SDP.Sort.Sort (SDP.Unrolled.Unlist.Unlist e) e


-- | <a>SDP.Unrolled.STUnlist</a> provides <a>STUnlist</a> - mutable boxed
--   lazy unrolled linked list.
module SDP.Unrolled.STUnlist

-- | <a>STUnlist</a> is mutable version of <a>Unlist</a>.
type STUnlist s = AnyChunks (STArray# s)


-- | <a>SDP.Unrolled.IOUnlist</a> provides <a>IOUnlist</a> - mutable lazy
--   boxed unrolled linked list.
module SDP.Unrolled.IOUnlist

-- | <a>MIOUnlist</a> is mutable version of <a>Unlist</a>.
type MIOUnlist io = AnyChunks (MIOArray# io)

-- | <a>IOUnlist</a> is mutable version of <a>Unlist</a>.
type IOUnlist = AnyChunks IOArray#


-- | <a>SDP.ByteList.Ublist</a> provides <a>Ublist</a> - strict boxed
--   unrolled linked list.
module SDP.ByteList.Ublist

-- | <a>Ublist</a> is unrolled linked list of unboxed values.
type Ublist = AnyChunks SBytes#
instance SDP.Unboxed.Unboxed e => SDP.Sort.Sort (SDP.ByteList.Ublist.Ublist e) e


-- | <a>SDP.ByteList.STUblist</a> provides <a>STUblist</a> - mutable
--   unboxed strict unrolled linked list.
module SDP.ByteList.STUblist

-- | This <a>STUblist</a> is mutable version of <a>Ublist</a>.
type STUblist s = AnyChunks (STBytes# s)


-- | <a>SDP.ByteList.IOUblist</a> provides <a>IOUblist</a> - mutable strict
--   unboxed unrolled linked list.
module SDP.ByteList.IOUblist

-- | <a>MIOUblist</a> is mutable version of <a>Ublist</a>.
type MIOUblist io = AnyChunks (MIOBytes# io)

-- | <a>IOUblist</a> is mutable version of <a>Ublist</a>.
type IOUblist = AnyChunks IOBytes#


-- | <a>Control.Concurent.SDP.TUnlist</a> provides lazy boxed unrolled
--   linked list of <tt>stm</tt> <a>TVar</a>s.
module Control.Concurent.SDP.TUnlist

-- | Lazy boxed unrolled linked list.
type TUnlist = AnyChunks TArray#

-- | A monad supporting atomic memory transactions.
data STM a

-- | Shared memory locations that support atomic memory transactions.
data TVar a


-- | <a>SDP.Plate.AnyBorder</a> provides <a>AnyBorder</a> - template of
--   generalized by index type structure, based on <a>Int</a>-indexed
--   primitive.
module SDP.Templates.AnyBorder

-- | <a>AnyBorder</a> is template, that appends arbitrary bounds to any
--   structure.
--   
--   <ul>
--   <li><a>Eq</a>, <a>Ord</a>, <a>Eq1</a> and <a>Ord1</a> instances
--   ingores bounds.</li>
--   <li><a>Thaw</a> and <a>Freeze</a> instances for <tt><a>AnyBorder</a>
--   rep e</tt> inherit <tt>rep e</tt> behavior.</li>
--   </ul>
data AnyBorder rep i e
AnyBorder :: !i -> !i -> !rep e -> AnyBorder rep i e
instance GHC.Generics.Generic (SDP.Templates.AnyBorder.AnyBorder rep i e)
instance (Data.Typeable.Internal.Typeable rep, Data.Typeable.Internal.Typeable e, Data.Data.Data i, Data.Data.Data (rep e)) => Data.Data.Data (SDP.Templates.AnyBorder.AnyBorder rep i e)
instance (SDP.Index.Index i, GHC.Classes.Eq (rep e)) => GHC.Classes.Eq (SDP.Templates.AnyBorder.AnyBorder rep i e)
instance (SDP.Index.Index i, Data.Functor.Classes.Eq1 rep) => Data.Functor.Classes.Eq1 (SDP.Templates.AnyBorder.AnyBorder rep i)
instance (SDP.Index.Index i, GHC.Classes.Ord (rep e)) => GHC.Classes.Ord (SDP.Templates.AnyBorder.AnyBorder rep i e)
instance (SDP.Index.Index i, Data.Functor.Classes.Ord1 rep) => Data.Functor.Classes.Ord1 (SDP.Templates.AnyBorder.AnyBorder rep i)
instance (SDP.Indexed.Indexed1 rep GHC.Types.Int e, SDP.Index.Index i, GHC.Show.Show i, GHC.Show.Show e) => GHC.Show.Show (SDP.Templates.AnyBorder.AnyBorder rep i e)
instance (SDP.Indexed.Indexed1 rep GHC.Types.Int GHC.Types.Char, SDP.Index.Index i, GHC.Show.Show i) => GHC.Show.Show (SDP.Templates.AnyBorder.AnyBorder rep i GHC.Types.Char)
instance (SDP.Index.Index i, GHC.Read.Read i, GHC.Read.Read e, SDP.Indexed.Indexed1 rep GHC.Types.Int e) => GHC.Read.Read (SDP.Templates.AnyBorder.AnyBorder rep i e)
instance (SDP.Index.Index i, Data.String.IsString (rep GHC.Types.Char), SDP.Linear.Bordered1 rep GHC.Types.Int GHC.Types.Char) => Data.String.IsString (SDP.Templates.AnyBorder.AnyBorder rep i GHC.Types.Char)
instance (SDP.Index.Index i, GHC.Exts.IsList (rep e), SDP.Linear.Bordered1 rep GHC.Types.Int e) => GHC.Exts.IsList (SDP.Templates.AnyBorder.AnyBorder rep i e)
instance (SDP.Index.Index i, SDP.Linear.Bordered (rep e) GHC.Types.Int, SDP.Nullable.Nullable (rep e)) => SDP.Nullable.Nullable (SDP.Templates.AnyBorder.AnyBorder rep i e)
instance SDP.Linear.Linear1 (SDP.Templates.AnyBorder.AnyBorder rep i) e => GHC.Base.Semigroup (SDP.Templates.AnyBorder.AnyBorder rep i e)
instance SDP.Linear.Linear1 (SDP.Templates.AnyBorder.AnyBorder rep i) e => GHC.Base.Monoid (SDP.Templates.AnyBorder.AnyBorder rep i e)
instance SDP.Linear.Linear1 (SDP.Templates.AnyBorder.AnyBorder rep i) e => Data.Default.Class.Default (SDP.Templates.AnyBorder.AnyBorder rep i e)
instance SDP.Index.Index i => SDP.Estimate.Estimate (SDP.Templates.AnyBorder.AnyBorder rep i e)
instance (SDP.Index.Index i, GHC.Base.Functor rep) => GHC.Base.Functor (SDP.Templates.AnyBorder.AnyBorder rep i)
instance (SDP.Index.Index i, SDP.Zip.Zip rep) => SDP.Zip.Zip (SDP.Templates.AnyBorder.AnyBorder rep i)
instance (SDP.Index.Index i, GHC.Base.Applicative rep) => GHC.Base.Applicative (SDP.Templates.AnyBorder.AnyBorder rep i)
instance (SDP.Index.Index i, Data.Foldable.Foldable rep) => Data.Foldable.Foldable (SDP.Templates.AnyBorder.AnyBorder rep i)
instance (SDP.Index.Index i, Data.Traversable.Traversable rep) => Data.Traversable.Traversable (SDP.Templates.AnyBorder.AnyBorder rep i)
instance SDP.Index.Index i => SDP.Linear.Bordered (SDP.Templates.AnyBorder.AnyBorder rep i e) i
instance (SDP.Index.Index i, SDP.Linear.Linear1 rep e, SDP.Linear.Bordered1 rep GHC.Types.Int e) => SDP.Linear.Linear (SDP.Templates.AnyBorder.AnyBorder rep i e) e
instance (SDP.Index.Index i, SDP.Linear.Split1 rep e, SDP.Linear.Bordered1 rep GHC.Types.Int e) => SDP.Linear.Split (SDP.Templates.AnyBorder.AnyBorder rep i e) e
instance (SDP.Index.Index i, SDP.LinearM.BorderedM1 m rep GHC.Types.Int e) => SDP.LinearM.BorderedM m (SDP.Templates.AnyBorder.AnyBorder rep i e) i
instance (SDP.Index.Index i, SDP.LinearM.LinearM1 m rep e, SDP.LinearM.BorderedM1 m rep GHC.Types.Int e) => SDP.LinearM.LinearM m (SDP.Templates.AnyBorder.AnyBorder rep i e) e
instance (SDP.Index.Index i, SDP.LinearM.BorderedM1 m rep GHC.Types.Int e, SDP.LinearM.SplitM1 m rep e) => SDP.LinearM.SplitM m (SDP.Templates.AnyBorder.AnyBorder rep i e) e
instance (SDP.Set.SetWith1 (SDP.Templates.AnyBorder.AnyBorder rep i) e, SDP.Nullable.Nullable (SDP.Templates.AnyBorder.AnyBorder rep i e), GHC.Classes.Ord e) => SDP.Set.Set (SDP.Templates.AnyBorder.AnyBorder rep i e) e
instance (SDP.Index.Index i, SDP.Set.SetWith1 rep e, SDP.Linear.Linear1 rep e, SDP.Linear.Bordered1 rep GHC.Types.Int e) => SDP.Set.SetWith (SDP.Templates.AnyBorder.AnyBorder rep i e) e
instance SDP.Linear.Linear1 (SDP.Templates.AnyBorder.AnyBorder rep i) e => SDP.Scan.Scan (SDP.Templates.AnyBorder.AnyBorder rep i e) e
instance (SDP.Index.Index i, SDP.Sort.Sort (rep e) e) => SDP.Sort.Sort (SDP.Templates.AnyBorder.AnyBorder rep i e) e
instance (SDP.Index.Index i, SDP.Indexed.Indexed1 rep GHC.Types.Int e) => SDP.Map.Map (SDP.Templates.AnyBorder.AnyBorder rep i e) i e
instance (SDP.Index.Index i, SDP.Indexed.Indexed1 rep GHC.Types.Int e) => SDP.Indexed.Indexed (SDP.Templates.AnyBorder.AnyBorder rep i e) i e
instance (SDP.Linear.Bordered1 rep GHC.Types.Int e, SDP.Linear.Split1 rep e) => SDP.Shaped.Shaped (SDP.Templates.AnyBorder.AnyBorder rep) e
instance (SDP.Index.Index i, SDP.MapM.MapM1 m rep GHC.Types.Int e, SDP.LinearM.LinearM1 m rep e, SDP.LinearM.BorderedM1 m rep GHC.Types.Int e) => SDP.MapM.MapM m (SDP.Templates.AnyBorder.AnyBorder rep i e) i e
instance (SDP.Index.Index i, SDP.IndexedM.IndexedM1 m rep GHC.Types.Int e) => SDP.IndexedM.IndexedM m (SDP.Templates.AnyBorder.AnyBorder rep i e) i e
instance (SDP.Index.Index i, SDP.SortM.SortM1 m rep e) => SDP.SortM.SortM m (SDP.Templates.AnyBorder.AnyBorder rep i e) e
instance (SDP.Index.Index i, SDP.IndexedM.Thaw m (rep e) mut) => SDP.IndexedM.Thaw m (SDP.Templates.AnyBorder.AnyBorder rep i e) mut
instance (SDP.Index.Index i, SDP.IndexedM.Thaw m imm (rep e), SDP.Linear.Bordered1 rep GHC.Types.Int e) => SDP.IndexedM.Thaw m imm (SDP.Templates.AnyBorder.AnyBorder rep i e)
instance (SDP.Index.Index i, SDP.IndexedM.Thaw1 m imm mut e) => SDP.IndexedM.Thaw m (SDP.Templates.AnyBorder.AnyBorder imm i e) (SDP.Templates.AnyBorder.AnyBorder mut i e)
instance (SDP.Index.Index i, SDP.Indexed.Freeze m (rep e) imm) => SDP.Indexed.Freeze m (SDP.Templates.AnyBorder.AnyBorder rep i e) imm
instance (SDP.Index.Index i, SDP.Indexed.Freeze m mut (rep e), SDP.Linear.Bordered1 rep GHC.Types.Int e) => SDP.Indexed.Freeze m mut (SDP.Templates.AnyBorder.AnyBorder rep i e)
instance (SDP.Index.Index i, SDP.Indexed.Freeze1 m mut imm e) => SDP.Indexed.Freeze m (SDP.Templates.AnyBorder.AnyBorder mut i e) (SDP.Templates.AnyBorder.AnyBorder imm i e)


-- | <a>SDP.Unrolled.ST</a> provides <a>STUnrolled</a> - mutable boxed lazy
--   unrolled linked list.
module SDP.Unrolled.ST

-- | <a>STUnrolled</a> is mutable version <a>Unrolled</a>.
type STUnrolled s = AnyBorder (STUnlist s)


-- | <a>SDP.Unrolled.IO</a> provides <a>IOUnrolled</a> - mutable lazy boxed
--   unrolled linked list type.
module SDP.Unrolled.IO

-- | <a>MIOUnrolled</a> is mutable version of <a>Unrolled</a>.
type MIOUnrolled io = AnyBorder (MIOUnlist io)

-- | <a>IOUnrolled</a> is mutable version of <a>Unrolled</a>.
type IOUnrolled = AnyBorder IOUnlist


-- | <a>SDP.Unrolled</a> provides <a>Unrolled</a> - lazy boxed unrolled
--   linked list.
module SDP.Unrolled

-- | <a>Unrolled</a> is bordered unrolled linked list.
type Unrolled = AnyBorder Unlist

-- | <a>Unlist</a> is unrolled linked list of boxed values.
type Unlist = AnyChunks SArray#


-- | <a>SDP.Bytes.ST</a> provides <a>STBytes</a> - mutable lazy boxed array
--   type.
module SDP.Bytes.ST

-- | <a>STBytes</a> is mutable version of <a>Bytes</a>.
type STBytes s = AnyBorder (STBytes# s)


-- | <a>SDP.Bytes.IO</a> provides <a>IOBytes</a> - mutable strict unboxed
--   array type.
module SDP.Bytes.IO

-- | <a>MIOBytes</a> is mutable version of <a>Bytes</a>.
type MIOBytes io = AnyBorder (MIOBytes# io)

-- | <a>IOBytes</a> is mutable version of <a>Bytes</a>.
type IOBytes = AnyBorder IOBytes#


-- | <a>SDP.Bytes</a> provides <a>Bytes</a> - immutable strict unboxed
--   array type.
module SDP.Bytes

-- | <a>Bytes</a> - unboxed array.
type Bytes = AnyBorder SBytes#


-- | <a>SDP.ByteList.ST</a> provides <a>STByteList</a> - mutable unboxed
--   strict unrolled linked list.
module SDP.ByteList.ST

-- | <a>STByteList</a> is mutable version of <a>ByteList</a>.
type STByteList s = AnyBorder (STUblist s)


-- | <a>SDP.ByteList.IO</a> provides <a>IOByteList</a> - mutable strict
--   unboxed unrolled linked list type.
module SDP.ByteList.IO

-- | <a>MIOByteList</a> is mutable version of <a>ByteList</a>.
type MIOByteList io = AnyBorder (MIOUblist io)

-- | <a>IOByteList</a> is mutable version of <a>ByteList</a>.
type IOByteList = AnyBorder IOUblist


-- | <a>SDP.ByteList</a> provides <a>ByteList</a> - strict unboxed unrolled
--   linked list.
module SDP.ByteList

-- | <a>ByteList</a> is bordered strict unboxed unrolled linked list.
type ByteList = AnyBorder Ublist

-- | <a>Ublist</a> is unrolled linked list of unboxed values.
type Ublist = AnyChunks SBytes#


-- | <a>SDP.Array.ST</a> provides <a>STArray</a> - mutable lazy boxed array
--   type.
module SDP.Array.ST

-- | <a>STArray</a> is mutable version of <a>Array</a>.
type STArray s = AnyBorder (STArray# s)


-- | "SDP.Array.IO provides <a>IOArray</a> - mutable lazy boxed array type.
module SDP.Array.IO

-- | <a>MIOArray</a> is mutable version of <a>Array</a>.
type MIOArray io = AnyBorder (MIOArray# io)

-- | <a>IOArray</a> is mutable version of <a>Array</a>.
type IOArray = AnyBorder IOArray#


-- | <a>SDP.Array</a> provides <a>Array</a> - immutable lazy boxed array
--   type.
module SDP.Array

-- | <a>Array</a> - lazy boxed array.
type Array = AnyBorder SArray#


-- | <a>Control.Concurent.SDP.TUnrolled</a> provides lazy boxed unrolled
--   linked list of <tt>stm</tt> <a>TVar</a>s.
module Control.Concurent.SDP.TUnrolled

-- | Lazy boxed unrolled libked list.
type TUnrolled = AnyBorder TUnlist

-- | A monad supporting atomic memory transactions.
data STM a

-- | Shared memory locations that support atomic memory transactions.
data TVar a


-- | <a>Control.Concurent.SDP.TArray</a> provides lazy boxed array of
--   <tt>stm</tt> <a>TVar</a>s.
module Control.Concurent.SDP.TArray

-- | Lazy boxed array.
type TArray = AnyBorder TArray#

-- | A monad supporting atomic memory transactions.
data STM a

-- | Shared memory locations that support atomic memory transactions.
data TVar a