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


-- | Sized sequence data-types
--   
--   A wrapper to make length-parametrized data-type from ListLike
--   data-types.
@package sized
@version 0.2.1.0


-- | This module provides the functionality to make length-parametrized
--   types from existing <a>ListLike</a> and <a>Functor</a> sequential
--   types.
--   
--   Most of the complexity of operations for <tt>Sized f n a</tt> are the
--   same as original operations for <tt>f</tt>. For example, <a>!!</a> is
--   O(1) for <tt>Sized Vector n a</tt> but O(i) for <tt>Sized [] n a</tt>.
--   
--   This module also provides powerful view types and pattern synonyms to
--   inspect the sized sequence. See <a>Views and Patterns</a> for more
--   detail.
module Data.Sized

-- | <tt>Sized</tt> wraps a sequential type <tt>f</tt> and makes
--   length-parametrized version.
--   
--   Here, <tt>f</tt> must be the instance of <a>Functor</a> and
--   <tt><a>ListLike</a> (f a) a</tt> for all <tt>a</tt>. This constraint
--   is expressed by <a>ListLikeF</a>. Folding and traversing function such
--   as <a>all</a> and <tt>foldl'</tt> is available via <a>Foldable</a> or
--   <a>Traversable</a> class, if <tt>f</tt> is the instance of them.
--   
--   Since 0.2.0.0
data Sized (f :: Type -> Type) (n :: nat) a

-- | <a>Sized</a> vector with the length is existentially quantified. This
--   type is used mostly when the return type's length cannot be statically
--   determined beforehand.
--   
--   <tt>SomeSized sn xs :: SomeSized f a</tt> stands for the <a>Sized</a>
--   sequence <tt>xs</tt> of element type <tt>a</tt> and length
--   <tt>sn</tt>.
--   
--   Since 0.1.0.0
data SomeSized f nat a
[SomeSized] :: (ListLike (f a) a) => Sing n -> Sized f (n :: nat) a -> SomeSized f nat a
instLL :: forall f a. ListLikeF f :- ListLike (f a) a
instFunctor :: ListLikeF f :- Functor f

-- | Functor <tt>f</tt> such that there is instance <tt>ListLike (f a)
--   a</tt> for any <tt>a</tt>.
--   
--   Since 0.1.0.0
type ListLikeF f = (Functor f, Forall (LLF f))
withListLikeF :: forall pxy f a b. ListLikeF f => pxy (f a) -> ((Functor f, ListLike (f a) a) => b) -> b
withListLikeF' :: ListLikeF f => f a -> ((Functor f, ListLike (f a) a) => b) -> b

-- | Returns the length of wrapped containers. If you use
--   <tt>unsafeFromList</tt> or similar unsafe functions, this function may
--   return different value from type-parameterized length.
--   
--   Since 0.1.0.0
length :: ListLike (f a) a => Sized f n a -> Int

-- | <tt>Sing</tt> version of <a>length</a>.
--   
--   Since 0.2.0.0
sLength :: forall f (n :: nat) a. (HasOrdinal nat, ListLike (f a) a) => Sized f n a -> Sing n

-- | Test if the sequence is empty or not.
--   
--   Since 0.1.0.0
null :: ListLike (f a) a => Sized f n a -> Bool

-- | (Unsafe) indexing with <tt>Int</tt>s. If you want to check boundary
--   statically, use <a>%!!</a> or <a>sIndex</a>.
--   
--   Since 0.1.0.0
(!!) :: (ListLike (f a) a) => Sized f (Succ m) a -> Int -> a

-- | Safe indexing with <a>Ordinal</a>s.
--   
--   Since 0.1.0.0
(%!!) :: (HasOrdinal nat, ListLike (f c) c) => Sized f n c -> Ordinal (n :: nat) -> c

-- | Flipped version of <a>!!</a>.
--   
--   Since 0.1.0.0
index :: (ListLike (f a) a) => Int -> Sized f (Succ m) a -> a

-- | Flipped version of <a>%!!</a>.
--   
--   Since 0.1.0.0
sIndex :: (HasOrdinal nat, ListLike (f c) c) => Ordinal (n :: nat) -> Sized f n c -> c

