{-# LANGUAGE CPP, ConstraintKinds, DataKinds, DeriveDataTypeable           #-}
{-# LANGUAGE DeriveFunctor, DeriveTraversable, DerivingStrategies          #-}
{-# LANGUAGE ExplicitNamespaces, FlexibleContexts, FlexibleInstances       #-}
{-# LANGUAGE GeneralizedNewtypeDeriving, KindSignatures                    #-}
{-# LANGUAGE LiberalTypeSynonyms, MultiParamTypeClasses, PolyKinds         #-}
{-# LANGUAGE RankNTypes, ScopedTypeVariables, StandaloneDeriving           #-}
{-# LANGUAGE TypeFamilies, TypeInType, TypeOperators, UndecidableInstances #-}
#if __GLASGOW_HASKELL__ && __GLASGOW_HASKELL__ >= 806
{-# LANGUAGE NoStarIsType #-}
#endif
{-# OPTIONS_GHC -fno-warn-orphans #-}
module Data.Sized.Internal (Sized(..)) where
import           Control.DeepSeq      (NFData (..))
import           Control.Lens.At      (Index, IxValue, Ixed (..))
import           Control.Lens.Indexed (FoldableWithIndex (..),
                                       FunctorWithIndex (..),
                                       TraversableWithIndex (..))
import           Control.Subcategory  (CFoldable, CFunctor, Constrained)
import           Data.Hashable        (Hashable (..))
import           Data.Kind            (Type)
import           Data.MonoTraversable (Element, MonoFoldable (..),
                                       MonoFunctor (..), MonoTraversable (..))
import qualified Data.Sequence        as Seq
import           Data.Type.Ordinal    (Ordinal (..), ordToNatural,
                                       unsafeNaturalToOrd)
import           Data.Typeable        (Typeable)
import qualified Data.Vector          as V
import qualified Data.Vector.Storable as SV
import qualified Data.Vector.Unboxed  as UV
import           GHC.TypeNats

-- | @Sized@ wraps a sequential type 'f' and makes length-parametrized version.
--
-- Here, 'f' must be the instance of 'CFreeMonoid' (f a) a@ for all @a@.
--
-- Since 0.2.0.0
newtype Sized (f :: Type -> Type) (n :: Nat) a =
  Sized { forall (f :: Type -> Type) (n :: Nat) a. Sized f n a -> f a
runSized :: f a
        } deriving (Sized f n a -> Sized f n a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (f :: Type -> Type) (n :: Nat) a.
Eq (f a) =>
Sized f n a -> Sized f n a -> Bool
/= :: Sized f n a -> Sized f n a -> Bool
$c/= :: forall (f :: Type -> Type) (n :: Nat) a.
Eq (f a) =>
Sized f n a -> Sized f n a -> Bool
== :: Sized f n a -> Sized f n a -> Bool
$c== :: forall (f :: Type -> Type) (n :: Nat) a.
Eq (f a) =>
Sized f n a -> Sized f n a -> Bool
Eq, Sized f n a -> Sized f n a -> Bool
Sized f n a -> Sized f n a -> Ordering
Sized f n a -> Sized f n a -> Sized f n a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {f :: Type -> Type} {n :: Nat} {a}.
Ord (f a) =>
Eq (Sized f n a)
forall (f :: Type -> Type) (n :: Nat) a.
Ord (f a) =>
Sized f n a -> Sized f n a -> Bool
forall (f :: Type -> Type) (n :: Nat) a.
Ord (f a) =>
Sized f n a -> Sized f n a -> Ordering
forall (f :: Type -> Type) (n :: Nat) a.
Ord (f a) =>
Sized f n a -> Sized f n a -> Sized f n a
min :: Sized f n a -> Sized f n a -> Sized f n a
$cmin :: forall (f :: Type -> Type) (n :: Nat) a.
Ord (f a) =>
Sized f n a -> Sized f n a -> Sized f n a
max :: Sized f n a -> Sized f n a -> Sized f n a
$cmax :: forall (f :: Type -> Type) (n :: Nat) a.
Ord (f a) =>
Sized f n a -> Sized f n a -> Sized f n a
>= :: Sized f n a -> Sized f n a -> Bool
$c>= :: forall (f :: Type -> Type) (n :: Nat) a.
Ord (f a) =>
Sized f n a -> Sized f n a -> Bool
> :: Sized f n a -> Sized f n a -> Bool
$c> :: forall (f :: Type -> Type) (n :: Nat) a.
Ord (f a) =>
Sized f n a -> Sized f n a -> Bool
<= :: Sized f n a -> Sized f n a -> Bool
$c<= :: forall (f :: Type -> Type) (n :: Nat) a.
Ord (f a) =>
Sized f n a -> Sized f n a -> Bool
< :: Sized f n a -> Sized f n a -> Bool
$c< :: forall (f :: Type -> Type) (n :: Nat) a.
Ord (f a) =>
Sized f n a -> Sized f n a -> Bool
compare :: Sized f n a -> Sized f n a -> Ordering
$ccompare :: forall (f :: Type -> Type) (n :: Nat) a.
Ord (f a) =>
Sized f n a -> Sized f n a -> Ordering
Ord, Typeable,
                    forall a b. a -> Sized f n b -> Sized f n a
forall a b. (a -> b) -> Sized f n a -> Sized f n b
forall (f :: Type -> Type).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
forall (f :: Type -> Type) (n :: Nat) a b.
Functor f =>
a -> Sized f n b -> Sized f n a
forall (f :: Type -> Type) (n :: Nat) a b.
Functor f =>
(a -> b) -> Sized f n a -> Sized f n b
<$ :: forall a b. a -> Sized f n b -> Sized f n a
$c<$ :: forall (f :: Type -> Type) (n :: Nat) a b.
Functor f =>
a -> Sized f n b -> Sized f n a
fmap :: forall a b. (a -> b) -> Sized f n a -> Sized f n b
$cfmap :: forall (f :: Type -> Type) (n :: Nat) a b.
Functor f =>
(a -> b) -> Sized f n a -> Sized f n b
Functor, forall a. Eq a => a -> Sized f n a -> Bool
forall a. Num a => Sized f n a -> a
forall a. Ord a => Sized f n a -> a
forall m. Monoid m => Sized f n m -> m
forall a. Sized f n a -> Bool
forall a. Sized f n a -> Int
forall a. Sized f n a -> [a]
forall a. (a -> a -> a) -> Sized f n a -> a
forall m a. Monoid m => (a -> m) -> Sized f n a -> m
forall b a. (b -> a -> b) -> b -> Sized f n a -> b
forall a b. (a -> b -> b) -> b -> Sized f n a -> b
forall (t :: Type -> Type).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
forall (f :: Type -> Type) (n :: Nat) a.
(Foldable f, Eq a) =>
a -> Sized f n a -> Bool
forall (f :: Type -> Type) (n :: Nat) a.
(Foldable f, Num a) =>
Sized f n a -> a
forall (f :: Type -> Type) (n :: Nat) a.
(Foldable f, Ord a) =>
Sized f n a -> a
forall (f :: Type -> Type) (n :: Nat) m.
(Foldable f, Monoid m) =>
Sized f n m -> m
forall (f :: Type -> Type) (n :: Nat) a.
Foldable f =>
Sized f n a -> Bool
forall (f :: Type -> Type) (n :: Nat) a.
Foldable f =>
Sized f n a -> Int
forall (f :: Type -> Type) (n :: Nat) a.
Foldable f =>
Sized f n a -> [a]
forall (f :: Type -> Type) (n :: Nat) a.
Foldable f =>
(a -> a -> a) -> Sized f n a -> a
forall (f :: Type -> Type) (n :: Nat) m a.
(Foldable f, Monoid m) =>
(a -> m) -> Sized f n a -> m
forall (f :: Type -> Type) (n :: Nat) b a.
Foldable f =>
(b -> a -> b) -> b -> Sized f n a -> b
forall (f :: Type -> Type) (n :: Nat) a b.
Foldable f =>
(a -> b -> b) -> b -> Sized f n a -> b
product :: forall a. Num a => Sized f n a -> a
$cproduct :: forall (f :: Type -> Type) (n :: Nat) a.
(Foldable f, Num a) =>
Sized f n a -> a
sum :: forall a. Num a => Sized f n a -> a
$csum :: forall (f :: Type -> Type) (n :: Nat) a.
(Foldable f, Num a) =>
Sized f n a -> a
minimum :: forall a. Ord a => Sized f n a -> a
$cminimum :: forall (f :: Type -> Type) (n :: Nat) a.
(Foldable f, Ord a) =>
Sized f n a -> a
maximum :: forall a. Ord a => Sized f n a -> a
$cmaximum :: forall (f :: Type -> Type) (n :: Nat) a.
(Foldable f, Ord a) =>
Sized f n a -> a
elem :: forall a. Eq a => a -> Sized f n a -> Bool
$celem :: forall (f :: Type -> Type) (n :: Nat) a.
(Foldable f, Eq a) =>
a -> Sized f n a -> Bool
length :: forall a. Sized f n a -> Int
$clength :: forall (f :: Type -> Type) (n :: Nat) a.
Foldable f =>
Sized f n a -> Int
null :: forall a. Sized f n a -> Bool
$cnull :: forall (f :: Type -> Type) (n :: Nat) a.
Foldable f =>
Sized f n a -> Bool
toList :: forall a. Sized f n a -> [a]
$ctoList :: forall (f :: Type -> Type) (n :: Nat) a.
Foldable f =>
Sized f n a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Sized f n a -> a
$cfoldl1 :: forall (f :: Type -> Type) (n :: Nat) a.
Foldable f =>
(a -> a -> a) -> Sized f n a -> a
foldr1 :: forall a. (a -> a -> a) -> Sized f n a -> a
$cfoldr1 :: forall (f :: Type -> Type) (n :: Nat) a.
Foldable f =>
(a -> a -> a) -> Sized f n a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Sized f n a -> b
$cfoldl' :: forall (f :: Type -> Type) (n :: Nat) b a.
Foldable f =>
(b -> a -> b) -> b -> Sized f n a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Sized f n a -> b
$cfoldl :: forall (f :: Type -> Type) (n :: Nat) b a.
Foldable f =>
(b -> a -> b) -> b -> Sized f n a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Sized f n a -> b
$cfoldr' :: forall (f :: Type -> Type) (n :: Nat) a b.
Foldable f =>
(a -> b -> b) -> b -> Sized f n a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Sized f n a -> b
$cfoldr :: forall (f :: Type -> Type) (n :: Nat) a b.
Foldable f =>
(a -> b -> b) -> b -> Sized f n a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Sized f n a -> m
$cfoldMap' :: forall (f :: Type -> Type) (n :: Nat) m a.
(Foldable f, Monoid m) =>
(a -> m) -> Sized f n a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Sized f n a -> m
$cfoldMap :: forall (f :: Type -> Type) (n :: Nat) m a.
(Foldable f, Monoid m) =>
(a -> m) -> Sized f n a -> m
fold :: forall m. Monoid m => Sized f n m -> m
$cfold :: forall (f :: Type -> Type) (n :: Nat) m.
(Foldable f, Monoid m) =>
Sized f n m -> m
Foldable, forall (t :: Type -> Type).
Functor t
-> Foldable t
-> (forall (f :: Type -> Type) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: Type -> Type) a.
    Applicative f =>
    t (f a) -> f (t a))
-> (forall (m :: Type -> Type) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: Type -> Type) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall {f :: Type -> Type} {n :: Nat}.
Traversable f =>
Functor (Sized f n)
forall {f :: Type -> Type} {n :: Nat}.
Traversable f =>
Foldable (Sized f n)
forall (f :: Type -> Type) (n :: Nat) (m :: Type -> Type) a.
(Traversable f, Monad m) =>
Sized f n (m a) -> m (Sized f n a)
forall (f :: Type -> Type) (n :: Nat) (f :: Type -> Type) a.
(Traversable f, Applicative f) =>
Sized f n (f a) -> f (Sized f n a)
forall (f :: Type -> Type) (n :: Nat) (m :: Type -> Type) a b.
(Traversable f, Monad m) =>
(a -> m b) -> Sized f n a -> m (Sized f n b)
forall (f :: Type -> Type) (n :: Nat) (f :: Type -> Type) a b.
(Traversable f, Applicative f) =>
(a -> f b) -> Sized f n a -> f (Sized f n b)
forall (f :: Type -> Type) a b.
Applicative f =>
(a -> f b) -> Sized f n a -> f (Sized f n b)
sequence :: forall (m :: Type -> Type) a.
Monad m =>
Sized f n (m a) -> m (Sized f n a)
$csequence :: forall (f :: Type -> Type) (n :: Nat) (m :: Type -> Type) a.
(Traversable f, Monad m) =>
Sized f n (m a) -> m (Sized f n a)
mapM :: forall (m :: Type -> Type) a b.
Monad m =>
(a -> m b) -> Sized f n a -> m (Sized f n b)
$cmapM :: forall (f :: Type -> Type) (n :: Nat) (m :: Type -> Type) a b.
(Traversable f, Monad m) =>
(a -> m b) -> Sized f n a -> m (Sized f n b)
sequenceA :: forall (f :: Type -> Type) a.
Applicative f =>
Sized f n (f a) -> f (Sized f n a)
$csequenceA :: forall (f :: Type -> Type) (n :: Nat) (f :: Type -> Type) a.
(Traversable f, Applicative f) =>
Sized f n (f a) -> f (Sized f n a)
traverse :: forall (f :: Type -> Type) a b.
Applicative f =>
(a -> f b) -> Sized f n a -> f (Sized f n b)
$ctraverse :: forall (f :: Type -> Type) (n :: Nat) (f :: Type -> Type) a b.
(Traversable f, Applicative f) =>
(a -> f b) -> Sized f n a -> f (Sized f n b)
Traversable)
          deriving newtype
                (forall (f :: Type -> Type). Constrained f
Constrained, forall a. (Eq a, Dom (Sized f n) a) => a -> Sized f n a -> Bool
forall a. (Num a, Dom (Sized f n) a) => Sized f n a -> a
forall a. (Ord a, Dom (Sized f n) a) => Sized f n a -> a
forall a. (Dom (Sized f n) a, Eq a) => a -> Sized f n a -> [Int]
forall a.
(Dom (Sized f n) a, Eq a) =>
a -> Sized f n a -> Maybe Int
forall w. (Dom (Sized f n) w, Monoid w) => Sized f n w -> w
forall a. Dom (Sized f n) a => Sized f n a -> a
forall a. Dom (Sized f n) a => Sized f n a -> Bool
forall a. Dom (Sized f n) a => Sized f n a -> Int
forall a. Dom (Sized f n) a => Sized f n a -> [a]
forall a. Dom (Sized f n) a => Sized f n a -> Int -> a
forall a. Dom (Sized f n) a => (a -> Bool) -> Sized f n a -> Bool
forall a. Dom (Sized f n) a => (a -> Bool) -> Sized f n a -> [Int]
forall a.
Dom (Sized f n) a =>
(a -> Bool) -> Sized f n a -> Maybe a
forall a.
Dom (Sized f n) a =>
(a -> Bool) -> Sized f n a -> Maybe Int
forall a. Dom (Sized f n) a => (a -> a -> a) -> Sized f n a -> a
forall a m.
(Dom (Sized f n) a, Monoid m) =>
(a -> m) -> Sized f n a -> m
forall a b.
Dom (Sized f n) a =>
(a -> b -> b) -> b -> Sized f n a -> b
forall a b.
Dom (Sized f n) a =>
(b -> a -> b) -> b -> Sized f n a -> b
forall (f :: Type -> Type).
Constrained f
-> (forall a w. (Dom f a, Monoid w) => (a -> w) -> f a -> w)
-> (forall a w. (Dom f a, Monoid w) => (a -> w) -> f a -> w)
-> (forall w. (Dom f w, Monoid w) => f w -> w)
-> (forall a b. Dom f a => (a -> b -> b) -> b -> f a -> b)
-> (forall (m :: Type -> Type) b a.
    (Monad m, Dom f b) =>
    (a -> b -> m a) -> a -> f b -> m a)
-> (forall (m :: Type -> Type) b a.
    (Monad m, Dom f b) =>
    (a -> b -> m a) -> a -> f b -> m a)
-> (forall (m :: Type -> Type) a b.
    (Monad m, Dom f a) =>
    (a -> b -> m b) -> b -> f a -> m b)
-> (forall (m :: Type -> Type) a b.
    (Monad m, Dom f a) =>
    (a -> b -> m b) -> b -> f a -> m b)
-> (forall a b. Dom f a => (b -> a -> b) -> b -> f a -> b)
-> (forall a b. Dom f a => (a -> b -> b) -> b -> f a -> b)
-> (forall a b. Dom f a => (b -> a -> b) -> b -> f a -> b)
-> (forall a. Dom f a => f a -> [a])
-> (forall a. Dom f a => (a -> a -> a) -> f a -> a)
-> (forall a. Dom f a => (a -> a -> a) -> f a -> a)
-> (forall a. Dom f a => f a -> Int -> a)
-> (forall a. Dom f a => f a -> Bool)
-> (forall a. Dom f a => f a -> Int)
-> (forall a. Dom f a => (a -> Bool) -> f a -> Bool)
-> (forall a. Dom f a => (a -> Bool) -> f a -> Bool)
-> (forall a. (Eq a, Dom f a) => a -> f a -> Bool)
-> (forall a. (Eq a, Dom f a) => a -> f a -> Bool)
-> (forall a. (Ord a, Dom f a) => f a -> a)
-> (forall a. (Ord a, Dom f a) => f a -> a)
-> (forall a. (Num a, Dom f a) => f a -> a)
-> (forall a. (Num a, Dom f a) => f a -> a)
-> (forall (g :: Type -> Type) a b.
    (CApplicative g, CPointed g, Dom g (), Dom f a, Dom g b) =>
    (a -> g b) -> f a -> g ())
-> (forall (g :: Type -> Type) a b.
    (Applicative g, Dom f a) =>
    (a -> g b) -> f a -> g ())
-> (forall a. Dom f a => f a -> a)
-> (forall a. Dom f a => f a -> a)
-> (forall a. Dom f a => (a -> Bool) -> f a -> Maybe a)
-> (forall a. Dom f a => (a -> Bool) -> f a -> Maybe Int)
-> (forall a. Dom f a => (a -> Bool) -> f a -> [Int])
-> (forall a. (Dom f a, Eq a) => a -> f a -> Maybe Int)
-> (forall a. (Dom f a, Eq a) => a -> f a -> [Int])
-> CFoldable f
forall {f :: Type -> Type} {n :: Nat}.
CFoldable f =>
Constrained (Sized f n)
forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Eq a, Dom (Sized f n) a) =>
a -> Sized f n a -> Bool
forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Num a, Dom (Sized f n) a) =>
Sized f n a -> a
forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Ord a, Dom (Sized f n) a) =>
Sized f n a -> a
forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a, Eq a) =>
a -> Sized f n a -> [Int]
forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a, Eq a) =>
a -> Sized f n a -> Maybe Int
forall (f :: Type -> Type) (n :: Nat) w.
(CFoldable f, Dom (Sized f n) w, Monoid w) =>
Sized f n w -> w
forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a) =>
Sized f n a -> a
forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a) =>
Sized f n a -> Bool
forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a) =>
Sized f n a -> Int
forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a) =>
Sized f n a -> [a]
forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a) =>
Sized f n a -> Int -> a
forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a) =>
(a -> Bool) -> Sized f n a -> Bool
forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a) =>
(a -> Bool) -> Sized f n a -> [Int]
forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a) =>
(a -> Bool) -> Sized f n a -> Maybe a
forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a) =>
(a -> Bool) -> Sized f n a -> Maybe Int
forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a) =>
(a -> a -> a) -> Sized f n a -> a
forall (f :: Type -> Type) (n :: Nat) a m.
(CFoldable f, Dom (Sized f n) a, Monoid m) =>
(a -> m) -> Sized f n a -> m
forall (f :: Type -> Type) (n :: Nat) a b.
(CFoldable f, Dom (Sized f n) a) =>
(a -> b -> b) -> b -> Sized f n a -> b
forall (f :: Type -> Type) (n :: Nat) a b.
(CFoldable f, Dom (Sized f n) a) =>
(b -> a -> b) -> b -> Sized f n a -> b
forall (f :: Type -> Type) (n :: Nat) (m :: Type -> Type) a b.
(CFoldable f, Monad m, Dom (Sized f n) a) =>
(a -> b -> m b) -> b -> Sized f n a -> m b
forall (f :: Type -> Type) (n :: Nat) (m :: Type -> Type) b a.
(CFoldable f, Monad m, Dom (Sized f n) b) =>
(a -> b -> m a) -> a -> Sized f n b -> m a
forall (f :: Type -> Type) (n :: Nat) (g :: Type -> Type) a b.
(CFoldable f, Applicative g, Dom (Sized f n) a) =>
(a -> g b) -> Sized f n a -> g ()
forall (f :: Type -> Type) (n :: Nat) (g :: Type -> Type) a b.
(CFoldable f, CApplicative g, CPointed g, Dom g (),
 Dom (Sized f n) a, Dom g b) =>
