{-# 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 { Sized f n a -> f a
runSized :: f a
        } deriving (Sized f n a -> Sized f n a -> Bool
(Sized f n a -> Sized f n a -> Bool)
-> (Sized f n a -> Sized f n a -> Bool) -> Eq (Sized f n a)
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, Eq (Sized f n a)
Eq (Sized f n a)
-> (Sized f n a -> Sized f n a -> Ordering)
-> (Sized f n a -> Sized f n a -> Bool)
-> (Sized f n a -> Sized f n a -> Bool)
-> (Sized f n a -> Sized f n a -> Bool)
-> (Sized f n a -> Sized f n a -> Bool)
-> (Sized f n a -> Sized f n a -> Sized f n a)
-> (Sized f n a -> Sized f n a -> Sized f n a)
-> Ord (Sized f n a)
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
$cp1Ord :: forall (f :: Type -> Type) (n :: Nat) a.
Ord (f a) =>
Eq (Sized f n a)
Ord, Typeable,
                    a -> Sized f n b -> Sized f n a
(a -> b) -> Sized f n a -> Sized f n b
(forall a b. (a -> b) -> Sized f n a -> Sized f n b)
-> (forall a b. a -> Sized f n b -> Sized f n a)
-> Functor (Sized f n)
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
<$ :: 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 :: (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, a -> Sized f n a -> Bool
Sized f n m -> m
Sized f n a -> [a]
Sized f n a -> Bool
Sized f n a -> Int
Sized f n a -> a
Sized f n a -> a
Sized f n a -> a
Sized f n a -> a
(a -> m) -> Sized f n a -> m
(a -> m) -> Sized f n a -> m
(a -> b -> b) -> b -> Sized f n a -> b
(a -> b -> b) -> b -> Sized f n a -> b
(b -> a -> b) -> b -> Sized f n a -> b
(b -> a -> b) -> b -> Sized f n a -> b
(a -> a -> a) -> Sized f n a -> a
(a -> a -> a) -> Sized f n a -> a
(forall m. Monoid m => Sized f n m -> m)
-> (forall m a. Monoid m => (a -> m) -> Sized f n a -> m)
-> (forall m a. Monoid m => (a -> m) -> Sized f n a -> m)
-> (forall a b. (a -> b -> b) -> b -> Sized f n a -> b)
-> (forall a b. (a -> b -> b) -> b -> Sized f n a -> b)
-> (forall b a. (b -> a -> b) -> b -> Sized f n a -> b)
-> (forall b a. (b -> a -> b) -> b -> Sized f n a -> b)
-> (forall a. (a -> a -> a) -> Sized f n a -> a)
-> (forall a. (a -> a -> a) -> Sized f n a -> a)
-> (forall a. Sized f n a -> [a])
-> (forall a. Sized f n a -> Bool)
-> (forall a. Sized f n a -> Int)
-> (forall a. Eq a => a -> Sized f n a -> Bool)
-> (forall a. Ord a => Sized f n a -> a)
-> (forall a. Ord a => Sized f n a -> a)
-> (forall a. Num a => Sized f n a -> a)
-> (forall a. Num a => Sized f n a -> a)
-> Foldable (Sized f n)
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 :: Sized f n a -> a
$cproduct :: forall (f :: Type -> Type) (n :: Nat) a.
(Foldable f, Num a) =>
Sized f n a -> a
sum :: Sized f n a -> a
$csum :: forall (f :: Type -> Type) (n :: Nat) a.
(Foldable f, Num a) =>
Sized f n a -> a
minimum :: Sized f n a -> a
$cminimum :: forall (f :: Type -> Type) (n :: Nat) a.
(Foldable f, Ord a) =>
Sized f n a -> a
maximum :: Sized f n a -> a
$cmaximum :: forall (f :: Type -> Type) (n :: Nat) a.
(Foldable f, Ord a) =>
Sized f n a -> a
elem :: 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 :: Sized f n a -> Int
$clength :: forall (f :: Type -> Type) (n :: Nat) a.
Foldable f =>
Sized f n a -> Int
null :: Sized f n a -> Bool
$cnull :: forall (f :: Type -> Type) (n :: Nat) a.
Foldable f =>
Sized f n a -> Bool
toList :: Sized f n a -> [a]
$ctoList :: forall (f :: Type -> Type) (n :: Nat) a.
Foldable f =>
Sized f n a -> [a]
foldl1 :: (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 :: (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' :: (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 :: (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' :: (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 :: (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' :: (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 :: (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 :: Sized f n m -> m
$cfold :: forall (f :: Type -> Type) (n :: Nat) m.
(Foldable f, Monoid m) =>
Sized f n m -> m
Foldable, Functor (Sized f n)
Foldable (Sized f n)
Functor (Sized f n)
-> Foldable (Sized f n)
-> (forall (f :: Type -> Type) a b.
    Applicative f =>
    (a -> f b) -> Sized f n a -> f (Sized f n b))
-> (forall (f :: Type -> Type) a.
    Applicative f =>
    Sized f n (f a) -> f (Sized f n a))
-> (forall (m :: Type -> Type) a b.
    Monad m =>
    (a -> m b) -> Sized f n a -> m (Sized f n b))
-> (forall (m :: Type -> Type) a.
    Monad m =>
    Sized f n (m a) -> m (Sized f n a))
-> Traversable (Sized f n)
(a -> f b) -> Sized f n a -> f (Sized f n b)
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 (m :: Type -> Type) a.
Monad m =>
Sized f n (m a) -> m (Sized f n a)
forall (f :: Type -> Type) a.
Applicative f =>
Sized f n (f a) -> f (Sized f n a)
forall (m :: Type -> Type) a b.
Monad m =>
(a -> m b) -> Sized f n a -> m (Sized f n b)
forall (f :: Type -> Type) a b.
Applicative f =>
(a -> f b) -> Sized f n a -> f (Sized f n b)
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)
sequence :: 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 :: (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 :: 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 :: (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)
$cp2Traversable :: forall (f :: Type -> Type) (n :: Nat).
Traversable f =>
Foldable (Sized f n)
$cp1Traversable :: forall (f :: Type -> Type) (n :: Nat).
Traversable f =>
Functor (Sized f n)
Traversable)
          deriving newtype
                (Constrained (Sized f n)
forall (f :: Type -> Type). Constrained f
Constrained, Constrained (Sized f n)
a -> Sized f n a -> Bool
a -> Sized f n a -> Bool
a -> Sized f n a -> Maybe Int
a -> Sized f n a -> [Int]
Constrained (Sized f n)
-> (forall a w.
    (Dom (Sized f n) a, Monoid w) =>
    (a -> w) -> Sized f n a -> w)
-> (forall a w.
    (Dom (Sized f n) a, Monoid w) =>
    (a -> w) -> Sized f n a -> w)
-> (forall w. (Dom (Sized f n) w, Monoid w) => Sized f n w -> w)
-> (forall a b.
    Dom (Sized f n) a =>
    (a -> b -> b) -> b -> Sized f n a -> 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 (m :: Type -> Type) b a.
    (Monad m, Dom (Sized f n) b) =>
    (a -> b -> m a) -> a -> Sized f n b -> m a)
-> (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) a b.
    (Monad m, Dom (Sized f n) a) =>
    (a -> b -> m b) -> b -> Sized f n a -> m b)
-> (forall a b.
    Dom (Sized f n) a =>
    (b -> a -> b) -> b -> Sized f n a -> b)
-> (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 a. Dom (Sized f n) a => Sized f n a -> [a])
-> (forall a.
    Dom (Sized f n) a =>
    (a -> a -> a) -> Sized f n a -> a)
-> (forall a.
    Dom (Sized f n) a =>
    (a -> a -> 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 => Sized f n a -> Bool)
-> (forall a. Dom (Sized f n) a => Sized f n a -> Int)
-> (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 -> Bool)
-> (forall a.
    (Eq a, Dom (Sized f n) a) =>
    a -> Sized f n a -> Bool)
-> (forall a.
    (Eq a, Dom (Sized f n) a) =>
    a -> Sized f n a -> Bool)
-> (forall a. (Ord 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. (Num a, Dom (Sized f n) a) => Sized f n a -> a)
-> (forall a. (Num a, Dom (Sized f n) a) => Sized f n a -> a)
-> (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 ())
-> (forall (g :: Type -> Type) a b.
    (Applicative g, Dom (Sized f n) a) =>
    (a -> g b) -> Sized f n a -> g ())
-> (forall a. Dom (Sized f n) a => Sized f n a -> a)
-> (forall a. Dom (Sized f n) a => Sized f n a -> a)
-> (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 -> Bool) -> Sized f n a -> [Int])
-> (forall a.
    (Dom (Sized f n) a, Eq a) =>
    a -> Sized f n a -> Maybe Int)
-> (forall a.
    (Dom (Sized f n) a, Eq a) =>
    a -> Sized f n a -> [Int])
-> CFoldable (Sized f n)
Sized f n w -> w
Sized f n a -> [a]
Sized f n a -> Int -> a
Sized f n a -> Bool
Sized f n a -> Int
Sized f n a -> a
Sized f n a -> a
Sized f n a -> a
Sized f n a -> a
Sized f n a -> a
Sized f n a -> a
(a -> w) -> Sized f n a -> w
(a -> m) -> Sized f n a -> m
(a -> b -> b) -> b -> Sized f n a -> b
(a -> b -> m a) -> a -> Sized f n b -> m a
(a -> b -> m a) -> a -> Sized f n b -> m a
(a -> b -> m b) -> b -> Sized f n a -> m b
(a -> b -> m b) -> b -> Sized f n a -> m b
(b -> a -> b) -> b -> Sized f n a -> b
(a -> b -> b) -> b -> Sized f n a -> b
(b -> a -> b) -> b -> Sized f n a -> b
(a -> a -> a) -> Sized f n a -> a
(a -> a -> a) -> Sized f n a -> a
(a -> Bool) -> Sized f n a -> Bool
(a -> Bool) -> Sized f n a -> Bool
(a -> g b) -> Sized f n a -> g ()
(a -> g b) -> Sized f n a -> g ()
(a -> Bool) -> Sized f n a -> Maybe a
(a -> Bool) -> Sized f n a -> Maybe Int
(a -> Bool) -> Sized f n a -> [Int]
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 w.
(Dom (Sized f n) a, Monoid w) =>
(a -> w) -> Sized f n a -> w
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 (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 ()
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 w.
(CFoldable f, Dom (Sized f n) a, Monoid w) =>
(a -> w) -> Sized f n a -> w
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 ()
celemIndices :: 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 :: 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 :: (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 :: (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 :: (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 :: 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 :: 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_ :: (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_ :: (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 :: 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 :: 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 :: 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 :: 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 :: 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 :: 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 :: (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 :: (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 :: 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 :: 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 :: 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 :: (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 :: (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 :: 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' :: (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' :: (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 :: (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' :: (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 :: (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' :: (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 :: (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 :: (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 :: 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' :: (a -> m) -> Sized f n a -> m
$ccfoldMap' :: forall (f :: Type -> Type) (n :: Nat) a w.
(CFoldable f, Dom (Sized f n) a, Monoid w) =>
(a -> w) -> Sized f n a -> w
cfoldMap :: (a -> w) -> Sized f n a -> w
$ccfoldMap :: forall (f :: Type -> Type) (n :: Nat) a w.
(CFoldable f, Dom (Sized f n) a, Monoid w) =>
(a -> w) -> Sized f n a -> w
$cp1CFoldable :: forall (f :: Type -> Type) (n :: Nat).
CFoldable f =>
Constrained (Sized f n)
CFoldable, Constrained (Sized f n)
a -> Sized f n b -> Sized f n a
Constrained (Sized f n)
-> (forall a b.
    (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)
-> CFunctor (Sized f n)
(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
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
<$: :: 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 :: (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
$cp1CFunctor :: forall (f :: Type -> Type) (n :: Nat).
CFunctor f =>
Constrained (Sized f n)
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 :: (Element (Sized f n a) -> f (Element (Sized f n a)))
-> Sized f n a -> f (Sized f n a)
otraverse Element (Sized f n a) -> f (Element (Sized f n a))
f = (f a -> Sized f n a) -> f (f a) -> f (Sized f n a)
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap f a -> Sized f n a
forall (f :: Type -> Type) (n :: Nat) a. f a -> Sized f n a
Sized (f (f a) -> f (Sized f n a))
-> (Sized f n a -> f (f a)) -> Sized f n a -> f (Sized f n a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Element (f a) -> f (Element (f a))) -> f a -> f (f a)
forall mono (f :: Type -> Type).
(MonoTraversable mono, Applicative f) =>
(Element mono -> f (Element mono)) -> mono -> f mono
otraverse Element (f a) -> f (Element (f a))
Element (Sized f n a) -> f (Element (Sized f n a))
f (f a -> f (f a)) -> (Sized f n a -> f a) -> Sized f n a -> f (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sized f n a -> f a
forall (f :: Type -> Type) (n :: Nat) a. Sized f n a -> f a
runSized
  omapM :: (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 = (f a -> Sized f n a) -> m (f a) -> m (Sized f n a)
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap f a -> Sized f n a
forall (f :: Type -> Type) (n :: Nat) a. f a -> Sized f n a
Sized (m (f a) -> m (Sized f n a))
-> (Sized f n a -> m (f a)) -> Sized f n a -> m (Sized f n a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Element (f a) -> m (Element (f a))) -> f a -> m (f a)
forall mono (f :: Type -> Type).
(MonoTraversable mono, Applicative f) =>
(Element mono -> f (Element mono)) -> mono -> f mono
omapM Element (f a) -> m (Element (f a))
Element (Sized f n a) -> m (Element (Sized f n a))
f(f a -> m (f a)) -> (Sized f n a -> f a) -> Sized f n a -> m (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sized f n a -> f a
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 :: (Element (Sized Vector n a) -> f (Element (Sized Vector n a)))
-> Sized Vector n a -> f (Sized Vector n a)
otraverse Element (Sized Vector n a) -> f (Element (Sized Vector n a))
f = (Vector a -> Sized Vector n a)
-> f (Vector a) -> f (Sized Vector n a)
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap Vector a -> Sized Vector n a
forall (f :: Type -> Type) (n :: Nat) a. f a -> Sized f n a
Sized (f (Vector a) -> f (Sized Vector n a))
-> (Sized Vector n a -> f (Vector a))
-> Sized Vector n a
-> f (Sized Vector n a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Element (Vector a) -> f (Element (Vector a)))
-> Vector a -> f (Vector a)
forall mono (f :: Type -> Type).
(MonoTraversable mono, Applicative f) =>
(Element mono -> f (Element mono)) -> mono -> f mono
otraverse Element (Vector a) -> f (Element (Vector a))
Element (Sized Vector n a) -> f (Element (Sized Vector n a))
f (Vector a -> f (Vector a))
-> (Sized Vector n a -> Vector a)
-> Sized Vector n a
-> f (Vector a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sized Vector n a -> Vector a
forall (f :: Type -> Type) (n :: Nat) a. Sized f n a -> f a
runSized
  omapM :: (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 = (Vector a -> Sized Vector n a)
-> m (Vector a) -> m (Sized Vector n a)
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap Vector a -> Sized Vector n a
forall (f :: Type -> Type) (n :: Nat) a. f a -> Sized f n a
Sized (m (Vector a) -> m (Sized Vector n a))
-> (Sized Vector n a -> m (Vector a))
-> Sized Vector n a
-> m (Sized Vector n a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Element (Vector a) -> m (Element (Vector a)))
-> Vector a -> m (Vector a)
forall mono (f :: Type -> Type).
(MonoTraversable mono, Applicative f) =>
(Element mono -> f (Element mono)) -> mono -> f mono
omapM Element (Vector a) -> m (Element (Vector a))
Element (Sized Vector n a) -> m (Element (Sized Vector n a))
f (Vector a -> m (Vector a))
-> (Sized Vector n a -> Vector a)
-> Sized Vector n a
-> m (Vector a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sized Vector n a -> Vector a
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 :: (Element (Sized Vector n a) -> f (Element (Sized Vector n a)))
-> Sized Vector n a -> f (Sized Vector n a)
otraverse Element (Sized Vector n a) -> f (Element (Sized Vector n a))
f = (Vector a -> Sized Vector n a)
-> f (Vector a) -> f (Sized Vector n a)
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap Vector a -> Sized Vector n a
forall (f :: Type -> Type) (n :: Nat) a. f a -> Sized f n a
Sized (f (Vector a) -> f (Sized Vector n a))
-> (Sized Vector n a -> f (Vector a))
-> Sized Vector n a
-> f (Sized Vector n a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Element (Vector a) -> f (Element (Vector a)))
-> Vector a -> f (Vector a)
forall mono (f :: Type -> Type).
(MonoTraversable mono, Applicative f) =>
(Element mono -> f (Element mono)) -> mono -> f mono
otraverse Element (Vector a) -> f (Element (Vector a))
Element (Sized Vector n a) -> f (Element (Sized Vector n a))
f (Vector a -> f (Vector a))
-> (Sized Vector n a -> Vector a)
-> Sized Vector n a
-> f (Vector a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sized Vector n a -> Vector a
forall (f :: Type -> Type) (n :: Nat) a. Sized f n a -> f a
runSized
  omapM :: (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 = (Vector a -> Sized Vector n a)
-> m (Vector a) -> m (Sized Vector n a)
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap Vector a -> Sized Vector n a
forall (f :: Type -> Type) (n :: Nat) a. f a -> Sized f n a
Sized (m (Vector a) -> m (Sized Vector n a))
-> (Sized Vector n a -> m (Vector a))
-> Sized Vector n a
-> m (Sized Vector n a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Element (Vector a) -> m (Element (Vector a)))
-> Vector a -> m (Vector a)
forall mono (f :: Type -> Type).
(MonoTraversable mono, Applicative f) =>
(Element mono -> f (Element mono)) -> mono -> f mono
omapM Element (Vector a) -> m (Element (Vector a))
Element (Sized Vector n a) -> m (Element (Sized Vector n a))
f (Vector a -> m (Vector a))
-> (Sized Vector n a -> Vector a)
-> Sized Vector n a
-> m (Vector a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sized Vector n a -> Vector a
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) = Int -> f a -> ShowS
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 = (f a -> Sized f n a) -> f (f a) -> f (Sized f n a)
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap f a -> Sized f n a
forall (f :: Type -> Type) (n :: Nat) a. f a -> Sized f n a
Sized (f (f a) -> f (Sized f n a))
-> (Sized f n a -> f (f a)) -> Sized f n a -> f (Sized f n a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Index (f a)
-> (IxValue (f a) -> f (IxValue (f a))) -> f a -> f (f a)
forall m. Ixed m => Index m -> Traversal' m (IxValue m)
ix (Natural -> Index (f a)
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Natural -> Index (f a)) -> Natural -> Index (f a)
forall a b. (a -> b) -> a -> b
$ Ordinal n -> Natural
forall (n :: Nat). Ordinal n -> Natural
ordToNatural Index (Sized f n a)
Ordinal n
n) IxValue (f a) -> f (IxValue (f a))
IxValue (Sized f n a) -> f (IxValue (Sized f n a))
f (f a -> f (f a)) -> (Sized f n a -> f a) -> Sized f n a -> f (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sized f n a -> f a
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 :: (Ordinal n -> a -> b) -> Sized f n a -> Sized f n b
imap Ordinal n -> a -> b
f = f b -> Sized f n b
forall (f :: Type -> Type) (n :: Nat) a. f a -> Sized f n a
Sized (f b -> Sized f n b)
-> (Sized f n a -> f b) -> Sized f n a -> Sized f n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (i -> a -> b) -> f a -> f b
forall i (f :: Type -> Type) a b.
FunctorWithIndex i f =>
(i -> a -> b) -> f a -> f b
imap (Ordinal n -> a -> b
f (Ordinal n -> a -> b) -> (i -> Ordinal n) -> i -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Natural -> Ordinal n
forall (n :: Nat). KnownNat n => Natural -> Ordinal n
unsafeNaturalToOrd (Natural -> Ordinal n) -> (i -> Natural) -> i -> Ordinal n
forall b c a. (b -> c) -> (a -> b) -> a -> c
. i -> Natural
forall a b. (Integral a, Num b) => a -> b
fromIntegral) (f a -> f b) -> (Sized f n a -> f a) -> Sized f n a -> f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sized f n a -> f a
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 :: (Ordinal n -> a -> m) -> Sized f n a -> m
ifoldMap Ordinal n -> a -> m
f = (i -> a -> m) -> f a -> m
forall i (f :: Type -> Type) m a.
(FoldableWithIndex i f, Monoid m) =>
(i -> a -> m) -> f a -> m
ifoldMap (Ordinal n -> a -> m
f (Ordinal n -> a -> m) -> (i -> Ordinal n) -> i -> a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Natural -> Ordinal n
forall (n :: Nat). KnownNat n => Natural -> Ordinal n
unsafeNaturalToOrd (Natural -> Ordinal n) -> (i -> Natural) -> i -> Ordinal n
forall b c a. (b -> c) -> (a -> b) -> a -> c
. i -> Natural
forall a b. (Integral a, Num b) => a -> b
fromIntegral) (f a -> m) -> (Sized f n a -> f a) -> Sized f n a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sized f n a -> f a
forall (f :: Type -> Type) (n :: Nat) a. Sized f n a -> f a
runSized
  {-# INLINE ifoldMap #-}

  ifoldr :: (Ordinal n -> a -> b -> b) -> b -> Sized f n a -> b
ifoldr Ordinal n -> a -> b -> b
f b
e = (i -> a -> b -> b) -> b -> f a -> b
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 (Ordinal n -> a -> b -> b) -> (i -> Ordinal n) -> i -> a -> b -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Natural -> Ordinal n
forall (n :: Nat). KnownNat n => Natural -> Ordinal n
unsafeNaturalToOrd (Natural -> Ordinal n) -> (i -> Natural) -> i -> Ordinal n
forall b c a. (b -> c) -> (a -> b) -> a -> c
. i -> Natural
forall a b. (Integral a, Num b) => a -> b
fromIntegral) b
e (f a -> b) -> (Sized f n a -> f a) -> Sized f n a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sized f n a -> f a
forall (f :: Type -> Type) (n :: Nat) a. Sized f n a -> f a
runSized
  {-# INLINE ifoldr #-}

  ifoldl :: (Ordinal n -> b -> a -> b) -> b -> Sized f n a -> b
ifoldl Ordinal n -> b -> a -> b
f b
e = (i -> b -> a -> b) -> b -> f a -> b
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 (Ordinal n -> b -> a -> b) -> (i -> Ordinal n) -> i -> b -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Natural -> Ordinal n
forall (n :: Nat). KnownNat n => Natural -> Ordinal n
unsafeNaturalToOrd (Natural -> Ordinal n) -> (i -> Natural) -> i -> Ordinal n
forall b c a. (b -> c) -> (a -> b) -> a -> c
. i -> Natural
forall a b. (Integral a, Num b) => a -> b
fromIntegral) b
e (f a -> b) -> (Sized f n a -> f a) -> Sized f n a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sized f n a -> f a
forall (f :: Type -> Type) (n :: Nat) a. Sized f n a -> f a
runSized
  {-# INLINE ifoldl #-}

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

  ifoldl' :: (Ordinal n -> b -> a -> b) -> b -> Sized f n a -> b
ifoldl' Ordinal n -> b -> a -> b
f b
e = (i -> b -> a -> b) -> b -> f a -> b
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 (Ordinal n -> b -> a -> b) -> (i -> Ordinal n) -> i -> b -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Natural -> Ordinal n
forall (n :: Nat). KnownNat n => Natural -> Ordinal n
unsafeNaturalToOrd (Natural -> Ordinal n) -> (i -> Natural) -> i -> Ordinal n
forall b c a. (b -> c) -> (a -> b) -> a -> c
. i -> Natural
forall a b. (Integral a, Num b) => a -> b
fromIntegral) b
e (f a -> b) -> (Sized f n a -> f a) -> Sized f n a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sized f n a -> f a
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 :: (Ordinal n -> a -> f b) -> Sized f n a -> f (Sized f n b)
itraverse Ordinal n -> a -> f b
f = (f b -> Sized f n b) -> f (f b) -> f (Sized f n b)
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap f b -> Sized f n b
forall (f :: Type -> Type) (n :: Nat) a. f a -> Sized f n a
Sized (f (f b) -> f (Sized f n b))
-> (Sized f n a -> f (f b)) -> Sized f n a -> f (Sized f n b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (i -> a -> f b) -> f a -> f (f b)
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 (Ordinal n -> a -> f b) -> (i -> Ordinal n) -> i -> a -> f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Natural -> Ordinal n
forall (n :: Nat). KnownNat n => Natural -> Ordinal n
unsafeNaturalToOrd (Natural -> Ordinal n) -> (i -> Natural) -> i -> Ordinal n
forall b c a. (b -> c) -> (a -> b) -> a -> c
. i -> Natural
forall a b. (Integral a, Num b) => a -> b
fromIntegral) (f a -> f (f b)) -> (Sized f n a -> f a) -> Sized f n a -> f (f b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sized f n a -> f a
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)) #-}