-- | Take the first element of non-empty sequence. If you want to make
--   case-analysis for general sequence, see <a>Views and Patterns</a>
--   section.
--   
--   Since 0.1.0.0
head :: (HasOrdinal nat, ListLike (f a) b, (Zero nat :< n) ~ True) => Sized f n a -> b

-- | Take the last element of non-empty sequence. If you want to make
--   case-analysis for general sequence, see <a>Views and Patterns</a>
--   section.
--   
--   Since 0.1.0.0
last :: (HasOrdinal nat, (Zero nat :< n) ~ True, ListLike (f a) b) => Sized f n a -> b

-- | Take the <a>head</a> and <a>tail</a> of non-empty sequence. If you
--   want to make case-analysis for general sequence, see <a>Views and
--   Patterns</a> section.
--   
--   Since 0.1.0.0
uncons :: ListLike (f a) b => Sized f (Succ n) a -> (b, Sized f n a)
uncons' :: ListLike (f a) b => proxy n -> Sized f (Succ n) a -> (b, Sized f n a)

-- | Take the <a>init</a> and <a>last</a> of non-empty sequence. If you
--   want to make case-analysis for general sequence, see <a>Views and
--   Patterns</a> section.
--   
--   Since 0.1.0.0
unsnoc :: ListLike (f a) b => Sized f (Succ n) a -> (Sized f n a, b)
unsnoc' :: ListLike (f a) b => proxy n -> Sized f (Succ n) a -> (Sized f n a, b)

-- | Take the tail of non-empty sequence. If you want to make case-analysis
--   for general sequence, see <a>Views and Patterns</a> section.
--   
--   Since 0.1.0.0
tail :: (HasOrdinal nat, ListLike (f a) a) => Sized f (Succ n) a -> Sized f (n :: nat) a

-- | Take the initial segment of non-empty sequence. If you want to make
--   case-analysis for general sequence, see <a>Views and Patterns</a>
--   section.
--   
--   Since 0.1.0.0
init :: ListLike (f a) a => Sized f (Succ n) a -> Sized f n a

-- | <tt>take k xs</tt> takes first <tt>k</tt> element of <tt>xs</tt> where
--   the length of <tt>xs</tt> should be larger than <tt>k</tt>. It is
--   really sad, that this function takes at least O(k) regardless of base
--   container.
--   
--   Since 0.1.0.0
take :: (ListLike (f a) a, (n :<= m) ~ True, HasOrdinal nat) => Sing (n :: nat) -> Sized f m a -> Sized f n a

-- | <tt>take k xs</tt> takes first <tt>k</tt> element of <tt>xs</tt> at
--   most. It is really sad, that this function takes at least O(k)
--   regardless of base container.
--   
--   Since 0.1.0.0
takeAtMost :: (ListLike (f a) a, HasOrdinal nat) => Sing (n :: nat) -> Sized f m a -> Sized f (Min n m) a

-- | <tt>drop k xs</tt> drops first <tt>k</tt> element of <tt>xs</tt> and
--   returns the rest of sequence, where the length of <tt>xs</tt> should
--   be larger than <tt>k</tt>. It is really sad, that this function takes
--   at least O(k) regardless of base container.
--   
--   Since 0.1.0.0
drop :: (HasOrdinal nat, ListLike (f a) a, (n :<= m) ~ True) => Sing (n :: nat) -> Sized f m a -> Sized f (m :- n) a

-- | <tt>splitAt k xs</tt> split <tt>xs</tt> at <tt>k</tt>, where the
--   length of <tt>xs</tt> should be less than or equal to <tt>k</tt>. It
--   is really sad, that this function takes at least O(k) regardless of
--   base container.
--   
--   Since 0.1.0.0
splitAt :: (ListLike (f a) a, (n :<= m) ~ True, HasOrdinal nat) => Sing (n :: nat) -> Sized f m a -> (Sized f n a, Sized f (m :-. n) a)

-- | <tt>splitAtMost k xs</tt> split <tt>xs</tt> at <tt>k</tt>. If
--   <tt>k</tt> exceeds the length of <tt>xs</tt>, then the second result
--   value become empty. It is really sad, that this function takes at
--   least O(k) regardless of base container.
--   
--   Since 0.1.0.0
splitAtMost :: (HasOrdinal nat, ListLike (f a) a) => Sing (n :: nat) -> Sized f m a -> (Sized f (Min n m) a, Sized f (m :-. n) a)