(a -> g b) -> Sized f n a -> g ()
forall (m :: Type -> Type) a b.
(Monad m, Dom (Sized f n) a) =>
(a -> b -> m b) -> b -> Sized f n a -> m b
forall (m :: Type -> Type) b a.
(Monad m, Dom (Sized f n) b) =>
(a -> b -> m a) -> a -> Sized f n b -> m a
forall (g :: Type -> Type) a b.
(Applicative g, Dom (Sized f n) a) =>
(a -> g b) -> Sized f n a -> g ()
forall (g :: Type -> Type) a b.
(CApplicative g, CPointed g, Dom g (), Dom (Sized f n) a,
 Dom g b) =>
(a -> g b) -> Sized f n a -> g ()
celemIndices :: forall a. (Dom (Sized f n) a, Eq a) => a -> Sized f n a -> [Int]
$ccelemIndices :: forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a, Eq a) =>
a -> Sized f n a -> [Int]
celemIndex :: forall a.
(Dom (Sized f n) a, Eq a) =>
a -> Sized f n a -> Maybe Int
$ccelemIndex :: forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a, Eq a) =>
a -> Sized f n a -> Maybe Int
cfindIndices :: forall a. Dom (Sized f n) a => (a -> Bool) -> Sized f n a -> [Int]
$ccfindIndices :: forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a) =>
(a -> Bool) -> Sized f n a -> [Int]
cfindIndex :: forall a.
Dom (Sized f n) a =>
(a -> Bool) -> Sized f n a -> Maybe Int
$ccfindIndex :: forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a) =>
(a -> Bool) -> Sized f n a -> Maybe Int
cfind :: forall a.
Dom (Sized f n) a =>
(a -> Bool) -> Sized f n a -> Maybe a
$ccfind :: forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a) =>
(a -> Bool) -> Sized f n a -> Maybe a
chead :: forall a. Dom (Sized f n) a => Sized f n a -> a
$cchead :: forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a) =>
Sized f n a -> a
clast :: forall a. Dom (Sized f n) a => Sized f n a -> a
$cclast :: forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a) =>
Sized f n a -> a
ctraverse_ :: forall (g :: Type -> Type) a b.
(Applicative g, Dom (Sized f n) a) =>
(a -> g b) -> Sized f n a -> g ()
$cctraverse_ :: forall (f :: Type -> Type) (n :: Nat) (g :: Type -> Type) a b.
(CFoldable f, Applicative g, Dom (Sized f n) a) =>
(a -> g b) -> Sized f n a -> g ()
cctraverse_ :: forall (g :: Type -> Type) a b.
(CApplicative g, CPointed g, Dom g (), Dom (Sized f n) a,
 Dom g b) =>
