{-# OPTIONS_GHC -fno-float-in #-}
{-# OPTIONS_GHC -Wno-orphans #-}
{-# OPTIONS_HADDOCK not-home, prune #-}
{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE RoleAnnotations #-}
{-# LANGUAGE NoStarIsType #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TupleSections #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UnboxedTuples #-}
{-# LANGUAGE ViewPatterns #-}
module Data.Vec.Short.Internal where
import Prelude hiding ((++), concat, iterate)
#if !MIN_VERSION_base(4, 18, 0)
import Control.Applicative (Applicative(..))
#endif
import Control.DeepSeq (NFData(rnf))
import Control.Exception (assert)
import qualified Data.Data as D
import qualified Data.Foldable as F
import Data.Function (on)
import Data.Functor ((<&>))
import Data.Kind (Type)
import qualified Data.List as L (sort, sortBy, sortOn, findIndex)
import Data.Semigroup (All(..), Any(..), Sum(..), Product(..))
import GHC.Exts
( Int(I#), Proxy#, State#, SmallMutableArray#, SmallArray#
, cloneSmallArray#, copySmallArray#, indexSmallArray#, newSmallArray#
, sizeofSmallArray#, thawSmallArray#, unsafeFreezeSmallArray#
, writeSmallArray#, proxy#, coerce
)
import qualified GHC.Exts as GHC (IsList(..))
import GHC.Stack (HasCallStack)
import GHC.ST (ST(..), runST)
import GHC.TypeNats (Nat, KnownNat, type (+), type (*), natVal')
import Data.Default.Class (Default(..))
import Data.Distributive (Distributive(..))
import Data.Foldable.WithIndex (FoldableWithIndex(..))
import Data.Functor.Apply (Apply(..))
import Data.Functor.Bind (Bind(..))
import Data.Functor.Rep (Representable(..))
import Data.Functor.WithIndex (FunctorWithIndex)
import qualified Data.Functor.WithIndex as X (imap)
import Data.Portray (Portray(..), Portrayal(..), strAtom)
import Data.Portray.Diff (Diff(..))
import Data.Traversable.WithIndex (TraversableWithIndex(..))
import qualified Test.QuickCheck as QC
import Data.Fin.Int (Fin, finToInt, unsafeFin)
import Data.SInt (SInt(SI#, unSInt), sintVal, subSIntL, divSIntR, withSInt, addSInt)
#if !MIN_VERSION_base(4,15,0)
import GHC.Natural (naturalToInteger, naturalToInt)
import GHC.Integer (integerToInt)
#endif
foldrEnumFin :: SInt n -> (Fin n -> a -> a) -> a -> a
foldrEnumFin :: forall (n :: Nat) a. SInt n -> (Fin n -> a -> a) -> a -> a
foldrEnumFin SInt n
sn Fin n -> a -> a
c a
n = Int -> a
go Int
0
where
go :: Int -> a
go Int
i
| Int
i forall a. Eq a => a -> a -> Bool
== forall (n :: Nat). SInt n -> Int
unSInt SInt n
sn = a
n
| Bool
otherwise = Fin n -> a -> a
c (forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin Int
i) (Int -> a
go (Int
i forall a. Num a => a -> a -> a
+ Int
1))
{-# INLINE [0] foldrEnumFin #-}
forMFin_ :: Applicative f => SInt n -> (Fin n -> f a) -> f ()
forMFin_ :: forall (f :: Type -> Type) (n :: Nat) a.
Applicative f =>
SInt n -> (Fin n -> f a) -> f ()
forMFin_ SInt n
n Fin n -> f a
f = forall (n :: Nat) a. SInt n -> (Fin n -> a -> a) -> a -> a
foldrEnumFin SInt n
n (\Fin n
i f ()
rest -> Fin n -> f a
f Fin n
i forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
*> f ()
rest) (forall (f :: Type -> Type) a. Applicative f => a -> f a
pure ())
{-# INLINE forMFin_ #-}
foldMapFin :: Monoid m => SInt n -> (Fin n -> (# m #)) -> m
foldMapFin :: forall m (n :: Nat). Monoid m => SInt n -> (Fin n -> (# m #)) -> m
foldMapFin SInt n
sn Fin n -> (# m #)
f = Int -> m -> m
go Int
0 forall a. Monoid a => a
mempty
where
go :: Int -> m -> m
go Int
i m
acc
| Int
i forall a. Eq a => a -> a -> Bool
== forall (n :: Nat). SInt n -> Int
unSInt SInt n
sn = m
acc
| Bool
otherwise = case Fin n -> (# m #)
f (forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin Int
i) of (# m
x #) -> Int -> m -> m
go (Int
i forall a. Num a => a -> a -> a
+ Int
1) (m
acc forall a. Semigroup a => a -> a -> a
<> m
x)
{-# INLINE foldMapFin #-}
foldMFin_
:: Monad m
=> SInt n -> (a -> Fin n -> m a) -> a -> m ()
foldMFin_ :: forall (m :: Type -> Type) (n :: Nat) a.
Monad m =>
SInt n -> (a -> Fin n -> m a) -> a -> m ()
foldMFin_ SInt n
n a -> Fin n -> m a
f a
z = forall (n :: Nat) a. SInt n -> (Fin n -> a -> a) -> a -> a
foldrEnumFin SInt n
n (\Fin n
i a -> m ()
rest a
a -> a -> Fin n -> m a
f a
a Fin n
i forall (m :: Type -> Type) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> m ()
rest) (\a
_ -> forall (f :: Type -> Type) a. Applicative f => a -> f a
pure ()) a
z
{-# INLINE foldMFin_ #-}
forMFin
:: Applicative f => SInt n -> (Fin n -> (# f a #)) -> f [a]
forMFin :: forall (f :: Type -> Type) (n :: Nat) a.
Applicative f =>
SInt n -> (Fin n -> (# f a #)) -> f [a]
forMFin SInt n
n Fin n -> (# f a #)
f = forall (n :: Nat) a. SInt n -> (Fin n -> a -> a) -> a -> a
foldrEnumFin SInt n
n
(\Fin n
i -> case Fin n -> (# f a #)
f Fin n
i of (# f a
fx #) -> forall (f :: Type -> Type) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (:) f a
fx)
(forall (f :: Type -> Type) a. Applicative f => a -> f a
pure [])
{-# INLINE forMFin #-}
prim_ :: (State# s -> State# s) -> ST s ()
prim_ :: forall s. (State# s -> State# s) -> ST s ()
prim_ State# s -> State# s
f = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s0 -> case State# s -> State# s
f State# s
s0 of State# s
s1 -> (# State# s
s1, () #)
{-# INLINE prim_ #-}
type role Vec nominal representational
data Vec (n :: Nat) (a :: Type) = V# (SmallArray# a)
type role MutableVec nominal nominal representational
data MutableVec (s :: Type) (n :: Nat) (a :: Type)
= MV# (SmallMutableArray# s a)
newMV :: SInt n -> a -> ST s (MutableVec s n a)
newMV :: forall (n :: Nat) a s. SInt n -> a -> ST s (MutableVec s n a)
newMV (SI# Int
n) = forall a s (n :: Nat). Int -> a -> ST s (MutableVec s n a)
unsafeNewMV Int
n
{-# INLINE newMV #-}
unsafeNewMV :: Int -> a -> ST s (MutableVec s n a)
unsafeNewMV :: forall a s (n :: Nat). Int -> a -> ST s (MutableVec s n a)
unsafeNewMV (I# Int#
n) a
x =
forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s0 ->
case forall a d.
Int# -> a -> State# d -> (# State# d, SmallMutableArray# d a #)
newSmallArray# Int#
n a
x State# s
s0 of { (# State# s
s1, SmallMutableArray# s a
sma #) ->
(# State# s
s1, forall s (n :: Nat) a. SmallMutableArray# s a -> MutableVec s n a
MV# SmallMutableArray# s a
sma #) }
{-# INLINE unsafeNewMV #-}
unsafeWriteMV :: MutableVec s n a -> Int -> a -> ST s ()
unsafeWriteMV :: forall s (n :: Nat) a. MutableVec s n a -> Int -> a -> ST s ()
unsafeWriteMV (MV# SmallMutableArray# s a
sma) (I# Int#
i) a
x = forall s. (State# s -> State# s) -> ST s ()
prim_ (forall d a.
SmallMutableArray# d a -> Int# -> a -> State# d -> State# d
writeSmallArray# SmallMutableArray# s a
sma Int#
i a
x)
{-# INLINE unsafeWriteMV #-}
writeMV :: MutableVec s n a -> Fin n -> a -> ST s ()
writeMV :: forall s (n :: Nat) a. MutableVec s n a -> Fin n -> a -> ST s ()
writeMV MutableVec s n a
mv Fin n
i = forall s (n :: Nat) a. MutableVec s n a -> Int -> a -> ST s ()
unsafeWriteMV MutableVec s n a
mv (forall (n :: Nat). Fin n -> Int
finToInt Fin n
i)
{-# INLINE writeMV #-}
unsafeFreezeMV :: MutableVec s n a -> ST s (Vec n a)
unsafeFreezeMV :: forall s (n :: Nat) a. MutableVec s n a -> ST s (Vec n a)
unsafeFreezeMV (MV# SmallMutableArray# s a
sma) =
forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s0 ->
case forall d a.
SmallMutableArray# d a -> State# d -> (# State# d, SmallArray# a #)
unsafeFreezeSmallArray# SmallMutableArray# s a
sma State# s
s0 of { (# State# s
s1, SmallArray# a
sa #) ->
(# State# s
s1, forall (n :: Nat) a. SmallArray# a -> Vec n a
V# SmallArray# a
sa #) }
{-# INLINE unsafeFreezeMV #-}
safeThawMV :: Vec n a -> ST s (MutableVec s n a)
safeThawMV :: forall (n :: Nat) a s. Vec n a -> ST s (MutableVec s n a)
safeThawMV (V# SmallArray# a
sa) =
forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s0 ->
case forall a d.
SmallArray# a
-> Int#
-> Int#
-> State# d
-> (# State# d, SmallMutableArray# d a #)
thawSmallArray# SmallArray# a
sa Int#
0# (forall a. SmallArray# a -> Int#
sizeofSmallArray# SmallArray# a
sa) State# s
s0 of { (# State# s
s1, SmallMutableArray# s a
sma #) ->
(# State# s
s1, forall s (n :: Nat) a. SmallMutableArray# s a -> MutableVec s n a
MV# SmallMutableArray# s a
sma #) }
{-# INLINE safeThawMV #-}
unsafeCopyVec :: Vec n a -> Int -> MutableVec s m a -> Int -> Int -> ST s ()
unsafeCopyVec :: forall (n :: Nat) a s (m :: Nat).
Vec n a -> Int -> MutableVec s m a -> Int -> Int -> ST s ()
unsafeCopyVec (V# SmallArray# a
src) (I# Int#
srcOff) (MV# SmallMutableArray# s a
dst) (I# Int#
dstOff) (I# Int#
len) =
forall s. (State# s -> State# s) -> ST s ()
prim_ (forall a d.
SmallArray# a
-> Int#
-> SmallMutableArray# d a
-> Int#
-> Int#
-> State# d
-> State# d
copySmallArray# SmallArray# a
src Int#
srcOff SmallMutableArray# s a
dst Int#
dstOff Int#
len)
{-# INLINE[1] unsafeCopyVec #-}
{-# RULES "unsafeCopyVec/0" forall v s m d . unsafeCopyVec v s m d 0 = return () #-}
sliceVec :: Vec n a -> Int -> SInt m -> Vec m a
sliceVec :: forall (n :: Nat) a (m :: Nat). Vec n a -> Int -> SInt m -> Vec m a
sliceVec xs :: Vec n a
xs@(V# SmallArray# a
sa) off :: Int
off@(I# Int#
o) (SI# len :: Int
len@(I# Int#
l)) =
forall a. (?callStack::CallStack) => Bool -> a -> a
assert (Int
0 forall a. Ord a => a -> a -> Bool
<= Int
off Bool -> Bool -> Bool
&& Int
0 forall a. Ord a => a -> a -> Bool
<= Int
len Bool -> Bool -> Bool
&& Int
len forall a. Ord a => a -> a -> Bool
<= forall (n :: Nat) a. Vec n a -> Int
vSize Vec n a
xs forall a. Num a => a -> a -> a
- Int
off) forall a b. (a -> b) -> a -> b
$
forall (n :: Nat) a. SmallArray# a -> Vec n a
V# (forall a. SmallArray# a -> Int# -> Int# -> SmallArray# a
cloneSmallArray# SmallArray# a
sa Int#
o Int#
l)
{-# INLINE sliceVec #-}
fetch :: Vec n a -> Fin n -> (# a #)
fetch :: forall (n :: Nat) a. Vec n a -> Fin n -> (# a #)
fetch (V# SmallArray# a
arr) (forall (n :: Nat). Fin n -> Int
finToInt -> I# Int#
i) = forall a. SmallArray# a -> Int# -> (# a #)
indexSmallArray# SmallArray# a
arr Int#
i
{-# INLINE fetch #-}
fusibleFetch :: Vec n a -> Fin n -> (# a #)
fusibleFetch :: forall (n :: Nat) a. Vec n a -> Fin n -> (# a #)
fusibleFetch = forall (n :: Nat) a. Accessor n a -> Fin n -> (# a #)
_aIndex forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Vec n a -> Accessor n a
access
{-# INLINE fusibleFetch #-}
(!) :: Vec n a -> Fin n -> a
! :: forall (n :: Nat) a. Vec n a -> Fin n -> a
(!) Vec n a
xs Fin n
i = case forall (n :: Nat) a. Vec n a -> Fin n -> (# a #)
fusibleFetch Vec n a
xs Fin n
i of (# a
x #) -> a
x
{-# INLINE (!) #-}
indexK :: Vec n a -> Fin n -> (a -> r) -> r
indexK :: forall (n :: Nat) a r. Vec n a -> Fin n -> (a -> r) -> r
indexK Vec n a
v Fin n
i a -> r
k = case forall (n :: Nat) a. Vec n a -> Fin n -> (# a #)
fetch Vec n a
v Fin n
i of (# a
x #) -> a -> r
k a
x
{-# INLINE indexK #-}
svSize :: Vec n a -> SInt n
svSize :: forall (n :: Nat) a. Vec n a -> SInt n
svSize (V# SmallArray# a
sa) = forall (n :: Nat). Int -> SInt n
SI# (Int# -> Int
I# (forall a. SmallArray# a -> Int#
sizeofSmallArray# SmallArray# a
sa))
{-# INLINE svSize #-}
vSize :: Vec n a -> Int
vSize :: forall (n :: Nat) a. Vec n a -> Int
vSize = forall (n :: Nat). SInt n -> Int
unSInt forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Vec n a -> SInt n
svSize
{-# INLINE vSize #-}
uninitialized :: a
uninitialized :: forall a. a
uninitialized = forall a. (?callStack::CallStack) => [Char] -> a
error [Char]
"Vec: uninitialized"
{-# NOINLINE uninitialized #-}
unsafeCreateVec :: Int -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
unsafeCreateVec :: forall (n :: Nat) a.
Int -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
unsafeCreateVec Int
n = forall (n :: Nat) a.
SInt n -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
createVec (forall (n :: Nat). Int -> SInt n
SI# Int
n)
{-# INLINE unsafeCreateVec #-}
createVec
:: SInt n
-> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
createVec :: forall (n :: Nat) a.
SInt n -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
createVec SInt n
n forall s. MutableVec s n a -> ST s ()
action = forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
MutableVec s n a
mv <- forall (n :: Nat) a s. SInt n -> a -> ST s (MutableVec s n a)
newMV SInt n
n forall a. a
uninitialized
forall s. MutableVec s n a -> ST s ()
action MutableVec s n a
mv
forall s (n :: Nat) a. MutableVec s n a -> ST s (Vec n a)
unsafeFreezeMV MutableVec s n a
mv
{-# INLINE createVec #-}
data Accessor n a = Accessor
{ forall (n :: Nat) a. Accessor n a -> SInt n
_aSize :: SInt n
, forall (n :: Nat) a. Accessor n a -> Fin n -> (# a #)
_aIndex :: Fin n -> (# a #)
}
access :: Vec n a -> Accessor n a
access :: forall (n :: Nat) a. Vec n a -> Accessor n a
access Vec n a
v = forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor (forall (n :: Nat) a. Vec n a -> SInt n
svSize Vec n a
v) (forall (n :: Nat) a. Vec n a -> Fin n -> (# a #)
fetch Vec n a
v)
{-# INLINE CONLIKE [0] access #-}
materialize :: Accessor n a -> Vec n a
materialize :: forall (n :: Nat) a. Accessor n a -> Vec n a
materialize (Accessor SInt n
n Fin n -> (# a #)
get) = forall (n :: Nat) a.
SInt n -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
createVec SInt n
n forall a b. (a -> b) -> a -> b
$ \MutableVec s n a
mv -> forall (f :: Type -> Type) (n :: Nat) a.
Applicative f =>
SInt n -> (Fin n -> f a) -> f ()
forMFin_ SInt n
n forall a b. (a -> b) -> a -> b
$ \Fin n
i ->
case Fin n -> (# a #)
get Fin n
i of (# a
x #) -> forall s (n :: Nat) a. MutableVec s n a -> Fin n -> a -> ST s ()
writeMV MutableVec s n a
mv Fin n
i a
x
{-# INLINE [0] materialize #-}
{-# RULES
-- Fuses adjacent Vec ops, keeping everything in Accessor form.
"access/materialize" forall va. access (materialize va) = va
-- Eliminates no-op copies of a vector.
"materialize/access" forall v. materialize (access v) = v
#-}
#if __GLASGOW_HASKELL__ < 902
{-# RULES
-- Transports coercions out from between access/materialize pairs so they can
-- fuse.
"access/coerce/materialize"
forall v. access (coerce v) = mapVA coerce (access v)
#-}
#endif
pureVA :: SInt n -> a -> Accessor n a
pureVA :: forall (n :: Nat) a. SInt n -> a -> Accessor n a
pureVA SInt n
n a
x = forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor SInt n
n forall a b. (a -> b) -> a -> b
$ \Fin n
_ -> (# a
x #)
{-# INLINE [0] pureVA #-}
mapVA :: (a -> b) -> Accessor n a -> Accessor n b
mapVA :: forall a b (n :: Nat). (a -> b) -> Accessor n a -> Accessor n b
mapVA a -> b
f (Accessor SInt n
n Fin n -> (# a #)
get) = forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor SInt n
n forall a b. (a -> b) -> a -> b
$ \Fin n
i -> case Fin n -> (# a #)
get Fin n
i of (# a
x #) -> (# a -> b
f a
x #)
{-# INLINE [0] mapVA #-}
mapWithPosVA :: (Fin n -> a -> b) -> Accessor n a -> Accessor n b
mapWithPosVA :: forall (n :: Nat) a b.
(Fin n -> a -> b) -> Accessor n a -> Accessor n b
mapWithPosVA Fin n -> a -> b
f (Accessor SInt n
n Fin n -> (# a #)
get) = forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor SInt n
n forall a b. (a -> b) -> a -> b
$
\Fin n
i -> case Fin n -> (# a #)
get Fin n
i of (# a
x #) -> (# Fin n -> a -> b
f Fin n
i a
x #)
{-# INLINE [0] mapWithPosVA #-}
seqVA :: Accessor n a -> Accessor n a
seqVA :: forall (n :: Nat) a. Accessor n a -> Accessor n a
seqVA (Accessor SInt n
n Fin n -> (# a #)
get) = forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor SInt n
n forall a b. (a -> b) -> a -> b
$
\Fin n
i -> case Fin n -> (# a #)
get Fin n
i of (# a
x #) -> a
x seq :: forall a b. a -> b -> b
`seq` (# a
x #)
{-# INLINE [0] seqVA #-}
takeVA
:: SInt m -> Accessor (m + n) a -> Accessor m a
takeVA :: forall (m :: Nat) (n :: Nat) a.
SInt m -> Accessor (m + n) a -> Accessor m a
takeVA SInt m
m (Accessor SInt (m + n)
_ Fin (m + n) -> (# a #)
get) = forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor SInt m
m (\Fin m
i -> Fin (m + n) -> (# a #)
get (forall (m :: Nat) (n :: Nat). Fin m -> Fin (m + n)
embedPlus Fin m
i))
where
embedPlus :: Fin m -> Fin (m + n)
embedPlus :: forall (m :: Nat) (n :: Nat). Fin m -> Fin (m + n)
embedPlus = forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat). Fin n -> Int
finToInt
{-# INLINE [0] takeVA #-}
dropVA :: SInt m -> Accessor (m + n) a -> Accessor n a
dropVA :: forall (m :: Nat) (n :: Nat) a.
SInt m -> Accessor (m + n) a -> Accessor n a
dropVA SInt m
m (Accessor SInt (m + n)
mn Fin (m + n) -> (# a #)
get) = forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor (forall (n :: Nat). Int -> SInt n
SI# (forall (n :: Nat). SInt n -> Int
unSInt SInt (m + n)
mn forall a. Num a => a -> a -> a
- forall (n :: Nat). SInt n -> Int
unSInt SInt m
m)) forall a b. (a -> b) -> a -> b
$
\Fin n
i -> Fin (m + n) -> (# a #)
get (forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin (forall (n :: Nat). Fin n -> Int
finToInt Fin n
i forall a. Num a => a -> a -> a
+ forall (n :: Nat). SInt n -> Int
unSInt SInt m
m))
{-# INLINE [0] dropVA #-}
revVA :: Accessor n a -> Accessor n a
revVA :: forall (n :: Nat) a. Accessor n a -> Accessor n a
revVA (Accessor SInt n
n Fin n -> (# a #)
get) = forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor SInt n
n forall a b. (a -> b) -> a -> b
$ \Fin n
i -> Fin n -> (# a #)
get (forall (n :: Nat). Fin n -> Fin n
complementIt Fin n
i)
where
!nMinus1 :: Int
nMinus1 = forall (n :: Nat). SInt n -> Int
unSInt SInt n
n forall a. Num a => a -> a -> a
- Int
1
complementIt :: Fin n -> Fin n
complementIt :: forall (n :: Nat). Fin n -> Fin n
complementIt = forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int
nMinus1 forall a. Num a => a -> a -> a
-) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat). Fin n -> Int
finToInt
{-# INLINE [0] revVA #-}
rotVA :: Fin n -> Accessor n a -> Accessor n a
rotVA :: forall (n :: Nat) a. Fin n -> Accessor n a -> Accessor n a
rotVA (forall (n :: Nat). Fin n -> Int
finToInt -> !Int
o) (Accessor SInt n
n Fin n -> (# a #)
get) = forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor SInt n
n forall a b. (a -> b) -> a -> b
$
\(forall (n :: Nat). Fin n -> Int
finToInt -> !Int
i) -> Fin n -> (# a #)
get forall a b. (a -> b) -> a -> b
$ forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin forall a b. (a -> b) -> a -> b
$ if Int
i forall a. Ord a => a -> a -> Bool
>= Int
o then Int
i forall a. Num a => a -> a -> a
- Int
o else Int
nmo forall a. Num a => a -> a -> a
+ Int
i
where
!nmo :: Int
nmo = forall (n :: Nat). SInt n -> Int
unSInt SInt n
n forall a. Num a => a -> a -> a
- Int
o
{-# INLINE [0] rotVA #-}
liftA2VA :: (a -> b -> c) -> Accessor n a -> Accessor n b -> Accessor n c
liftA2VA :: forall a b c (n :: Nat).
(a -> b -> c) -> Accessor n a -> Accessor n b -> Accessor n c
liftA2VA a -> b -> c
f (Accessor SInt n
n Fin n -> (# a #)
getA) (Accessor SInt n
_ Fin n -> (# b #)
getB) = forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor SInt n
n forall a b. (a -> b) -> a -> b
$
\Fin n
i -> case Fin n -> (# a #)
getA Fin n
i of (# a
a #) -> case Fin n -> (# b #)
getB Fin n
i of (# b
b #) -> (# a -> b -> c
f a
a b
b #)
{-# INLINE [0] liftA2VA #-}
foldMapVA :: Monoid m => (a -> m) -> Accessor n a -> m
foldMapVA :: forall m a (n :: Nat). Monoid m => (a -> m) -> Accessor n a -> m
foldMapVA a -> m
f (Accessor SInt n
n Fin n -> (# a #)
get) =
forall m (n :: Nat). Monoid m => SInt n -> (Fin n -> (# m #)) -> m
foldMapFin SInt n
n (\Fin n
i -> case Fin n -> (# a #)
get Fin n
i of (# a
x #) -> (# a -> m
f a
x #))
{-# INLINE [0] foldMapVA #-}
sequenceVA :: Applicative f => Accessor n (f a) -> f (Vec n a)
sequenceVA :: forall (f :: Type -> Type) (n :: Nat) a.
Applicative f =>
Accessor n (f a) -> f (Vec n a)
sequenceVA (Accessor SInt n
n Fin n -> (# f a #)
get) = forall (n :: Nat) a. SInt n -> [a] -> Vec n a
listVec SInt n
n forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: Type -> Type) (n :: Nat) a.
Applicative f =>
SInt n -> (Fin n -> (# f a #)) -> f [a]
forMFin SInt n
n Fin n -> (# f a #)
get
{-# INLINE [0] sequenceVA #-}
splitFinS :: SInt n -> Fin (n + m) -> Either (Fin n) (Fin m)
splitFinS :: forall (n :: Nat) (m :: Nat).
SInt n -> Fin (n + m) -> Either (Fin n) (Fin m)
splitFinS (SI# Int
n) (forall (n :: Nat). Fin n -> Int
finToInt -> Int
i)
| Int
i forall a. Ord a => a -> a -> Bool
< Int
n = forall a b. a -> Either a b
Left (forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin Int
i)
| Bool
otherwise = forall a b. b -> Either a b
Right (forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin (Int
i forall a. Num a => a -> a -> a
- Int
n))
addPosSInt :: SInt n -> SInt m -> SInt (n + m)
addPosSInt :: forall (n :: Nat) (m :: Nat). SInt n -> SInt m -> SInt (n + m)
addPosSInt (SI# Int
n) (SI# Int
m) =
let nm :: Int
nm = Int
n forall a. Num a => a -> a -> a
+ Int
m
in if Int
nm forall a. Ord a => a -> a -> Bool
< Int
0
then forall a. (?callStack::CallStack) => [Char] -> a
error [Char]
"addPosSInt: Int overflow"
else forall (n :: Nat). Int -> SInt n
SI# (Int
n forall a. Num a => a -> a -> a
+ Int
m)
{-# INLINE addPosSInt #-}
appendVA :: Accessor n a -> Accessor m a -> Accessor (n + m) a
appendVA :: forall (n :: Nat) a (m :: Nat).
Accessor n a -> Accessor m a -> Accessor (n + m) a
appendVA (Accessor SInt n
n Fin n -> (# a #)
getN) (Accessor SInt m
m Fin m -> (# a #)
getM) = forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor
(forall (n :: Nat) (m :: Nat). SInt n -> SInt m -> SInt (n + m)
addPosSInt SInt n
n SInt m
m)
(\Fin (n + m)
i -> case forall (n :: Nat) (m :: Nat).
SInt n -> Fin (n + m) -> Either (Fin n) (Fin m)
splitFinS SInt n
n Fin (n + m)
i of
Left Fin n
i' -> Fin n -> (# a #)
getN Fin n
i'
Right Fin m
i' -> Fin m -> (# a #)
getM Fin m
i')
{-# INLINE [0] appendVA #-}
unsafeMkVec :: Int -> (Int -> a) -> Vec n a
unsafeMkVec :: forall a (n :: Nat). Int -> (Int -> a) -> Vec n a
unsafeMkVec Int
n Int -> a
f = forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
mkVec (forall (n :: Nat). Int -> SInt n
SI# Int
n) forall a b. (a -> b) -> a -> b
$ \Fin n
i -> Int -> a
f (forall (n :: Nat). Fin n -> Int
finToInt Fin n
i)
{-# INLINE unsafeMkVec #-}
tabulateVec, mkVec :: SInt n -> (Fin n -> a) -> Vec n a
tabulateVec :: forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
tabulateVec SInt n
n Fin n -> a
f = forall (n :: Nat) a. Accessor n a -> Vec n a
materialize forall a b. (a -> b) -> a -> b
$ forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor SInt n
n forall a b. (a -> b) -> a -> b
$ \Fin n
i -> (# Fin n -> a
f Fin n
i #)
mkVec :: forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
mkVec = forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
tabulateVec
{-# INLINE tabulateVec #-}
{-# INLINE mkVec #-}
tabulateVec', mkVec' :: SInt n -> (Fin n -> a) -> Vec n a
tabulateVec' :: forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
tabulateVec' SInt n
n Fin n -> a
f = forall (n :: Nat) a. Accessor n a -> Vec n a
materialize forall a b. (a -> b) -> a -> b
$
forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor SInt n
n forall a b. (a -> b) -> a -> b
$ \Fin n
i -> let x :: a
x = Fin n -> a
f Fin n
i in a
x seq :: forall a b. a -> b -> b
`seq` (# a
x #)
mkVec' :: forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
mkVec' = forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
tabulateVec'
{-# INLINE tabulateVec' #-}
{-# INLINE mkVec' #-}
backpermute :: SInt m -> (Fin m -> Fin n) -> Vec n a -> Vec m a
backpermute :: forall (m :: Nat) (n :: Nat) a.
SInt m -> (Fin m -> Fin n) -> Vec n a -> Vec m a
backpermute SInt m
m Fin m -> Fin n
f Vec n a
xs = forall (n :: Nat) a. Accessor n a -> Vec n a
materialize forall a b. (a -> b) -> a -> b
$ forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor SInt m
m forall a b. (a -> b) -> a -> b
$ \Fin m
i -> forall (n :: Nat) a. Vec n a -> Fin n -> (# a #)
fetch Vec n a
xs (Fin m -> Fin n
f Fin m
i)
{-# INLINE backpermute #-}
listVec :: SInt n -> [a] -> Vec n a
listVec :: forall (n :: Nat) a. SInt n -> [a] -> Vec n a
listVec SInt n
n [a]
xs = forall (n :: Nat) a.
SInt n -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
createVec SInt n
n forall a b. (a -> b) -> a -> b
$ \MutableVec s n a
mv -> (forall a b. (a -> b) -> a -> b
$ [a]
xs) forall a b. (a -> b) -> a -> b
$ forall (n :: Nat) a. SInt n -> (Fin n -> a -> a) -> a -> a
foldrEnumFin SInt n
n
(\Fin n
i [a] -> ST s ()
rest [a]
xs' -> case [a]
xs' of
[] -> forall s (n :: Nat) a. MutableVec s n a -> Fin n -> a -> ST s ()
writeMV MutableVec s n a
mv Fin n
i forall a. a
uninitialized forall (m :: Type -> Type) a b. Monad m => m a -> m b -> m b
>> [a] -> ST s ()
rest []
(a
x:[a]
xs'') -> forall s (n :: Nat) a. MutableVec s n a -> Fin n -> a -> ST s ()
writeMV MutableVec s n a
mv Fin n
i a
x forall (m :: Type -> Type) a b. Monad m => m a -> m b -> m b
>> [a] -> ST s ()
rest [a]
xs'')
(\[a]
_ -> forall (m :: Type -> Type) a. Monad m => a -> m a
return ())
{-# INLINE listVec #-}
withVec :: [a] -> (forall n. Vec n a -> r) -> r
withVec :: forall a r. [a] -> (forall (n :: Nat). Vec n a -> r) -> r
withVec [a]
xs forall (n :: Nat). Vec n a -> r
f = forall r.
(?callStack::CallStack) =>
Int -> (forall (n :: Nat). SInt n -> r) -> r
withSInt (forall (t :: Type -> Type) a. Foldable t => t a -> Int
length [a]
xs) forall a b. (a -> b) -> a -> b
$ \SInt n
sn -> forall (n :: Nat). Vec n a -> r
f (forall (n :: Nat) a. SInt n -> [a] -> Vec n a
listVec SInt n
sn [a]
xs)
{-# INLINABLE withVec #-}
fromListN :: HasCallStack => SInt n -> Int -> [a] -> Vec n a
fromListN :: forall (n :: Nat) a.
(?callStack::CallStack) =>
SInt n -> Int -> [a] -> Vec n a
fromListN SInt n
sn Int
l [a]
xs
| Int
l forall a. Eq a => a -> a -> Bool
== Int
n = forall (n :: Nat) a. SInt n -> [a] -> Vec n a
listVec SInt n
sn [a]
xs
| Bool
otherwise = forall a. (?callStack::CallStack) => [Char] -> a
error forall a b. (a -> b) -> a -> b
$ [Char]
"Vec.fromListN: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> [Char]
show Int
l forall a. Semigroup a => a -> a -> a
<> [Char]
" /= " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> [Char]
show Int
n
where
!n :: Int
n = forall (n :: Nat). SInt n -> Int
unSInt SInt n
sn
{-# INLINABLE fromListN #-}
fromList :: HasCallStack => SInt n -> [a] -> Vec n a
fromList :: forall (n :: Nat) a.
(?callStack::CallStack) =>
SInt n -> [a] -> Vec n a
fromList SInt n
sn [a]
xs
| Int
n forall a. Int -> [a] -> Bool
`eqLength` [a]
xs = forall (n :: Nat) a. SInt n -> [a] -> Vec n a
listVec SInt n
sn [a]
xs
| Bool
otherwise = forall a. (?callStack::CallStack) => [Char] -> a
error forall a b. (a -> b) -> a -> b
$ [Char]
"Vec.fromList: length /= " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> [Char]
show Int
n
where
!n :: Int
n = forall (n :: Nat). SInt n -> Int
unSInt SInt n
sn
{-# INLINABLE fromList #-}
eqLength :: Int -> [a] -> Bool
eqLength :: forall a. Int -> [a] -> Bool
eqLength Int
0 [] = Bool
True
eqLength Int
0 (a
_:[a]
_) = Bool
False
eqLength Int
_ [] = Bool
False
eqLength Int
n (a
_:[a]
xs) = forall a. Int -> [a] -> Bool
eqLength (Int
n forall a. Num a => a -> a -> a
- Int
1) [a]
xs
instance KnownNat n => GHC.IsList (Vec n a) where
type Item (Vec n a) = a
fromListN :: Int -> [Item (Vec n a)] -> Vec n a
fromListN = forall (n :: Nat) a.
(?callStack::CallStack) =>
SInt n -> Int -> [a] -> Vec n a
fromListN forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal
fromList :: [Item (Vec n a)] -> Vec n a
fromList = forall (n :: Nat) a.
(?callStack::CallStack) =>
SInt n -> [a] -> Vec n a
fromList forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal
toList :: Vec n a -> [Item (Vec n a)]
toList = forall (t :: Type -> Type) a. Foldable t => t a -> [a]
F.toList
vecDataType :: D.DataType
vecDataType :: DataType
vecDataType = [Char] -> [Constr] -> DataType
D.mkDataType [Char]
"Vec.Vec" [Constr
vecConstr]
vecConstr :: D.Constr
vecConstr :: Constr
vecConstr = DataType -> [Char] -> [[Char]] -> Fixity -> Constr
D.mkConstr DataType
vecDataType [Char]
"fromList" [] Fixity
D.Prefix
instance (KnownNat n, D.Data a) => D.Data (Vec n a) where
toConstr :: Vec n a -> Constr
toConstr Vec n a
_ = Constr
vecConstr
dataTypeOf :: Vec n a -> DataType
dataTypeOf Vec n a
_ = DataType
vecDataType
gfoldl :: forall (c :: Type -> Type).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Vec n a -> c (Vec n a)
gfoldl forall d b. Data d => c (d -> b) -> d -> c b
app forall g. g -> c g
pur Vec n a
v = forall g. g -> c g
pur (forall (n :: Nat) a.
(?callStack::CallStack) =>
SInt n -> [a] -> Vec n a
fromList forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal) forall d b. Data d => c (d -> b) -> d -> c b
`app` forall (t :: Type -> Type) a. Foldable t => t a -> [a]
F.toList Vec n a
v
gunfold :: forall (c :: Type -> Type).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Vec n a)
gunfold forall b r. Data b => c (b -> r) -> c r
app forall r. r -> c r
pur Constr
c
| Constr -> Int
D.constrIndex Constr
c forall a. Eq a => a -> a -> Bool
== Int
1 = forall b r. Data b => c (b -> r) -> c r
app (forall r. r -> c r
pur (forall (n :: Nat) a.
(?callStack::CallStack) =>
SInt n -> [a] -> Vec n a
fromList forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal))
| Bool
otherwise = forall a. (?callStack::CallStack) => [Char] -> a
error [Char]
"gunfold@Vec: invalid constrIndex"
instance Show a => Show (Vec n a) where
showsPrec :: Int -> Vec n a -> ShowS
showsPrec Int
p Vec n a
xs = Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
precedence)
forall a b. (a -> b) -> a -> b
$ [Char] -> ShowS
showString [Char]
"fromListN "
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> ShowS
shows (forall (n :: Nat) a. Vec n a -> Int
vSize Vec n a
xs)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> ShowS
showString [Char]
" "
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> ShowS
shows (forall (t :: Type -> Type) a. Foldable t => t a -> [a]
F.toList Vec n a
xs)
instance (KnownNat n, Read a) => Read (Vec n a) where
readsPrec :: Int -> ReadS (Vec n a)
readsPrec Int
p = forall a. Bool -> ReadS a -> ReadS a
readParen (Int
p forall a. Ord a => a -> a -> Bool
>= Int
precedence) forall a b. (a -> b) -> a -> b
$ \[Char]
s ->
[ forall b. Int -> b -> b
assertSize (forall (t :: Type -> Type) a. Foldable t => t a -> Int
length [a]
ls) (forall (n :: Nat) a.
(?callStack::CallStack) =>
SInt n -> Int -> [a] -> Vec n a
fromListN SInt n
n Int
m [a]
ls, [Char]
s''')
| ([Char]
"fromListN", [Char]
s') <- ReadS [Char]
lex [Char]
s
, (Int
m, [Char]
s'') <- forall a. Read a => Int -> ReadS a
readsPrec Int
precedence [Char]
s'
, ([a]
ls, [Char]
s''') <- forall b. Int -> b -> b
assertSize Int
m forall a. Read a => Int -> ReadS a
readsPrec Int
precedence [Char]
s''
]
where
n :: SInt n
n = forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal @n
assertSize :: Int -> b -> b
assertSize :: forall b. Int -> b -> b
assertSize Int
m b
x = if Int
m forall a. Eq a => a -> a -> Bool
/= forall (n :: Nat). SInt n -> Int
unSInt SInt n
n
then forall a. (?callStack::CallStack) => [Char] -> a
error forall a b. (a -> b) -> a -> b
$ [Char]
"Can't read a Vec with " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> [Char]
show Int
m forall a. Semigroup a => a -> a -> a
<>
[Char]
" elements into a type `Vec " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> [Char]
show SInt n
n forall a. Semigroup a => a -> a -> a
<>
[Char]
"`"
else b
x
precedence :: Int
precedence :: Int
precedence = Int
10
instance Portray a => Portray (Vec n a) where
portray :: Vec n a -> Portrayal
portray Vec n a
xs = Portrayal -> [Portrayal] -> Portrayal
Apply ([Char] -> Portrayal
strAtom [Char]
"fromListN")
[forall a. Portray a => a -> Portrayal
portray (forall (n :: Nat) a. Vec n a -> Int
vSize Vec n a
xs), forall a. Portray a => a -> Portrayal
portray forall a b. (a -> b) -> a -> b
$ forall (t :: Type -> Type) a. Foldable t => t a -> [a]
F.toList Vec n a
xs]
instance (Portray a, Diff a) => Diff (Vec n a) where
diff :: Vec n a -> Vec n a -> Maybe Portrayal
diff Vec n a
x Vec n a
y = (forall a. Diff a => a -> a -> Maybe Portrayal
diff forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` forall (t :: Type -> Type) a. Foldable t => t a -> [a]
F.toList) Vec n a
x Vec n a
y forall (f :: Type -> Type) a b. Functor f => f a -> (a -> b) -> f b
<&>
\Portrayal
d -> Portrayal -> [Portrayal] -> Portrayal
Apply ([Char] -> Portrayal
strAtom [Char]
"fromListN") [forall a. Portray a => a -> Portrayal
portray (forall (n :: Nat) a. Vec n a -> Int
vSize Vec n a
x), Portrayal
d]
instance NFData a => NFData (Vec n a) where
rnf :: Vec n a -> ()
rnf !Vec n a
xs = forall m (n :: Nat). Monoid m => SInt n -> (Fin n -> (# m #)) -> m
foldMapFin (forall (n :: Nat) a. Vec n a -> SInt n
svSize Vec n a
xs) forall a b. (a -> b) -> a -> b
$
\Fin n
i -> case forall (n :: Nat) a r. Vec n a -> Fin n -> (a -> r) -> r
indexK Vec n a
xs Fin n
i forall a. NFData a => a -> ()
rnf of () -> (# () #)
{-# INLINE rnf #-}
instance Semigroup a => Semigroup (Vec n a) where
<> :: Vec n a -> Vec n a -> Vec n a
(<>) = forall (f :: Type -> Type) a b c.
Apply f =>
(a -> b -> c) -> f a -> f b -> f c
liftF2 forall a. Semigroup a => a -> a -> a
(<>)
instance (KnownNat n, Monoid a) => Monoid (Vec n a) where
mempty :: Vec n a
mempty = forall (f :: Type -> Type) a. Applicative f => a -> f a
pure forall a. Monoid a => a
mempty
instance forall a n. (QC.Arbitrary a, KnownNat n) => QC.Arbitrary (Vec n a)
where
arbitrary :: Gen (Vec n a)
arbitrary = forall (n :: Nat) a. SInt n -> [a] -> Vec n a
listVec SInt n
sn forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Int -> Gen a -> Gen [a]
QC.vectorOf Int
n forall a. Arbitrary a => Gen a
QC.arbitrary
where
!sn :: SInt n
sn@(SI# Int
n) = forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal
shrink :: Vec n a -> [Vec n a]
shrink Vec n a
xs =
[ forall (n :: Nat) a. Fin n -> Vec n a -> a -> Vec n a
upd Fin n
i Vec n a
xs a
x'
| Fin n
i <- forall (n :: Nat) a. SInt n -> (Fin n -> a -> a) -> a -> a
foldrEnumFin SInt n
sn (:) [], a
x' <- forall (n :: Nat) a r. Vec n a -> Fin n -> (a -> r) -> r
indexK Vec n a
xs Fin n
i forall a. Arbitrary a => a -> [a]
QC.shrink
]
where
!sn :: SInt n
sn = forall (n :: Nat) a. Vec n a -> SInt n
svSize Vec n a
xs
upd :: Fin n -> Vec n a -> a -> Vec n a
upd :: forall (n :: Nat) a. Fin n -> Vec n a -> a -> Vec n a
upd Fin n
i Vec n a
xs a
x = forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
MutableVec s n a
mv <- forall (n :: Nat) a s. Vec n a -> ST s (MutableVec s n a)
safeThawMV Vec n a
xs
forall s (n :: Nat) a. MutableVec s n a -> Fin n -> a -> ST s ()
writeMV MutableVec s n a
mv Fin n
i a
x
forall s (n :: Nat) a. MutableVec s n a -> ST s (Vec n a)
unsafeFreezeMV MutableVec s n a
mv
{-# INLINE upd #-}
instance (Show a) => QC.CoArbitrary (Vec n a) where
coarbitrary :: forall b. Vec n a -> Gen b -> Gen b
coarbitrary = forall a b. Show a => a -> Gen b -> Gen b
QC.coarbitraryShow
instance (KnownNat n, Num a) => Num (Vec n a) where
+ :: Vec n a -> Vec n a -> Vec n a
(+) = forall (f :: Type -> Type) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 forall a. Num a => a -> a -> a
(+)
* :: Vec n a -> Vec n a -> Vec n a
(*) = forall (f :: Type -> Type) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 forall a. Num a => a -> a -> a
(*)
(-) = forall (f :: Type -> Type) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (-)
abs :: Vec n a -> Vec n a
abs = forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Num a => a -> a
abs
signum :: Vec n a -> Vec n a
signum = forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Num a => a -> a
signum
negate :: Vec n a -> Vec n a
negate = forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Num a => a -> a
negate
fromInteger :: Integer -> Vec n a
fromInteger = forall (f :: Type -> Type) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Num a => Integer -> a
fromInteger
instance (KnownNat n, Default a) => Default (Vec n a) where
def :: Vec n a
def = forall (f :: Type -> Type) a. Applicative f => a -> f a
pure forall a. Default a => a
def
instance Eq a => Eq (Vec n a) where
Vec n a
xs == :: Vec n a -> Vec n a -> Bool
== Vec n a
ys = All -> Bool
getAll forall a b. (a -> b) -> a -> b
$ forall (t :: Type -> Type) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Bool -> All
All forall a b. (a -> b) -> a -> b
$ forall (f :: Type -> Type) a b c.
Apply f =>
(a -> b -> c) -> f a -> f b -> f c
liftF2 forall a. Eq a => a -> a -> Bool
(==) Vec n a
xs Vec n a
ys
Vec n a
xs /= :: Vec n a -> Vec n a -> Bool
/= Vec n a
ys = Any -> Bool
getAny forall a b. (a -> b) -> a -> b
$ forall (t :: Type -> Type) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Bool -> Any
Any forall a b. (a -> b) -> a -> b
$ forall (f :: Type -> Type) a b c.
Apply f =>
(a -> b -> c) -> f a -> f b -> f c
liftF2 forall a. Eq a => a -> a -> Bool
(/=) Vec n a
xs Vec n a
ys
instance Ord a => Ord (Vec n a) where
compare :: Vec n a -> Vec n a -> Ordering
compare Vec n a
xs Vec n a
ys = forall (t :: Type -> Type) m. (Foldable t, Monoid m) => t m -> m
F.fold forall a b. (a -> b) -> a -> b
$ forall (f :: Type -> Type) a b c.
Apply f =>
(a -> b -> c) -> f a -> f b -> f c
liftF2 forall a. Ord a => a -> a -> Ordering
compare Vec n a
xs Vec n a
ys
mapVec :: (a -> b) -> Vec n a -> Vec n b
mapVec :: forall a b (n :: Nat). (a -> b) -> Vec n a -> Vec n b
mapVec a -> b
f = forall (n :: Nat) a. Accessor n a -> Vec n a
materialize forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b (n :: Nat). (a -> b) -> Accessor n a -> Accessor n b
mapVA a -> b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Vec n a -> Accessor n a
access
{-# INLINE mapVec #-}
{-# RULES
"mapVec/merge" forall f g va. mapVA f (mapVA g va) = mapVA (f . g) va
"mapVec/coerce" [1] forall v. materialize (mapVA coerce (access v)) = coerce v
"mapVec/id" mapVA (\x -> x) = id
#-}
instance Functor (Vec n) where
fmap :: forall a b. (a -> b) -> Vec n a -> Vec n b
fmap = forall a b (n :: Nat). (a -> b) -> Vec n a -> Vec n b
mapVec
a
x <$ :: forall a b. a -> Vec n b -> Vec n a
<$ Vec n b
v = forall (n :: Nat) a. SInt n -> a -> Vec n a
pureVec (forall (n :: Nat) a. Accessor n a -> SInt n
_aSize (forall (n :: Nat) a. Vec n a -> Accessor n a
access Vec n b
v)) a
x
{-# INLINE (<$) #-}
instance FunctorWithIndex (Fin n) (Vec n) where imap :: forall a b. (Fin n -> a -> b) -> Vec n a -> Vec n b
imap = forall (n :: Nat) a b. (Fin n -> a -> b) -> Vec n a -> Vec n b
imap
instance KnownNat n => FoldableWithIndex (Fin n) (Vec n) where
ifoldMap :: forall m a. Monoid m => (Fin n -> a -> m) -> Vec n a -> m
ifoldMap Fin n -> a -> m
f = forall (t :: Type -> Type) m. (Foldable t, Monoid m) => t m -> m
F.fold forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a b. (Fin n -> a -> b) -> Vec n a -> Vec n b
imap Fin n -> a -> m
f
instance KnownNat n => TraversableWithIndex (Fin n) (Vec n) where
itraverse :: forall (f :: Type -> Type) a b.
Applicative f =>
(Fin n -> a -> f b) -> Vec n a -> f (Vec n b)
itraverse Fin n -> a -> f b
f = forall (t :: Type -> Type) (f :: Type -> Type) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
sequenceA forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a b. (Fin n -> a -> b) -> Vec n a -> Vec n b
imap Fin n -> a -> f b
f
map' :: (a -> b) -> Vec n a -> Vec n b
map' :: forall a b (n :: Nat). (a -> b) -> Vec n a -> Vec n b
map' a -> b
f = forall (n :: Nat) a. Accessor n a -> Vec n a
materialize forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Accessor n a -> Accessor n a
seqVA forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b (n :: Nat). (a -> b) -> Accessor n a -> Accessor n b
mapVA a -> b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Vec n a -> Accessor n a
access
{-# INLINE map' #-}
imap :: (Fin n -> a -> b) -> Vec n a -> Vec n b
imap :: forall (n :: Nat) a b. (Fin n -> a -> b) -> Vec n a -> Vec n b
imap Fin n -> a -> b
f = forall (n :: Nat) a. Accessor n a -> Vec n a
materialize forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a b.
(Fin n -> a -> b) -> Accessor n a -> Accessor n b
mapWithPosVA Fin n -> a -> b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Vec n a -> Accessor n a
access
{-# INLINE imap #-}
withPos :: Vec n a -> Vec n (Fin n, a)
withPos :: forall (n :: Nat) a. Vec n a -> Vec n (Fin n, a)
withPos = forall (n :: Nat) a b. (Fin n -> a -> b) -> Vec n a -> Vec n b
imap (,)
{-# INLINE withPos #-}
imap' :: (Fin n -> a -> b) -> Vec n a -> Vec n b
imap' :: forall (n :: Nat) a b. (Fin n -> a -> b) -> Vec n a -> Vec n b
imap' Fin n -> a -> b
f = forall (n :: Nat) a. Accessor n a -> Vec n a
materialize forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Accessor n a -> Accessor n a
seqVA forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a b.
(Fin n -> a -> b) -> Accessor n a -> Accessor n b
mapWithPosVA Fin n -> a -> b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Vec n a -> Accessor n a
access
{-# INLINE imap' #-}
pureVec_, pureVec :: SInt n -> a -> Vec n a
pureVec_ :: forall (n :: Nat) a. SInt n -> a -> Vec n a
pureVec_ SInt n
n a
x = forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ forall (n :: Nat) a s. SInt n -> a -> ST s (MutableVec s n a)
newMV SInt n
n a
x forall (m :: Type -> Type) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall s (n :: Nat) a. MutableVec s n a -> ST s (Vec n a)
unsafeFreezeMV
{-# NOINLINE pureVec_ #-}
pureVec :: forall (n :: Nat) a. SInt n -> a -> Vec n a
pureVec = \SInt n
n a
x -> forall (n :: Nat) a. Accessor n a -> Vec n a
materialize (forall (n :: Nat) a. SInt n -> a -> Accessor n a
pureVA SInt n
n a
x)
{-# INLINE pureVec #-}
{-# RULES
"pureVec/spec" [1] forall n x. materialize (pureVA n x) = pureVec_ n x
"mapVA/pureVA" forall f n x. mapVA f (pureVA n x) = pureVA n (f x)
#-}
liftA2Vec :: (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
liftA2Vec :: forall a b c (n :: Nat).
(a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
liftA2Vec a -> b -> c
f Vec n a
as Vec n b
bs = forall (n :: Nat) a. Accessor n a -> Vec n a
materialize (forall a b c (n :: Nat).
(a -> b -> c) -> Accessor n a -> Accessor n b -> Accessor n c
liftA2VA a -> b -> c
f (forall (n :: Nat) a. Vec n a -> Accessor n a
access Vec n a
as) (forall (n :: Nat) a. Vec n a -> Accessor n a
access Vec n b
bs))
{-# INLINE liftA2Vec #-}
instance Apply (Vec n) where
liftF2 :: forall a b c. (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
liftF2 = forall a b c (n :: Nat).
(a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
liftA2Vec
{-# INLINE liftF2 #-}
instance KnownNat n => Applicative (Vec n) where
pure :: forall a. a -> Vec n a
pure = forall (n :: Nat) a. SInt n -> a -> Vec n a
pureVec forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal
{-# INLINE pure #-}
liftA2 :: forall a b c. (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
liftA2 = forall a b c (n :: Nat).
(a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
liftA2Vec
{-# INLINE liftA2 #-}
<*> :: forall a b. Vec n (a -> b) -> Vec n a -> Vec n b
(<*>) = forall a b c (n :: Nat).
(a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
liftA2Vec forall a b. (a -> b) -> a -> b
($)
{-# INLINE (<*>) #-}
Vec n a
_ *> :: forall a b. Vec n a -> Vec n b -> Vec n b
*> Vec n b
ys = Vec n b
ys
{-# INLINE (*>) #-}
Vec n a
xs <* :: forall a b. Vec n a -> Vec n b -> Vec n a
<* Vec n b
_ = Vec n a
xs
{-# INLINE (<*) #-}
instance Bind (Vec n) where
Vec n a
xs >>- :: forall a b. Vec n a -> (a -> Vec n b) -> Vec n b
>>- a -> Vec n b
f = forall (n :: Nat) a. Accessor n a -> Vec n a
materialize (case forall (n :: Nat) a. Vec n a -> Accessor n a
access Vec n a
xs of
Accessor SInt n
n Fin n -> (# a #)
get -> forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor SInt n
n (\Fin n
i -> case Fin n -> (# a #)
get Fin n
i of
(# a
x #) -> a -> Vec n b
f a
x forall (n :: Nat) a. Vec n a -> Fin n -> (# a #)
`fusibleFetch` Fin n
i))
{-# INLINE (>>-) #-}
instance KnownNat n => Monad (Vec n) where >>= :: forall a b. Vec n a -> (a -> Vec n b) -> Vec n b
(>>=) = forall (m :: Type -> Type) a b. Bind m => m a -> (a -> m b) -> m b
(>>-)
liftA2Lazy :: SInt n -> (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
liftA2Lazy :: forall (n :: Nat) a b c.
SInt n -> (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
liftA2Lazy SInt n
sn a -> b -> c
f Vec n a
xs Vec n b
ys = forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
tabulateVec SInt n
sn forall a b. (a -> b) -> a -> b
$ \Fin n
i ->
forall (n :: Nat) a r. Vec n a -> Fin n -> (a -> r) -> r
indexK Vec n a
xs Fin n
i forall a b. (a -> b) -> a -> b
$ \a
x ->
forall (n :: Nat) a r. Vec n a -> Fin n -> (a -> r) -> r
indexK Vec n b
ys Fin n
i forall a b. (a -> b) -> a -> b
$ \b
y ->
a -> b -> c
f a
x b
y
unsafeIndexK :: Vec n a -> Int -> (a -> r) -> r
unsafeIndexK :: forall (n :: Nat) a r. Vec n a -> Int -> (a -> r) -> r
unsafeIndexK (V# SmallArray# a
sa) (I# Int#
i) a -> r
k = case forall a. SmallArray# a -> Int# -> (# a #)
indexSmallArray# SmallArray# a
sa Int#
i of (# a
x #) -> a -> r
k a
x
{-# INLINE unsafeIndexK #-}
instance Foldable (Vec n) where
length :: forall a. Vec n a -> Int
length = forall (n :: Nat) a. Vec n a -> Int
vSize
{-# INLINE length #-}
null :: forall a. Vec n a -> Bool
null = (Int
0 forall a. Eq a => a -> a -> Bool
==) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: Type -> Type) a. Foldable t => t a -> Int
length
{-# INLINE null #-}
foldMap :: forall m a. Monoid m => (a -> m) -> Vec n a -> m
foldMap a -> m
f = forall m a (n :: Nat). Monoid m => (a -> m) -> Accessor n a -> m
foldMapVA a -> m
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Vec n a -> Accessor n a
access
{-# INLINE foldMap #-}
fold :: forall m. Monoid m => Vec n m -> m
fold = forall m a (n :: Nat). Monoid m => (a -> m) -> Accessor n a -> m
foldMapVA forall a. a -> a
id forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Vec n a -> Accessor n a
access
{-# INLINE fold #-}
foldr :: forall a b. (a -> b -> b) -> b -> Vec n a -> b
foldr a -> b -> b
f b
acc0 = \Vec n a
v ->
let Accessor SInt n
n Fin n -> (# a #)
get = forall (n :: Nat) a. Vec n a -> Accessor n a
access Vec n a
v
in forall (n :: Nat) a. SInt n -> (Fin n -> a -> a) -> a -> a
foldrEnumFin SInt n
n
(\Fin n
i b
acc -> case Fin n -> (# a #)
get Fin n
i of (# a
x #) -> a -> b -> b
f a
x b
acc)
b
acc0
{-# INLINE foldr #-}
foldr' :: forall a b. (a -> b -> b) -> b -> Vec n a -> b
foldr' a -> b -> b
f b
acc0 = \Vec n a
v ->
let !(Accessor SInt n
n Fin n -> (# a #)
get) = forall (n :: Nat) a. Vec n a -> Accessor n a
access Vec n a
v
go :: Int -> b -> b
go !Int
i !b
acc
| Int
i forall a. Ord a => a -> a -> Bool
< Int
0 = b
acc
| Bool
otherwise =
case Fin n -> (# a #)
get (forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin Int
i) of (# a
x #) -> Int -> b -> b
go (Int
i forall a. Num a => a -> a -> a
- Int
1) (a -> b -> b
f a
x b
acc)
in Int -> b -> b
go (forall (n :: Nat). SInt n -> Int
unSInt SInt n
n forall a. Num a => a -> a -> a
- Int
1) b
acc0
{-# INLINE foldr' #-}
foldl :: forall b a. (b -> a -> b) -> b -> Vec n a -> b
foldl b -> a -> b
f b
acc0 = \Vec n a
v ->
let !(Accessor SInt n
n Fin n -> (# a #)
get) = forall (n :: Nat) a. Vec n a -> Accessor n a
access Vec n a
v
go :: Int -> b
go !Int
i
| Int
i forall a. Ord a => a -> a -> Bool
< Int
0 = b
acc0
| Bool
otherwise = case Fin n -> (# a #)
get (forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin Int
i) of (# a
x #) -> b -> a -> b
f (Int -> b
go (Int
i forall a. Num a => a -> a -> a
- Int
1)) a
x
in Int -> b
go (forall (n :: Nat). SInt n -> Int
unSInt SInt n
n forall a. Num a => a -> a -> a
- Int
1)
{-# INLINE foldl #-}
foldl' :: forall b a. (b -> a -> b) -> b -> Vec n a -> b
foldl' b -> a -> b
f b
acc0 = \Vec n a
v ->
let !(Accessor (forall (n :: Nat). SInt n -> Int
unSInt -> !Int
n) Fin n -> (# a #)
get) = forall (n :: Nat) a. Vec n a -> Accessor n a
access Vec n a
v
go :: Int -> b -> b
go !Int
i !b
acc
| Int
i forall a. Ord a => a -> a -> Bool
>= Int
n = b
acc
| Bool
otherwise =
case Fin n -> (# a #)
get (forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin Int
i) of (# a
a #) -> Int -> b -> b
go (Int
iforall a. Num a => a -> a -> a
+Int
1) (b -> a -> b
f b
acc a
a)
in Int -> b -> b
go Int
0 b
acc0
{-# INLINE foldl' #-}
foldr1 :: forall a. (a -> a -> a) -> Vec n a -> a
foldr1 a -> a -> a
f = \Vec n a
v ->
case forall (n :: Nat) a. Vec n a -> Accessor n a
access Vec n a
v of
Accessor (forall a. Num a => a -> a -> a
subtract Int
1 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat). SInt n -> Int
unSInt -> Int
lMinus1) Fin n -> (# a #)
get
| Int
lMinus1 forall a. Ord a => a -> a -> Bool
< Int
0 -> forall a. (?callStack::CallStack) => [Char] -> a
error [Char]
"foldr1@Vec: empty list"
| Bool
otherwise ->
let !(# a
z #) = Fin n -> (# a #)
get (forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin Int
lMinus1)
go :: Int -> a
go !Int
i | Int
i forall a. Ord a => a -> a -> Bool
>= Int
lMinus1 = a
z
| Bool
otherwise =
let !(# a
x #) = Fin n -> (# a #)
get (forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin Int
i)
in a -> a -> a
f a
x (Int -> a
go (Int
i forall a. Num a => a -> a -> a
+ Int
1))
in Int -> a
go Int
0
{-# INLINE foldr1 #-}
foldl1 :: forall a. (a -> a -> a) -> Vec n a -> a
foldl1 a -> a -> a
f = \Vec n a
v ->
case forall (n :: Nat) a. Vec n a -> Accessor n a
access Vec n a
v of
Accessor (forall a. Num a => a -> a -> a
subtract Int
1 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat). SInt n -> Int
unSInt -> Int
lMinus1) Fin n -> (# a #)
get
| Int
lMinus1 forall a. Ord a => a -> a -> Bool
< Int
0 -> forall a. (?callStack::CallStack) => [Char] -> a
error [Char]
"foldl1@Vec: empty list"
| Bool
otherwise ->
let !(# a
z #) = Fin n -> (# a #)
get (forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin (Int
0 :: Int))
go :: Int -> a
go !Int
i | Int
i forall a. Ord a => a -> a -> Bool
<= Int
0 = a
z
| Bool
otherwise =
let !(# a
x #) = Fin n -> (# a #)
get (forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin Int
i)
in a -> a -> a
f (Int -> a
go (Int
i forall a. Num a => a -> a -> a
- Int
1)) a
x
in Int -> a
go Int
lMinus1
{-# INLINE foldl1 #-}
sum :: forall a. Num a => Vec n a -> a
sum = coerce :: forall a b. Coercible a b => a -> b
coerce forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: Type -> Type) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap forall a. a -> Sum a
Sum
{-# INLINE sum #-}
product :: forall a. Num a => Vec n a -> a
product = coerce :: forall a b. Coercible a b => a -> b
coerce forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: Type -> Type) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap forall a. a -> Product a
Product
{-# INLINE product #-}
minimum :: forall a. Ord a => Vec n a -> a
minimum = forall (t :: Type -> Type) a.
Foldable t =>
(a -> a -> a) -> t a -> a
foldr1 forall a. Ord a => a -> a -> a
min
{-# INLINE minimum #-}
maximum :: forall a. Ord a => Vec n a -> a
maximum = forall (t :: Type -> Type) a.
Foldable t =>
(a -> a -> a) -> t a -> a
foldr1 forall a. Ord a => a -> a -> a
max
{-# INLINE maximum #-}
elem :: forall a. Eq a => a -> Vec n a -> Bool
elem a
x = coerce :: forall a b. Coercible a b => a -> b
coerce forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: Type -> Type) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (Bool -> Any
Any forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. Eq a => a -> a -> Bool
== a
x))
{-# INLINE elem #-}
traverseVec :: Applicative f => (a -> f b) -> Vec n a -> f (Vec n b)
traverseVec :: forall (f :: Type -> Type) a b (n :: Nat).
Applicative f =>
(a -> f b) -> Vec n a -> f (Vec n b)
traverseVec a -> f b
f = forall (f :: Type -> Type) (n :: Nat) a.
Applicative f =>
Accessor n (f a) -> f (Vec n a)
sequenceVA forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b (n :: Nat). (a -> b) -> Accessor n a -> Accessor n b
mapVA a -> f b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Vec n a -> Accessor n a
access
{-# INLINE traverseVec #-}
instance Traversable (Vec n) where
traverse :: forall (f :: Type -> Type) a b.
Applicative f =>
(a -> f b) -> Vec n a -> f (Vec n b)
traverse = forall (f :: Type -> Type) a b (n :: Nat).
Applicative f =>
(a -> f b) -> Vec n a -> f (Vec n b)
traverseVec
{-# INLINE traverse #-}
instance KnownNat n => Distributive (Vec n) where
distribute :: forall (f :: Type -> Type) a.
Functor f =>
f (Vec n a) -> Vec n (f a)
distribute f (Vec n a)
fxs = forall (f :: Type -> Type) a.
Representable f =>
(Rep f -> a) -> f a
tabulate forall a b. (a -> b) -> a -> b
$ \Rep (Vec n)
i -> forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall (n :: Nat) a. Vec n a -> Fin n -> a
! Rep (Vec n)
i) f (Vec n a)
fxs
{-# INLINE distribute #-}
instance KnownNat n => Representable (Vec n) where
type Rep (Vec n) = Fin n
tabulate :: forall a. (Rep (Vec n) -> a) -> Vec n a
tabulate = forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
tabulateVec forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal
{-# INLINE tabulate #-}
index :: forall a. Vec n a -> Rep (Vec n) -> a
index = forall (n :: Nat) a. Vec n a -> Fin n -> a
(!)
{-# INLINE index #-}
vscanl :: (b -> a -> b) -> b -> Vec n a -> Vec (1 + n) b
vscanl :: forall b a (n :: Nat).
(b -> a -> b) -> b -> Vec n a -> Vec (1 + n) b
vscanl b -> a -> b
f b
b Vec n a
v = forall (n :: Nat) a. SInt n -> [a] -> Vec n a
listVec (forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal forall (m :: Nat) (n :: Nat).
(?callStack::CallStack) =>
SInt m -> SInt n -> SInt (m + n)
`addSInt` forall (n :: Nat) a. Vec n a -> SInt n
svSize Vec n a
v) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b a. (b -> a -> b) -> b -> [a] -> [b]
scanl b -> a -> b
f b
b forall a b. (a -> b) -> a -> b
$ forall (t :: Type -> Type) a. Foldable t => t a -> [a]
F.toList Vec n a
v
nil :: Vec 0 a
nil :: forall a. Vec 0 a
nil = forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
mkVec forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal (\Fin 0
i -> Fin 0
i seq :: forall a b. a -> b -> b
`seq` forall a. (?callStack::CallStack) => [Char] -> a
error [Char]
"Vec.nil: the impossible happened")
{-# NOINLINE nil #-}
{-# RULES
-- Note this matches only zero-length vectors because the LHS type is unified
-- with the RHS type.
"materialize@0" forall va. materialize va = nil
#-}
infixr 5 ++
append_, (++) :: Vec n a -> Vec m a -> Vec (n + m) a
append_ :: forall (n :: Nat) a (m :: Nat). Vec n a -> Vec m a -> Vec (n + m) a
append_ Vec n a
xs Vec m a
ys = forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
let !n :: Int
n = forall (n :: Nat) a. Vec n a -> Int
vSize Vec n a
xs
!m :: Int
m = forall (n :: Nat) a. Vec n a -> Int
vSize Vec m a
ys
MutableVec s (n + m) a
zs <- forall a s (n :: Nat). Int -> a -> ST s (MutableVec s n a)
unsafeNewMV (Int
n forall a. Num a => a -> a -> a
+ Int
m) forall a. a
uninitialized
forall (n :: Nat) a s (m :: Nat).
Vec n a -> Int -> MutableVec s m a -> Int -> Int -> ST s ()
unsafeCopyVec Vec n a
xs Int
0 MutableVec s (n + m) a
zs Int
0 Int
n
forall (n :: Nat) a s (m :: Nat).
Vec n a -> Int -> MutableVec s m a -> Int -> Int -> ST s ()
unsafeCopyVec Vec m a
ys Int
0 MutableVec s (n + m) a
zs Int
n Int
m
forall s (n :: Nat) a. MutableVec s n a -> ST s (Vec n a)
unsafeFreezeMV MutableVec s (n + m) a
zs
{-# NOINLINE append_ #-}
++ :: forall (n :: Nat) a (m :: Nat). Vec n a -> Vec m a -> Vec (n + m) a
(++) = \Vec n a
xs Vec m a
ys -> forall (n :: Nat) a. Accessor n a -> Vec n a
materialize (forall (n :: Nat) a (m :: Nat).
Accessor n a -> Accessor m a -> Accessor (n + m) a
appendVA (forall (n :: Nat) a. Vec n a -> Accessor n a
access Vec n a
xs) (forall (n :: Nat) a. Vec n a -> Accessor n a
access Vec m a
ys))
{-# INLINE (++) #-}
{-# RULES
"++/spec" [1]
forall xs ys. materialize (appendVA (access xs) (access ys)) = xs `append_` ys
#-}
take_ :: SInt m -> Vec (m + n) a -> Vec m a
take_ :: forall (m :: Nat) (n :: Nat) a. SInt m -> Vec (m + n) a -> Vec m a
take_ SInt m
m Vec (m + n) a
xs = forall (n :: Nat) a (m :: Nat). Vec n a -> Int -> SInt m -> Vec m a
sliceVec Vec (m + n) a
xs Int
0 SInt m
m
{-# NOINLINE take_ #-}
{-# RULES
"take_/spec" [1] forall m xs. materialize (takeVA m (access xs)) = take_ m xs
#-}
drop_ :: forall m n a. SInt m -> Vec (m + n) a -> Vec n a
drop_ :: forall (m :: Nat) (n :: Nat) a. SInt m -> Vec (m + n) a -> Vec n a
drop_ SInt m
m Vec (m + n) a
xs =
forall (n :: Nat) a (m :: Nat). Vec n a -> Int -> SInt m -> Vec m a
sliceVec Vec (m + n) a
xs (forall (n :: Nat). SInt n -> Int
unSInt SInt m
m) forall a b. (a -> b) -> a -> b
$
forall (n :: Nat) a. Vec n a -> SInt n
svSize Vec (m + n) a
xs forall (m :: Nat) (n :: Nat). SInt (m + n) -> SInt m -> SInt n
`subSIntL` SInt m
m
{-# NOINLINE drop_ #-}
{-# RULES
"drop_/spec" [1] forall m xs. materialize (dropVA m (access xs)) = drop_ m xs
#-}
split
:: forall m n a. SInt m -> Vec (m + n) a -> (Vec m a, Vec n a)
split :: forall (m :: Nat) (n :: Nat) a.
SInt m -> Vec (m + n) a -> (Vec m a, Vec n a)
split SInt m
m Vec (m + n) a
xs =
let va :: Accessor (m + n) a
va = forall (n :: Nat) a. Vec n a -> Accessor n a
access Vec (m + n) a
xs
in (forall (n :: Nat) a. Accessor n a -> Vec n a
materialize (forall (m :: Nat) (n :: Nat) a.
SInt m -> Accessor (m + n) a -> Accessor m a
takeVA SInt m
m Accessor (m + n) a
va), forall (n :: Nat) a. Accessor n a -> Vec n a
materialize (forall (m :: Nat) (n :: Nat) a.
SInt m -> Accessor (m + n) a -> Accessor n a
dropVA SInt m
m Accessor (m + n) a
va))
{-# INLINE split #-}
concat :: forall m n a. Vec n (Vec m a) -> Vec (n * m) a
concat :: forall (m :: Nat) (n :: Nat) a. Vec n (Vec m a) -> Vec (n * m) a
concat Vec n (Vec m a)
xs =
let !n :: Int
n = forall (n :: Nat) a. Vec n a -> Int
vSize Vec n (Vec m a)
xs
in if Int
n forall a. Eq a => a -> a -> Bool
== Int
0 then
forall (n :: Nat) a.
Int -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
unsafeCreateVec Int
0 forall a b. (a -> b) -> a -> b
$ \ MutableVec s (n * m) a
_ -> forall (m :: Type -> Type) a. Monad m => a -> m a
return ()
else
let !m :: Int
m = forall (n :: Nat) a r. Vec n a -> Int -> (a -> r) -> r
unsafeIndexK Vec n (Vec m a)
xs Int
0 forall (n :: Nat) a. Vec n a -> Int
vSize
in forall (n :: Nat) a.
Int -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
unsafeCreateVec (Int
n forall a. Num a => a -> a -> a
* Int
m) forall a b. (a -> b) -> a -> b
$ \ MutableVec s (n * m) a
marr ->
forall (t :: Type -> Type) (m :: Type -> Type) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
F.forM_ [Int
0..Int
nforall a. Num a => a -> a -> a
-Int
1] forall a b. (a -> b) -> a -> b
$ \ Int
i ->
forall (n :: Nat) a r. Vec n a -> Int -> (a -> r) -> r
unsafeIndexK Vec n (Vec m a)
xs Int
i forall a b. (a -> b) -> a -> b
$ \ Vec m a
ys ->
forall (n :: Nat) a s (m :: Nat).
Vec n a -> Int -> MutableVec s m a -> Int -> Int -> ST s ()
unsafeCopyVec Vec m a
ys Int
0 MutableVec s (n * m) a
marr (Int
i forall a. Num a => a -> a -> a
* Int
m) Int
m
{-# INLINE concat #-}
reshape :: SInt m -> Vec (n * m) a -> Vec n (Vec m a)
reshape :: forall (m :: Nat) (n :: Nat) a.
SInt m -> Vec (n * m) a -> Vec n (Vec m a)
reshape SInt m
m =
let !m' :: Int
m' = forall (n :: Nat). SInt n -> Int
unSInt SInt m
m
in \Vec (n * m) a
xs ->
forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
mkVec (forall (n :: Nat) a. Vec n a -> SInt n
svSize Vec (n * m) a
xs forall (m :: Nat) (n :: Nat). SInt (m * n) -> SInt n -> SInt m
`divSIntR` SInt m
m) (\Fin n
i -> forall (n :: Nat) a (m :: Nat). Vec n a -> Int -> SInt m -> Vec m a
sliceVec Vec (n * m) a
xs (forall (n :: Nat). Fin n -> Int
finToInt Fin n
i forall a. Num a => a -> a -> a
* Int
m') SInt m
m)
{-# INLINE reshape #-}
concatMap :: forall m n a b. (a -> Vec m b) -> Vec n a -> Vec (n * m) b
concatMap :: forall (m :: Nat) (n :: Nat) a b.
(a -> Vec m b) -> Vec n a -> Vec (n * m) b
concatMap a -> Vec m b
f = forall (m :: Nat) (n :: Nat) a. Vec n (Vec m a) -> Vec (n * m) a
concat forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Vec m b
f
{-# INLINE concatMap #-}
iterate :: SInt n -> (a -> a) -> a -> Vec n a
iterate :: forall (n :: Nat) a. SInt n -> (a -> a) -> a -> Vec n a
iterate SInt n
sn a -> a
f a
z =
forall (n :: Nat) a.
SInt n -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
createVec SInt n
sn forall a b. (a -> b) -> a -> b
$ \MutableVec s n a
mv ->
forall (m :: Type -> Type) (n :: Nat) a.
Monad m =>
SInt n -> (a -> Fin n -> m a) -> a -> m ()
foldMFin_ SInt n
sn (\a
x Fin n
i -> a -> a
f a
x forall (f :: Type -> Type) a b. Functor f => a -> f b -> f a
<$ forall s (n :: Nat) a. MutableVec s n a -> Fin n -> a -> ST s ()
writeMV MutableVec s n a
mv Fin n
i a
x) a
z
{-# INLINE iterate #-}
iterate' :: SInt n -> (a -> a) -> a -> Vec n a
iterate' :: forall (n :: Nat) a. SInt n -> (a -> a) -> a -> Vec n a
iterate' SInt n
sn a -> a
f !a
z =
forall (n :: Nat) a.
SInt n -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
createVec SInt n
sn forall a b. (a -> b) -> a -> b
$ \MutableVec s n a
mv ->
forall (m :: Type -> Type) (n :: Nat) a.
Monad m =>
SInt n -> (a -> Fin n -> m a) -> a -> m ()
foldMFin_ SInt n
sn (\a
x Fin n
i -> a -> a
f a
x forall (f :: Type -> Type) a b. Functor f => a -> f b -> f a
<$ (forall s (n :: Nat) a. MutableVec s n a -> Fin n -> a -> ST s ()
writeMV MutableVec s n a
mv Fin n
i forall a b. (a -> b) -> a -> b
$! a
x)) a
z
{-# INLINE iterate' #-}
rev :: Vec n a -> Vec n a
rev :: forall (n :: Nat) a. Vec n a -> Vec n a
rev = forall (n :: Nat) a. Accessor n a -> Vec n a
materialize forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Accessor n a -> Accessor n a
revVA forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) a. Vec n a -> Accessor n a
access
{-# INLINE rev #-}
rot, rot_ :: Fin n -> Vec n a -> Vec n a
rot_ :: forall (n :: Nat) a. Fin n -> Vec n a -> Vec n a
rot_ Fin n
o' Vec n a
xs = forall (n :: Nat) a.
SInt n -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
createVec (forall (n :: Nat) a. Vec n a -> SInt n
svSize Vec n a
xs) forall a b. (a -> b) -> a -> b
$ \MutableVec s n a
mv -> do
let o :: Int
o = forall (n :: Nat). Fin n -> Int
finToInt Fin n
o'
nmo :: Int
nmo = forall (n :: Nat) a. Vec n a -> Int
vSize Vec n a
xs forall a. Num a => a -> a -> a
- Int
o
forall (n :: Nat) a s (m :: Nat).
Vec n a -> Int -> MutableVec s m a -> Int -> Int -> ST s ()
unsafeCopyVec Vec n a
xs Int
nmo MutableVec s n a
mv Int
0 Int
o
forall (n :: Nat) a s (m :: Nat).
Vec n a -> Int -> MutableVec s m a -> Int -> Int -> ST s ()
unsafeCopyVec Vec n a
xs Int
0 MutableVec s n a
mv Int
o Int
nmo
{-# NOINLINE rot_ #-}
rot :: forall (n :: Nat) a. Fin n -> Vec n a -> Vec n a
rot Fin n
o = \Vec n a
v -> forall (n :: Nat) a. Accessor n a -> Vec n a
materialize (forall (n :: Nat) a. Fin n -> Accessor n a -> Accessor n a
rotVA Fin n
o (forall (n :: Nat) a. Vec n a -> Accessor n a
access Vec n a
v))
{-# INLINE rot #-}
{-# RULES
"rot/spec" [1] forall o v. materialize (rotVA o (access v)) = rot_ o v
#-}
viota :: SInt n -> Vec n (Fin n)
viota :: forall (n :: Nat). SInt n -> Vec n (Fin n)
viota SInt n
sn = forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
mkVec SInt n
sn forall a. a -> a
id
{-# INLINE viota #-}
cross :: Vec m a -> Vec n b -> Vec n (Vec m (a, b))
cross :: forall (m :: Nat) a (n :: Nat) b.
Vec m a -> Vec n b -> Vec n (Vec m (a, b))
cross Vec m a
xs = forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap (\b
y -> forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap (, b
y) Vec m a
xs)
{-# INLINE cross #-}
unsafeInsert :: Int -> a -> Vec n a -> Vec (n+1) a
unsafeInsert :: forall a (n :: Nat). Int -> a -> Vec n a -> Vec (n + 1) a
unsafeInsert Int
i a
xi Vec n a
xs =
let !n :: Int
n = forall (n :: Nat) a. Vec n a -> Int
vSize Vec n a
xs
in forall (n :: Nat) a.
Int -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
unsafeCreateVec (Int
nforall a. Num a => a -> a -> a
+Int
1) forall a b. (a -> b) -> a -> b
$ \ MutableVec s (n + 1) a
mv -> do
forall (n :: Nat) a s (m :: Nat).
Vec n a -> Int -> MutableVec s m a -> Int -> Int -> ST s ()
unsafeCopyVec Vec n a
xs Int
0 MutableVec s (n + 1) a
mv Int
0 Int
i
forall s (n :: Nat) a. MutableVec s n a -> Int -> a -> ST s ()
unsafeWriteMV MutableVec s (n + 1) a
mv Int
i a
xi
forall (n :: Nat) a s (m :: Nat).
Vec n a -> Int -> MutableVec s m a -> Int -> Int -> ST s ()
unsafeCopyVec Vec n a
xs Int
i MutableVec s (n + 1) a
mv (Int
i forall a. Num a => a -> a -> a
+ Int
1) (Int
n forall a. Num a => a -> a -> a
- Int
i)
insert :: Fin (n+1) -> a -> Vec n a -> Vec (n+1) a
insert :: forall (n :: Nat) a. Fin (n + 1) -> a -> Vec n a -> Vec (n + 1) a
insert Fin (n + 1)
i = forall a (n :: Nat). Int -> a -> Vec n a -> Vec (n + 1) a
unsafeInsert (forall (n :: Nat). Fin n -> Int
finToInt Fin (n + 1)
i)
unsafeRemove :: Int -> Vec (n+1) a -> Vec n a
unsafeRemove :: forall (n :: Nat) a. Int -> Vec (n + 1) a -> Vec n a
unsafeRemove Int
i Vec (n + 1) a
xs =
let !np1 :: Int
np1 = forall (n :: Nat) a. Vec n a -> Int
vSize Vec (n + 1) a
xs
in forall (n :: Nat) a.
Int -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
unsafeCreateVec (Int
np1 forall a. Num a => a -> a -> a
- Int
1) forall a b. (a -> b) -> a -> b
$ \ MutableVec s n a
mv -> do
forall (n :: Nat) a s (m :: Nat).
Vec n a -> Int -> MutableVec s m a -> Int -> Int -> ST s ()
unsafeCopyVec Vec (n + 1) a
xs Int
0 MutableVec s n a
mv Int
0 Int
i
forall (n :: Nat) a s (m :: Nat).
Vec n a -> Int -> MutableVec s m a -> Int -> Int -> ST s ()
unsafeCopyVec Vec (n + 1) a
xs (Int
iforall a. Num a => a -> a -> a
+Int
1) MutableVec s n a
mv Int
i (Int
np1 forall a. Num a => a -> a -> a
- Int
1 forall a. Num a => a -> a -> a
- Int
i)
remove :: Fin (n+1) -> Vec (n+1) a -> Vec n a
remove :: forall (n :: Nat) a. Fin (n + 1) -> Vec (n + 1) a -> Vec n a
remove Fin (n + 1)
i = forall (n :: Nat) a. Int -> Vec (n + 1) a -> Vec n a
unsafeRemove (forall (n :: Nat). Fin n -> Int
finToInt Fin (n + 1)
i)
vsort :: Ord a => Vec n a -> Vec n a
vsort :: forall a (n :: Nat). Ord a => Vec n a -> Vec n a
vsort Vec n a
xs = forall (n :: Nat) a. SInt n -> [a] -> Vec n a
listVec (forall (n :: Nat) a. Vec n a -> SInt n
svSize Vec n a
xs) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Ord a => [a] -> [a]
L.sort forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: Type -> Type) a. Foldable t => t a -> [a]
F.toList forall a b. (a -> b) -> a -> b
$ Vec n a
xs
vsortBy :: (a -> a -> Ordering) -> Vec n a -> Vec n a
vsortBy :: forall a (n :: Nat). (a -> a -> Ordering) -> Vec n a -> Vec n a
vsortBy a -> a -> Ordering
f Vec n a
xs = forall (n :: Nat) a. SInt n -> [a] -> Vec n a
listVec (forall (n :: Nat) a. Vec n a -> SInt n
svSize Vec n a
xs)forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> a -> Ordering) -> [a] -> [a]
L.sortBy a -> a -> Ordering
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: Type -> Type) a. Foldable t => t a -> [a]
F.toList forall a b. (a -> b) -> a -> b
$ Vec n a
xs
vsortOn :: Ord b => (a -> b) -> Vec n a -> Vec n a
vsortOn :: forall b a (n :: Nat). Ord b => (a -> b) -> Vec n a -> Vec n a
vsortOn a -> b
f Vec n a
xs = forall (n :: Nat) a. SInt n -> [a] -> Vec n a
listVec (forall (n :: Nat) a. Vec n a -> SInt n
svSize Vec n a
xs)forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b a. Ord b => (a -> b) -> [a] -> [a]
L.sortOn a -> b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: Type -> Type) a. Foldable t => t a -> [a]
F.toList forall a b. (a -> b) -> a -> b
$ Vec n a
xs
vtranspose :: SInt m -> Vec n (Vec m a) -> Vec m (Vec n a)
vtranspose :: forall (m :: Nat) (n :: Nat) a.
SInt m -> Vec n (Vec m a) -> Vec m (Vec n a)
vtranspose SInt m
sm Vec n (Vec m a)
xs =
let !s :: Int
s = forall (n :: Nat) a. Vec n a -> Int
vSize Vec n (Vec m a)
xs
!t :: Int
t = forall (n :: Nat). SInt n -> Int
unSInt SInt m
sm
in forall a (n :: Nat). Int -> (Int -> a) -> Vec n a
unsafeMkVec Int
t forall a b. (a -> b) -> a -> b
$ \ Int
i ->
forall a (n :: Nat). Int -> (Int -> a) -> Vec n a
unsafeMkVec Int
s forall a b. (a -> b) -> a -> b
$ \ Int
j ->
forall (n :: Nat) a r. Vec n a -> Int -> (a -> r) -> r
unsafeIndexK Vec n (Vec m a)
xs Int
j forall a b. (a -> b) -> a -> b
$ \ Vec m a
v -> forall (n :: Nat) a r. Vec n a -> Int -> (a -> r) -> r
unsafeIndexK Vec m a
v Int
i forall a. a -> a
id
vfindIndex :: (a -> Bool) -> Vec n a -> Maybe (Fin n)
vfindIndex :: forall a (n :: Nat). (a -> Bool) -> Vec n a -> Maybe (Fin n)
vfindIndex a -> Bool
p = forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> [a] -> Maybe Int
L.findIndex a -> Bool
p forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: Type -> Type) a. Foldable t => t a -> [a]
F.toList
vec1 :: a -> Vec 1 a
vec1 :: forall a. a -> Vec 1 a
vec1 = forall (f :: Type -> Type) a. Applicative f => a -> f a
pure
{-# INLINE vec1 #-}
vec2 :: a -> a -> Vec 2 a
vec2 :: forall a. a -> a -> Vec 2 a
vec2 a
x0 a
x1 = forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
mkVec forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal forall a b. (a -> b) -> a -> b
$ \Fin 2
i -> case forall (n :: Nat). Fin n -> Int
finToInt Fin 2
i of
Int
0 -> a
x0
Int
1 -> a
x1
Int
_ -> forall a. (?callStack::CallStack) => [Char] -> a
error [Char]
"Impossible: Fin out of range"
{-# INLINE vec2 #-}
vec3 :: a -> a -> a -> Vec 3 a
vec3 :: forall a. a -> a -> a -> Vec 3 a
vec3 a
x0 a
x1 a
x2 = forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
mkVec forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal forall a b. (a -> b) -> a -> b
$ \Fin 3
i -> case forall (n :: Nat). Fin n -> Int
finToInt Fin 3
i of
Int
0 -> a
x0
Int
1 -> a
x1
Int
2 -> a
x2
Int
_ -> forall a. (?callStack::CallStack) => [Char] -> a
error [Char]
"Impossible: Fin out of range"
{-# INLINE vec3 #-}
vec4 :: a -> a -> a -> a -> Vec 4 a
vec4 :: forall a. a -> a -> a -> a -> Vec 4 a
vec4 a
x0 a
x1 a
x2 a
x3 = forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
mkVec forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal forall a b. (a -> b) -> a -> b
$ \Fin 4
i -> case forall (n :: Nat). Fin n -> Int
finToInt Fin 4
i of
Int
0 -> a
x0
Int
1 -> a
x1
Int
2 -> a
x2
Int
3 -> a
x3
Int
_ -> forall a. (?callStack::CallStack) => [Char] -> a
error [Char]
"Impossible: Fin out of range"
{-# INLINE vec4 #-}
vec6 :: a -> a -> a -> a -> a -> a ->Vec 6 a
vec6 :: forall a. a -> a -> a -> a -> a -> a -> Vec 6 a
vec6 a
x0 a
x1 a
x2 a
x3 a
x4 a
x5 = forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
mkVec forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal forall a b. (a -> b) -> a -> b
$ \Fin 6
i -> case forall (n :: Nat). Fin n -> Int
finToInt Fin 6
i of
Int
0 -> a
x0
Int
1 -> a
x1
Int
2 -> a
x2
Int
3 -> a
x3
Int
4 -> a
x4
Int
5 -> a
x5
Int
_ -> forall a. (?callStack::CallStack) => [Char] -> a
error [Char]
"Impossible: Fin out of range"
{-# INLINE vec6 #-}
vec8 :: a -> a -> a -> a -> a -> a -> a -> a -> Vec 8 a
vec8 :: forall a. a -> a -> a -> a -> a -> a -> a -> a -> Vec 8 a
vec8 a
x0 a
x1 a
x2 a
x3 a
x4 a
x5 a
x6 a
x7 = forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
mkVec forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal forall a b. (a -> b) -> a -> b
$ \Fin 8
i -> case forall (n :: Nat). Fin n -> Int
finToInt Fin 8
i of
Int
0 -> a
x0
Int
1 -> a
x1
Int
2 -> a
x2
Int
3 -> a
x3
Int
4 -> a
x4
Int
5 -> a
x5
Int
6 -> a
x6
Int
7 -> a
x7
Int
_ -> forall a. (?callStack::CallStack) => [Char] -> a
error [Char]
"Impossible: Fin out of range"
{-# INLINE vec8 #-}
{-# INLINE valueOf #-}
valueOf :: forall (n :: Nat) (i :: Type) . (KnownNat n, Num i) => i
valueOf :: forall (n :: Nat) i. (KnownNat n, Num i) => i
valueOf = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall (n :: Nat). KnownNat n => Proxy# n -> Nat
natVal' (forall {k} (a :: k). Proxy# a
proxy# :: Proxy# n)
#if !MIN_VERSION_base(4,15,0)
{-# RULES "integerToInt . naturalToInteger => naturalToInt"
forall a. integerToInt (naturalToInteger a) =
let !(I# i) = naturalToInt a
in i
#-}
#endif
overIx :: Fin n -> (a -> a) -> Vec n a -> Vec n a
overIx :: forall (n :: Nat) a. Fin n -> (a -> a) -> Vec n a -> Vec n a
overIx Fin n
i a -> a
f Vec n a
v = forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
MutableVec s n a
mv <- forall (n :: Nat) a s. Vec n a -> ST s (MutableVec s n a)
safeThawMV Vec n a
v
forall (n :: Nat) a r. Vec n a -> Fin n -> (a -> r) -> r
indexK Vec n a
v Fin n
i (forall s (n :: Nat) a. MutableVec s n a -> Fin n -> a -> ST s ()
writeMV MutableVec s n a
mv Fin n
i forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a
f)
forall s (n :: Nat) a. MutableVec s n a -> ST s (Vec n a)
unsafeFreezeMV MutableVec s n a
mv
{-# INLINE overIx #-}