-- | Empty sequence.
--   
--   Since 0.1.0.0
empty :: forall f a. (HasOrdinal nat, ListLike (f a) a) => Sized f (Zero nat :: nat) a

-- | Sequence with one element.
--   
--   Since 0.1.0.0
singleton :: forall f a. ListLike (f a) a => a -> Sized f 1 a

-- | Consruct the <a>Sized</a> sequence from base type, but the length
--   parameter is dynamically determined and existentially quantified; see
--   also <a>SomeSized</a>.
--   
--   Since 0.1.0.0
toSomeSized :: forall nat f a. (HasOrdinal nat, ListLike (f a) a) => f a -> SomeSized f nat a

-- | Replicates the same value.
--   
--   Since 0.1.0.0
replicate :: forall f (n :: nat) a. (HasOrdinal nat, ListLike (f a) a) => Sing n -> a -> Sized f n a

-- | <a>replicate</a> with the length inferred.
--   
--   Since 0.1.0.0
replicate' :: (HasOrdinal nat, SingI (n :: nat), ListLike (f a) a) => a -> Sized f n a
generate :: forall (nat :: Type) (n :: nat) (a :: Type) f. (ListLike (f a) a, HasOrdinal nat) => Sing n -> (Ordinal n -> a) -> Sized f n a

-- | Append an element to the head of sequence.
--   
--   Since 0.1.0.0
cons :: (ListLike (f a) b) => b -> Sized f n a -> Sized f (Succ n) a

-- | Infix version of <a>cons</a>.
--   
--   Since 0.1.0.0
(<|) :: (ListLike (f a) b) => b -> Sized f n a -> Sized f (Succ n) a
infixr 5 <|

-- | Append an element to the tail of sequence.
--   
--   Since 0.1.0.0
snoc :: (ListLike (f a) b) => Sized f n a -> b -> Sized f (Succ n) a

-- | Infix version of <a>snoc</a>.
--   
--   Since 0.1.0.0
(|>) :: (ListLike (f a) b) => Sized f n a -> b -> Sized f (Succ n) a
infixl 5 |>

-- | Append two lists.
--   
--   Since 0.1.0.0
append :: ListLike (f a) a => Sized f n a -> Sized f m a -> Sized f (n :+ m) a

-- | Infix version of <a>append</a>.
--   
--   Since 0.1.0.0
(++) :: (ListLike (f a) a) => Sized f n a -> Sized f m a -> Sized f (n :+ m) a
infixr 5 ++

-- | Concatenates multiple sequences into one.
--   
--   Since 0.1.0.0
concat :: forall f f' m n a. (Functor f', Foldable f', ListLike (f a) a) => Sized f' m (Sized f n a) -> Sized f (m :* n) a

-- | Zipping two sequences. Length is adjusted to shorter one.
--   
--   Since 0.1.0.0
zip :: (ListLike (f a) a, ListLike (f b) b, ListLike (f (a, b)) (a, b)) => Sized f n a -> Sized f m b -> Sized f (Min n m) (a, b)

-- | <a>zip</a> for the sequences of the same length.
--   
--   Since 0.1.0.0
zipSame :: (ListLike (f a) a, ListLike (f b) b, ListLike (f (a, b)) (a, b)) => Sized f n a -> Sized f n b -> Sized f n (a, b)

-- | Zipping two sequences with funtion. Length is adjusted to shorter one.
--   
--   Since 0.1.0.0
zipWith :: (ListLike (f a) a, ListLike (f b) b, ListLike (f c) c) => (a -> b -> c) -> Sized f n a -> Sized f m b -> Sized f (Min n m) c

-- | <a>zipWith</a> for the sequences of the same length.
--   
--   Since 0.1.0.0
zipWithSame :: (ListLike (f a) a, ListLike (f b) b, ListLike (f c) c) => (a -> b -> c) -> Sized f n a -> Sized f n b -> Sized f n c

-- | Unzipping the sequence of tuples.
--   
--   Since 0.1.0.0
unzip :: (ListLike (f a) a, ListLike (f b) b, ListLike (f (a, b)) (a, b)) => Sized f n (a, b) -> (Sized f n a, Sized f n b)