(a -> g b) -> Sized f n a -> g ()
$ccctraverse_ :: forall (f :: Type -> Type) (n :: Nat) (g :: Type -> Type) a b.
(CFoldable f, CApplicative g, CPointed g, Dom g (),
 Dom (Sized f n) a, Dom g b) =>
(a -> g b) -> Sized f n a -> g ()
cproduct :: forall a. (Num a, Dom (Sized f n) a) => Sized f n a -> a
$ccproduct :: forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Num a, Dom (Sized f n) a) =>
Sized f n a -> a
csum :: forall a. (Num a, Dom (Sized f n) a) => Sized f n a -> a
$ccsum :: forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Num a, Dom (Sized f n) a) =>
Sized f n a -> a
cmaximum :: forall a. (Ord a, Dom (Sized f n) a) => Sized f n a -> a
$ccmaximum :: forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Ord a, Dom (Sized f n) a) =>
Sized f n a -> a
cminimum :: forall a. (Ord a, Dom (Sized f n) a) => Sized f n a -> a
$ccminimum :: forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Ord a, Dom (Sized f n) a) =>
Sized f n a -> a
cnotElem :: forall a. (Eq a, Dom (Sized f n) a) => a -> Sized f n a -> Bool
$ccnotElem :: forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Eq a, Dom (Sized f n) a) =>
a -> Sized f n a -> Bool
celem :: forall a. (Eq a, Dom (Sized f n) a) => a -> Sized f n a -> Bool
$ccelem :: forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Eq a, Dom (Sized f n) a) =>
a -> Sized f n a -> Bool
call :: forall a. Dom (Sized f n) a => (a -> Bool) -> Sized f n a -> Bool
$ccall :: forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a) =>
(a -> Bool) -> Sized f n a -> Bool
cany :: forall a. Dom (Sized f n) a => (a -> Bool) -> Sized f n a -> Bool
$ccany :: forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a) =>
(a -> Bool) -> Sized f n a -> Bool
clength :: forall a. Dom (Sized f n) a => Sized f n a -> Int
$cclength :: forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a) =>
Sized f n a -> Int
cnull :: forall a. Dom (Sized f n) a => Sized f n a -> Bool
$ccnull :: forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a) =>
Sized f n a -> Bool
cindex :: forall a. Dom (Sized f n) a => Sized f n a -> Int -> a
$ccindex :: forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a) =>
Sized f n a -> Int -> a
cfoldl1 :: forall a. Dom (Sized f n) a => (a -> a -> a) -> Sized f n a -> a
$ccfoldl1 :: forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a) =>
(a -> a -> a) -> Sized f n a -> a
cfoldr1 :: forall a. Dom (Sized f n) a => (a -> a -> a) -> Sized f n a -> a
$ccfoldr1 :: forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a) =>
(a -> a -> a) -> Sized f n a -> a
cbasicToList :: forall a. Dom (Sized f n) a => Sized f n a -> [a]
$ccbasicToList :: forall (f :: Type -> Type) (n :: Nat) a.
(CFoldable f, Dom (Sized f n) a) =>
Sized f n a -> [a]
cfoldl' :: forall a b.
Dom (Sized f n) a =>
(b -> a -> b) -> b -> Sized f n a -> b
$ccfoldl' :: forall (f :: Type -> Type) (n :: Nat) a b.
(CFoldable f, Dom (Sized f n) a) =>
(b -> a -> b) -> b -> Sized f n a -> b
cfoldr' :: forall a b.
Dom (Sized f n) a =>
(a -> b -> b) -> b -> Sized f n a -> b
$ccfoldr' :: forall (f :: Type -> Type) (n :: Nat) a b.
(CFoldable f, Dom (Sized f n) a) =>
(a -> b -> b) -> b -> Sized f n a -> b
cfoldl :: forall a b.
Dom (Sized f n) a =>
(b -> a -> b) -> b -> Sized f n a -> b
$ccfoldl :: forall (f :: Type -> Type) (n :: Nat) a b.
(CFoldable f, Dom (Sized f n) a) =>
(b -> a -> b) -> b -> Sized f n a -> b
cfoldrM' :: forall (m :: Type -> Type) a b.
(Monad m, Dom (Sized f n) a) =>
(a -> b -> m b) -> b -> Sized f n a -> m b
$ccfoldrM' :: forall (f :: Type -> Type) (n :: Nat) (m :: Type -> Type) a b.
(CFoldable f, Monad m, Dom (Sized f n) a) =>
(a -> b -> m b) -> b -> Sized f n a -> m b
cfoldrM :: forall (m :: Type -> Type) a b.
(Monad m, Dom (Sized f n) a) =>
(a -> b -> m b) -> b -> Sized f n a -> m b
$ccfoldrM :: forall (f :: Type -> Type) (n :: Nat) (m :: Type -> Type) a b.
(CFoldable f, Monad m, Dom (Sized f n) a) =>
(a -> b -> m b) -> b -> Sized f n a -> m b
cfoldlM' :: forall (m :: Type -> Type) b a.
(Monad m, Dom (Sized f n) b) =>
(a -> b -> m a) -> a -> Sized f n b -> m a
$ccfoldlM' :: forall (f :: Type -> Type) (n :: Nat) (m :: Type -> Type) b a.
(CFoldable f, Monad m, Dom (Sized f n) b) =>
(a -> b -> m a) -> a -> Sized f n b -> m a
cfoldlM :: forall (m :: Type -> Type) b a.
(Monad m, Dom (Sized f n) b) =>
(a -> b -> m a) -> a -> Sized f n b -> m a
$ccfoldlM :: forall (f :: Type -> Type) (n :: Nat) (m :: Type -> Type) b a.
(CFoldable f, Monad m, Dom (Sized f n) b) =>
(a -> b -> m a) -> a -> Sized f n b -> m a
cfoldr :: forall a b.
Dom (Sized f n) a =>
(a -> b -> b) -> b -> Sized f n a -> b
$ccfoldr :: forall (f :: Type -> Type) (n :: Nat) a b.
(CFoldable f, Dom (Sized f n) a) =>
(a -> b -> b) -> b -> Sized f n a -> b
cfold :: forall w. (Dom (Sized f n) w, Monoid w) => Sized f n w -> w
$ccfold :: forall (f :: Type -> Type) (n :: Nat) w.
(CFoldable f, Dom (Sized f n) w, Monoid w) =>
Sized f n w -> w
cfoldMap' :: forall a m.
(Dom (Sized f n) a, Monoid m) =>
(a -> m) -> Sized f n a -> m
$ccfoldMap' :: forall (f :: Type -> Type) (n :: Nat) a m.
(CFoldable f, Dom (Sized f n) a, Monoid m) =>
(a -> m) -> Sized f n a -> m
cfoldMap :: forall a m.
(Dom (Sized f n) a, Monoid m) =>
(a -> m) -> Sized f n a -> m
$ccfoldMap :: forall (f :: Type -> Type) (n :: Nat) a m.
(CFoldable f, Dom (Sized f n) a, Monoid m) =>
(a -> m) -> Sized f n a -> m
CFoldable, forall a b.
(Dom (Sized f n) a, Dom (Sized f n) b) =>
a -> Sized f n b -> Sized f n a
forall a b.
(Dom (Sized f n) a, Dom (Sized f n) b) =>
(a -> b) -> Sized f n a -> Sized f n b
forall (f :: Type -> Type).
Constrained f
-> (forall a b. (Dom f a, Dom f b) => (a -> b) -> f a -> f b)
-> (forall a b. (Dom f a, Dom f b) => a -> f b -> f a)
-> CFunctor f
forall {f :: Type -> Type} {n :: Nat}.
CFunctor f =>
Constrained (Sized f n)
forall (f :: Type -> Type) (n :: Nat) a b.
(CFunctor f, Dom (Sized f n) a, Dom (Sized f n) b) =>
a -> Sized f n b -> Sized f n a
forall (f :: Type -> Type) (n :: Nat) a b.
(CFunctor f, Dom (Sized f n) a, Dom (Sized f n) b) =>
(a -> b) -> Sized f n a -> Sized f n b
<$: :: forall a b.
(Dom (Sized f n) a, Dom (Sized f n) b) =>
a -> Sized f n b -> Sized f n a
$c<$: :: forall (f :: Type -> Type) (n :: Nat) a b.
(CFunctor f, Dom (Sized f n) a, Dom (Sized f n) b) =>
a -> Sized f n b -> Sized f n a
cmap :: forall a b.
(Dom (Sized f n) a, Dom (Sized f n) b) =>
(a -> b) -> Sized f n a -> Sized f n b
$ccmap :: forall (f :: Type -> Type) (n :: Nat) a b.
(CFunctor f, Dom (Sized f n) a, Dom (Sized f n) b) =>
(a -> b) -> Sized f n a -> Sized f n b
CFunctor)