-- | Map function.
--   
--   Since 0.1.0.0
map :: (ListLike (f a) a, ListLike (f b) b) => (a -> b) -> Sized f n a -> Sized f n b
fmap :: forall f n a b. Functor f => (a -> b) -> Sized f n a -> Sized f n b

-- | Reverse function.
--   
--   Since 0.1.0.0
reverse :: ListLike (f a) a => Sized f n a -> Sized f n a

-- | Intersperces.
--   
--   Since 0.1.0.0
intersperse :: ListLike (f a) a => a -> Sized f n a -> Sized f ((FromInteger 2 :* n) :-. 1) a

-- | Remove all duplicates.
--   
--   Since 0.1.0.0
nub :: (HasOrdinal nat, ListLike (f a) a, Eq a) => Sized f n a -> SomeSized f nat a

-- | Sorting sequence by ascending order.
--   
--   Since 0.1.0.0
sort :: (ListLike (f a) a, Ord a) => Sized f n a -> Sized f n a

-- | Generalized version of <a>sort</a>.
--   
--   Since 0.1.0.0
sortBy :: (ListLike (f a) a) => (a -> a -> Ordering) -> Sized f n a -> Sized f n a

-- | Insert new element into the presorted sequence.
--   
--   Since 0.1.0.0
insert :: (ListLike (f a) a, Ord a) => a -> Sized f n a -> Sized f (Succ n) a

-- | Generalized version of <a>insert</a>.
--   
--   Since 0.1.0.0
insertBy :: (ListLike (f a) a) => (a -> a -> Ordering) -> a -> Sized f n a -> Sized f (Succ n) a

-- | Convert to list.
--   
--   Since 0.1.0.0
toList :: ListLike (f a) a => Sized f n a -> [a]

-- | If the given list is shorter than <tt>n</tt>, then returns
--   <tt>Nothing</tt> Otherwise returns <tt>Sized f n a</tt> consisting of
--   initial <tt>n</tt> element of given list.
--   
--   Since 0.1.0.0
fromList :: forall f n a. (HasOrdinal nat, ListLike (f a) a) => Sing (n :: nat) -> [a] -> Maybe (Sized f n a)

-- | <a>fromList</a> with the result length inferred.
--   
--   Since 0.1.0.0
fromList' :: (ListLike (f a) a, SingI (n :: Nat)) => [a] -> Maybe (Sized f n a)

-- | Unsafe version of <a>fromList</a>. If the length of the given list
--   does not equal to <tt>n</tt>, then something unusual happens.
--   
--   Since 0.1.0.0
unsafeFromList :: forall (nat :: Type) f (n :: nat) a. ListLike (f a) a => Sing n -> [a] -> Sized f n a

-- | <a>unsafeFromList</a> with the result length inferred.
--   
--   Since 0.1.0.0
unsafeFromList' :: (SingI (n :: Nat), ListLike (f a) a) => [a] -> Sized f n a

-- | Construct a <tt>Sized f n a</tt> by padding default value if the given
--   list is short.
--   
--   Since 0.1.0.0
fromListWithDefault :: forall f (n :: nat) a. (HasOrdinal nat, ListLike (f a) a) => Sing n -> a -> [a] -> Sized f n a

-- | <a>fromListWithDefault</a> with the result length inferred.
--   
--   Since 0.1.0.0
fromListWithDefault' :: (SingI (n :: Nat), ListLike (f a) a) => a -> [a] -> Sized f n a

-- | Forget the length and obtain the wrapped base container.
--   
--   Since 0.1.0.0
unsized :: Sized f n a -> f a

-- | If the length of the input is shorter than <tt>n</tt>, then returns
--   <tt>Nothing</tt>. Otherwise returns <tt>Sized f n a</tt> consisting of
--   initial <tt>n</tt> element of the input.
--   
--   Since 0.1.0.0
toSized :: (HasOrdinal nat, ListLike (f a) a) => Sing (n :: nat) -> f a -> Maybe (Sized f n a)

-- | <a>toSized</a> with the result length inferred.
--   
--   Since 0.1.0.0
toSized' :: (ListLike (f a) a, SingI (n :: Nat)) => f a -> Maybe (Sized f n a)

-- | Unsafe version of <a>toSized</a>. If the length of the given list does
--   not equal to <tt>n</tt>, then something unusual happens.
--   
--   Since 0.1.0.0
unsafeToSized :: Sing n -> f a -> Sized f n a

-- | <a>unsafeToSized</a> with the result length inferred.
--   
--   Since 0.1.0.0
unsafeToSized' :: (SingI (n :: Nat), ListLike (f a) a) => f a -> Sized f n a

-- | Construct a <tt>Sized f n a</tt> by padding default value if the given
--   list is short.
--   
--   Since 0.1.0.0
toSizedWithDefault :: (HasOrdinal nat, ListLike (f a) a) => Sing (n :: nat) -> a -> f a -> Sized f n a

-- | <a>toSizedWithDefault</a> with the result length inferred.
--   
--   Since 0.1.0.0
toSizedWithDefault' :: (SingI (n :: Nat), ListLike (f a) a) => a -> f a -> Sized f n a

-- | The type <tt>Partitioned f n a</tt> represents partitioned sequence of
--   length <tt>n</tt>. Value <tt>Partitioned lenL ls lenR rs</tt> stands
--   for:
--   
--   <ul>
--   <li>Entire sequence is divided into <tt>ls</tt> and <tt>rs</tt>, and
--   their length are <tt>lenL</tt> and <tt>lenR</tt> resp.</li>
--   <li><pre>lenL + lenR = n</pre></li>
--   </ul>
--   
--   Since 0.1.0.0
data Partitioned f n a
[Partitioned] :: (ListLike (f a) a) => Sing n -> Sized f (n :: Nat) a -> Sing m -> Sized f (m :: Nat) a -> Partitioned f (n :+ m) a

-- | Take the initial segment as long as elements satisfys the predicate.
--   
--   Since 0.1.0.0
takeWhile :: (HasOrdinal nat, ListLike (f a) a) => (a -> Bool) -> Sized f n a -> SomeSized f nat a

-- | Drop the initial segment as long as elements satisfys the predicate.
--   
--   Since 0.1.0.0
dropWhile :: (HasOrdinal nat, ListLike (f a) a) => (a -> Bool) -> Sized f n a -> SomeSized f nat a

-- | Invariant: <tt><a>ListLike</a> (f a) a</tt> instance must be
--   implemented to satisfy the following property: <tt>length (fst (span p
--   xs)) + length (snd (span p xs)) == length xs</tt> Otherwise, this
--   function introduces severe contradiction.
--   
--   Since 0.1.0.0
span :: ListLike (f a) a => (a -> Bool) -> Sized f n a -> Partitioned f n a

-- | Invariant: <tt><a>ListLike</a> (f a) a</tt> instance must be
--   implemented to satisfy the following property: <tt>length (fst (break
--   p xs)) + length (snd (break p xs)) == length xs</tt> Otherwise, this
--   function introduces severe contradiction.
--   
--   Since 0.1.0.0
break :: ListLike (f a) a => (a -> Bool) -> Sized f n a -> Partitioned f n a

-- | Invariant: <tt><a>ListLike</a> (f a) a</tt> instance must be
--   implemented to satisfy the following property: <tt>length (fst
--   (partition p xs)) + length (snd (partition p xs)) == length xs</tt>
--   Otherwise, this function introduces severe contradiction.
--   
--   Since 0.1.0.0
partition :: ListLike (f a) a => (a -> Bool) -> Sized f n a -> Partitioned f n a

-- | Membership test; see also <a>notElem</a>.
--   
--   Since 0.1.0.0
elem :: (ListLike (f a) a, Eq a) => a -> Sized f n a -> Bool

-- | Negation of <a>elem</a>.
--   
--   Since 0.1.0.0
notElem :: (ListLike (f a) a, Eq a) => a -> Sized f n a -> Bool

-- | Find the element satisfying the predicate.
--   
--   Since 0.1.0.0
find :: Foldable f => (a -> Bool) -> Sized f n a -> Maybe a

-- | <tt><a>Foldable</a></tt> version of <tt><a>find</a></tt>.
findF :: (Foldable f) => (a -> Bool) -> Sized f n a -> Maybe a

-- | <tt><a>findIndex</a> p xs</tt> find the element satisfying <tt>p</tt>
--   and returns its index if exists.
--   
--   Since 0.1.0.0
findIndex :: ListLike (f a) a => (a -> Bool) -> Sized f n a -> Maybe Int