type instance Element (Sized f n a) = Element (f a)

-- | Since 0.2.0.0
deriving instance MonoFoldable (f a)
               => MonoFoldable (Sized f n a)

-- | Since 0.2.0.0
deriving instance MonoFunctor (f a)
               => MonoFunctor (Sized f n a)

-- | Since 0.2.0.0
instance {-# OVERLAPPABLE #-} (MonoTraversable (f a))
      => MonoTraversable (Sized f n a) where
  {-# SPECIALISE instance MonoTraversable (Sized [] n a) #-}
  {-# SPECIALISE instance MonoTraversable (Sized V.Vector n a) #-}
  {-# SPECIALISE instance MonoTraversable (Sized Seq.Seq n a) #-}
  {-# SPECIALISE instance UV.Unbox a => MonoTraversable (Sized UV.Vector n a) #-}
  {-# SPECIALISE instance SV.Storable a => MonoTraversable (Sized SV.Vector n a) #-}
  otraverse :: forall (m :: Type -> Type).
Applicative m =>
(Element (Sized f n a) -> m (Element (Sized f n a)))
-> Sized f n a -> m (Sized f n a)
otraverse Element (Sized f n a) -> f (Element (Sized f n a))
f = forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap forall (f :: Type -> Type) (n :: Nat) a. f a -> Sized f n a
Sized forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall mono (f :: Type -> Type).
(MonoTraversable mono, Applicative f) =>
(Element mono -> f (Element mono)) -> mono -> f mono
otraverse Element (Sized f n a) -> f (Element (Sized f n a))
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: Type -> Type) (n :: Nat) a. Sized f n a -> f a
runSized
  omapM :: forall (m :: Type -> Type).
Applicative m =>
(Element (Sized f n a) -> m (Element (Sized f n a)))
-> Sized f n a -> m (Sized f n a)
omapM Element (Sized f n a) -> m (Element (Sized f n a))
f = forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap forall (f :: Type -> Type) (n :: Nat) a. f a -> Sized f n a
Sized forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall mono (f :: Type -> Type).
(MonoTraversable mono, Applicative f) =>
(Element mono -> f (Element mono)) -> mono -> f mono
omapM Element (Sized f n a) -> m (Element (Sized f n a))
fforall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: Type -> Type) (n :: Nat) a. Sized f n a -> f a
runSized

-- | Since 0.6.0.0
instance {-# OVERLAPPING #-} SV.Storable a => MonoTraversable (Sized SV.Vector n a) where
  otraverse :: forall (m :: Type -> Type).
Applicative m =>
(Element (Sized Vector n a) -> m (Element (Sized Vector n a)))
-> Sized Vector n a -> m (Sized Vector n a)
otraverse Element (Sized Vector n a) -> f (Element (Sized Vector n a))
f = forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap forall (f :: Type -> Type) (n :: Nat) a. f a -> Sized f n a
Sized forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall mono (f :: Type -> Type).
(MonoTraversable mono, Applicative f) =>
(Element mono -> f (Element mono)) -> mono -> f mono
otraverse Element (Sized Vector n a) -> f (Element (Sized Vector n a))
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: Type -> Type) (n :: Nat) a. Sized f n a -> f a
runSized
  omapM :: forall (m :: Type -> Type).
Applicative m =>
(Element (Sized Vector n a) -> m (Element (Sized Vector n a)))
-> Sized Vector n a -> m (Sized Vector n a)
omapM Element (Sized Vector n a) -> m (Element (Sized Vector n a))
f = forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap forall (f :: Type -> Type) (n :: Nat) a. f a -> Sized f n a
Sized forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall mono (f :: Type -> Type).
(MonoTraversable mono, Applicative f) =>
(Element mono -> f (Element mono)) -> mono -> f mono
omapM Element (Sized Vector n a) -> m (Element (Sized Vector n a))
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: Type -> Type) (n :: Nat) a. Sized f n a -> f a
runSized

-- | Since 0.6.0.0
instance {-# OVERLAPPING #-} UV.Unbox a => MonoTraversable (Sized UV.Vector n a) where
  otraverse :: forall (m :: Type -> Type).
Applicative m =>
(Element (Sized Vector n a) -> m (Element (Sized Vector n a)))
-> Sized Vector n a -> m (Sized Vector n a)
otraverse Element (Sized Vector n a) -> f (Element (Sized Vector n a))
f = forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap forall (f :: Type -> Type) (n :: Nat) a. f a -> Sized f n a
Sized forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall mono (f :: Type -> Type).
(MonoTraversable mono, Applicative f) =>
(Element mono -> f (Element mono)) -> mono -> f mono
otraverse Element (Sized Vector n a) -> f (Element (Sized Vector n a))
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: Type -> Type) (n :: Nat) a. Sized f n a -> f a
runSized
  omapM :: forall (m :: Type -> Type).
Applicative m =>
(Element (Sized Vector n a) -> m (Element (Sized Vector n a)))
-> Sized Vector n a -> m (Sized Vector n a)
omapM Element (Sized Vector n a) -> m (Element (Sized Vector n a))
f = forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap forall (f :: Type -> Type) (n :: Nat) a. f a -> Sized f n a
Sized forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall mono (f :: Type -> Type).
(MonoTraversable mono, Applicative f) =>
(Element mono -> f (Element mono)) -> mono -> f mono
omapM Element (Sized Vector n a) -> m (Element (Sized Vector n a))
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: Type -> Type) (n :: Nat) a. Sized f n a -> f a
runSized

deriving instance NFData (f a) => NFData (Sized f n a)
deriving instance Hashable (f a) => Hashable (Sized f n a)

instance Show (f a) => Show (Sized f n a) where
  showsPrec :: Int -> Sized f n a -> ShowS
showsPrec Int
d (Sized f a
x) = forall a. Show a => Int -> a -> ShowS
showsPrec Int
d f a
x

-- | Since 0.2.0.0
type instance Index (Sized f n a) = Ordinal n

-- | Since 0.3.0.0
type instance IxValue (Sized f n a) = IxValue (f a)
instance (Integral (Index (f a)), Ixed (f a))
         => Ixed (Sized f (n :: Nat) a) where
  {-# SPECIALISE instance Ixed (Sized [] (n :: Nat) a) #-}
  {-# SPECIALISE instance Ixed (Sized V.Vector (n :: Nat) a) #-}
  {-# SPECIALISE instance SV.Storable a => Ixed (Sized SV.Vector (n :: Nat) a) #-}
  {-# SPECIALISE instance UV.Unbox a => Ixed (Sized UV.Vector (n :: Nat) a) #-}
  {-# SPECIALISE instance Ixed (Sized Seq.Seq (n :: Nat) a) #-}
  {-# INLINE ix #-}
  ix :: Index (Sized f n a)
-> Traversal' (Sized f n a) (IxValue (Sized f n a))
ix Index (Sized f n a)
n IxValue (Sized f n a) -> f (IxValue (Sized f n a))
f = forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap forall (f :: Type -> Type) (n :: Nat) a. f a -> Sized f n a
Sized forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall m. Ixed m => Index m -> Traversal' m (IxValue m)
ix (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall (n :: Nat). Ordinal n -> Nat
ordToNatural Index (Sized f n a)
n) IxValue (Sized f n a) -> f (IxValue (Sized f n a))
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: Type -> Type) (n :: Nat) a. Sized f n a -> f a
runSized

-- | Since 0.2.0.0
instance (Integral i, FunctorWithIndex i f, KnownNat n)
      => FunctorWithIndex (Ordinal n) (Sized f n) where
  imap :: forall a b. (Ordinal n -> a -> b) -> Sized f n a -> Sized f n b
imap Ordinal n -> a -> b
f = forall (f :: Type -> Type) (n :: Nat) a. f a -> Sized f n a
Sized forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i (f :: Type -> Type) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap (Ordinal n -> a -> b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat). KnownNat n => Nat -> Ordinal n
unsafeNaturalToOrd forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: Type -> Type) (n :: Nat) a. Sized f n a -> f a
runSized
  {-# INLINE imap #-}
  {-# SPECIALISE instance KnownNat n
                       => FunctorWithIndex (Ordinal n) (Sized [] (n :: Nat)) #-}
  {-# SPECIALISE instance KnownNat n
                       => FunctorWithIndex (Ordinal n) (Sized V.Vector (n :: Nat)) #-}
  {-# SPECIALISE instance KnownNat n
                       => FunctorWithIndex (Ordinal n) (Sized Seq.Seq (n :: Nat)) #-}

-- | Since 0.4.0.0
instance {-# OVERLAPPABLE #-}  (Integral i, FoldableWithIndex i f, KnownNat n)
      => FoldableWithIndex (Ordinal n) (Sized f n) where
  ifoldMap :: forall m a. Monoid m => (Ordinal n -> a -> m) -> Sized f n a -> m
ifoldMap Ordinal n -> a -> m
f = forall i (f :: Type -> Type) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap (Ordinal n -> a -> m
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat). KnownNat n => Nat -> Ordinal n
unsafeNaturalToOrd forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: Type -> Type) (n :: Nat) a. Sized f n a -> f a
runSized
  {-# INLINE ifoldMap #-}

  ifoldr :: forall a b. (Ordinal n -> a -> b -> b) -> b -> Sized f n a -> b
ifoldr Ordinal n -> a -> b -> b
f b
e = forall i (f :: Type -> Type) a b.
FoldableWithIndex i f =>
(i -> a -> b -> b) -> b -> f a -> b
ifoldr (Ordinal n -> a -> b -> b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat). KnownNat n => Nat -> Ordinal n
unsafeNaturalToOrd forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) b
e forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: Type -> Type) (n :: Nat) a. Sized f n a -> f a
runSized
  {-# INLINE ifoldr #-}

  ifoldl :: forall b a. (Ordinal n -> b -> a -> b) -> b -> Sized f n a -> b
ifoldl Ordinal n -> b -> a -> b
f b
e = forall i (f :: Type -> Type) b a.
FoldableWithIndex i f =>
(i -> b -> a -> b) -> b -> f a -> b
ifoldl (Ordinal n -> b -> a -> b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat). KnownNat n => Nat -> Ordinal n
unsafeNaturalToOrd forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) b
e forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: Type -> Type) (n :: Nat) a. Sized f n a -> f a
runSized
  {-# INLINE ifoldl #-}

  ifoldr' :: forall a b. (Ordinal n -> a -> b -> b) -> b -> Sized f n a -> b
ifoldr' Ordinal n -> a -> b -> b
f b
e = forall i (f :: Type -> Type) a b.
FoldableWithIndex i f =>
(i -> a -> b -> b) -> b -> f a -> b
ifoldr' (Ordinal n -> a -> b -> b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat). KnownNat n => Nat -> Ordinal n
unsafeNaturalToOrd forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) b
e forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: Type -> Type) (n :: Nat) a. Sized f n a -> f a
runSized
  {-# INLINE ifoldr' #-}

  ifoldl' :: forall b a. (Ordinal n -> b -> a -> b) -> b -> Sized f n a -> b
ifoldl' Ordinal n -> b -> a -> b
f b
e = forall i (f :: Type -> Type) b a.
FoldableWithIndex i f =>
(i -> b -> a -> b) -> b -> f a -> b
ifoldl' (Ordinal n -> b -> a -> b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat). KnownNat n => Nat -> Ordinal n
unsafeNaturalToOrd forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) b
e forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: Type -> Type) (n :: Nat) a. Sized f n a -> f a
runSized
  {-# INLINE ifoldl' #-}

  {-# SPECIALISE instance KnownNat n
                       => FoldableWithIndex (Ordinal n) (Sized [] (n :: Nat)) #-}
  {-# SPECIALISE instance KnownNat n
                       => FoldableWithIndex (Ordinal n) (Sized V.Vector (n :: Nat)) #-}
  {-# SPECIALISE instance KnownNat n
                       => FoldableWithIndex (Ordinal n) (Sized Seq.Seq (n :: Nat)) #-}
-- | Since 0.2.0.0
instance (Integral i, TraversableWithIndex i f, KnownNat n)
      => TraversableWithIndex (Ordinal n) (Sized f n) where
  itraverse :: forall (f :: Type -> Type) a b.
Applicative f =>
(Ordinal n -> a -> f b) -> Sized f n a -> f (Sized f n b)
itraverse Ordinal n -> a -> f b
f = forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap forall (f :: Type -> Type) (n :: Nat) a. f a -> Sized f n a
Sized forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i (t :: Type -> Type) (f :: Type -> Type) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
itraverse (Ordinal n -> a -> f b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat). KnownNat n => Nat -> Ordinal n
unsafeNaturalToOrd forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: Type -> Type) (n :: Nat) a. Sized f n a -> f a
runSized
  {-# INLINE itraverse #-}

  {-# SPECIALISE instance KnownNat n
                       => TraversableWithIndex (Ordinal n) (Sized [] (n :: Nat)) #-}
  {-# SPECIALISE instance KnownNat n
                       => TraversableWithIndex (Ordinal n) (Sized V.Vector (n :: Nat)) #-}
  {-# SPECIALISE instance KnownNat n
                       => TraversableWithIndex (Ordinal n) (Sized Seq.Seq (n :: Nat)) #-}