-- | <tt><a>findIndex</a></tt> implemented in terms of
--   <tt><a>FoldableWithIndex</a></tt>
findIndexIF :: (FoldableWithIndex i f) => (a -> Bool) -> Sized f n a -> Maybe i

-- | <a>Ordinal</a> version of <a>findIndex</a>.
--   
--   Since 0.1.0.0
sFindIndex :: (SingI (n :: nat), ListLike (f a) a, HasOrdinal nat) => (a -> Bool) -> Sized f n a -> Maybe (Ordinal n)

-- | <tt><a>sFindIndex</a></tt> implemented in terms of
--   <tt><a>FoldableWithIndex</a></tt>
sFindIndexIF :: (FoldableWithIndex i f, Integral i, HasOrdinal nat, SingI n) => (a -> Bool) -> Sized f (n :: nat) a -> Maybe (Ordinal n)

-- | <tt><a>findIndices</a> p xs</tt> find all elements satisfying
--   <tt>p</tt> and returns their indices.
--   
--   Since 0.1.0.0
findIndices :: ListLike (f a) a => (a -> Bool) -> Sized f n a -> [Int]

-- | <tt><a>findIndices</a></tt> implemented in terms of
--   <tt><a>FoldableWithIndex</a></tt>
findIndicesIF :: (FoldableWithIndex i f) => (a -> Bool) -> Sized f n a -> [i]

-- | <a>Ordinal</a> version of <a>findIndices</a>.
--   
--   Since 0.1.0.0
sFindIndices :: (HasOrdinal nat, SingI (n :: nat), ListLike (f a) a) => (a -> Bool) -> Sized f n a -> [Ordinal n]
sFindIndicesIF :: (FoldableWithIndex i f, Integral i, HasOrdinal nat, SingI n) => (a -> Bool) -> Sized f (n :: nat) a -> [Ordinal n]

-- | Returns the index of the given element in the list, if exists.
--   
--   Since 0.1.0.0
elemIndex :: (Eq a, ListLike (f a) a) => a -> Sized f n a -> Maybe Int

-- | Ordinal version of <a>elemIndex</a> It statically checks boundary
--   invariants. If you don't internal structure on <tt><a>Sized</a></tt>,
--   then <tt><a>sUnsafeElemIndex</a></tt> is much faster and also safe for
--   most cases.
--   
--   Since 0.1.0.0
sElemIndex :: forall (n :: nat) f a. (SingI n, ListLike (f a) a, Eq a, HasOrdinal nat) => a -> Sized f n a -> Maybe (Ordinal n)
sUnsafeElemIndex :: forall (n :: nat) f a. (SingI n, ListLike (f a) a, Eq a, HasOrdinal nat) => a -> Sized f n a -> Maybe (Ordinal n)

-- | Returns all indices of the given element in the list.
--   
--   Since 0.1.0.0
elemIndices :: (ListLike (f a) a, Eq a) => a -> Sized f n a -> [Int]

-- | Ordinal version of <a>elemIndices</a>
--   
--   Since 0.1.0.0
sElemIndices :: (HasOrdinal nat, SingI (n :: nat), ListLike (f a) a, Eq a) => a -> Sized f n a -> [Ordinal n]

-- | Case analysis for the cons-side of sequence.
--   
--   Since 0.1.0.0
viewCons :: forall f a (n :: nat). (HasOrdinal nat, ListLike (f a) a) => Sized f n a -> ConsView f n a

-- | View of the left end of sequence (cons-side).
--   
--   Since 0.1.0.0
data ConsView f n a
[NilCV] :: ConsView f (Zero nat) a
[::-] :: SingI n => a -> Sized f n a -> ConsView f (Succ n) a

-- | Case analysis for the snoc-side of sequence.
--   
--   Since 0.1.0.0
viewSnoc :: forall f (n :: nat) a. (HasOrdinal nat, ListLike (f a) a) => Sized f n a -> SnocView f n a

-- | View of the left end of sequence (snoc-side).
--   
--   Since 0.1.0.0
data SnocView f n a
[NilSV] :: SnocView f (Zero nat) a
[:-::] :: SingI n => Sized f n a -> a -> SnocView f (Succ n) a

-- | Pattern synonym for cons-side uncons.
infixr 5 :<
infixl 5 :>
instance GHC.Show.Show (f a) => GHC.Show.Show (Data.Sized.SomeSized f nat a)
instance GHC.Classes.Eq (f a) => GHC.Classes.Eq (Data.Sized.SomeSized f nat a)
instance forall k (nat :: k) (f :: * -> *) nat1 (n :: nat1). (GHC.Base.Functor f, Data.Type.Ordinal.HasOrdinal nat1, Data.Singletons.SingI n, Data.Sized.Internal.ListLikeF f) => GHC.Base.Applicative (Data.Sized.Internal.Sized f n)


-- | This module exports <tt><a>Sized</a></tt> type specialized to GHC's
--   built-in type numeral <tt><a>Nat</a></tt>.
module Data.Sized.Builtin
type Ordinal (n :: Nat) = Ordinal n
type Sized f (n :: Nat) = Sized f n
infixr 5 :<
infixl 5 :>

module Data.Sized.Flipped

-- | Wrapper for <tt><a>Sized</a></tt> which takes length as its last
--   element, instead of the second.
--   
--   Since 0.2.0.0
newtype Flipped f a n
Flipped :: Sized f n a -> Flipped f a n
[runFlipped] :: Flipped f a n -> Sized f n a
instance forall (f :: GHC.Types.Type -> *) a nat (n :: nat). Data.MonoTraversable.MonoFunctor (f a) => Data.MonoTraversable.MonoFunctor (Data.Sized.Flipped.Flipped f a n)
instance forall (f :: GHC.Types.Type -> *) a nat (n :: nat). Data.MonoTraversable.MonoFoldable (f a) => Data.MonoTraversable.MonoFoldable (Data.Sized.Flipped.Flipped f a n)
instance forall nat nat1 (f0 :: GHC.Types.Type -> GHC.Types.Type) a0 (n0 :: nat1) t0 (f1 :: GHC.Types.Type -> GHC.Types.Type) a1 (n1 :: nat). Data.Sized.Flipped.Flipped f0 a0 n0 ~ t0 => Control.Lens.Wrapped.Rewrapped (Data.Sized.Flipped.Flipped f1 a1 n1) t0
instance forall nat (f0 :: GHC.Types.Type -> GHC.Types.Type) a0 (n0 :: nat). Control.Lens.Wrapped.Wrapped (Data.Sized.Flipped.Flipped f0 a0 n0)
instance forall nat (f :: GHC.Types.Type -> *) a (n :: nat). Data.MonoTraversable.MonoTraversable (f a) => Data.MonoTraversable.MonoTraversable (Data.Sized.Flipped.Flipped f a n)
instance forall k (nat :: k) (f :: GHC.Types.Type -> GHC.Types.*) a nat1 (n :: nat1). (GHC.Real.Integral (Control.Lens.At.Index (f a)), Control.Lens.At.Ixed (f a), Data.Type.Ordinal.HasOrdinal nat1) => Control.Lens.At.Ixed (Data.Sized.Flipped.Flipped f a n)
instance forall (f :: GHC.Types.Type -> GHC.Types.Type) a nat (n :: nat). Data.Hashable.Class.Hashable (f a) => Data.Hashable.Class.Hashable (Data.Sized.Flipped.Flipped f a n)
instance forall (f :: GHC.Types.Type -> GHC.Types.Type) a nat (n :: nat). Control.DeepSeq.NFData (f a) => Control.DeepSeq.NFData (Data.Sized.Flipped.Flipped f a n)
instance forall (f :: GHC.Types.Type -> GHC.Types.Type) a nat (n :: nat). GHC.Classes.Ord (f a) => GHC.Classes.Ord (Data.Sized.Flipped.Flipped f a n)
instance forall (f :: GHC.Types.Type -> GHC.Types.Type) a nat (n :: nat). GHC.Classes.Eq (f a) => GHC.Classes.Eq (Data.Sized.Flipped.Flipped f a n)
instance forall (f :: GHC.Types.Type -> GHC.Types.Type) a nat (n :: nat). GHC.Show.Show (f a) => GHC.Show.Show (Data.Sized.Flipped.Flipped f a n)


-- | This module exports <tt><a>Sized</a></tt> type specialized to
--   type-level Peano numeral <tt><a>Nat</a></tt>.
module Data.Sized.Peano
type Ordinal (n :: Nat) = Ordinal n
type Sized f (n :: Nat) = Sized f n
infixr 5 :<
infixl 5 :>