{-# 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)
import Control.Applicative (Applicative(..))
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 :: 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 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== SInt n -> Int
forall (n :: Nat). SInt n -> Int
unSInt SInt n
sn = a
n
| Bool
otherwise = Fin n -> a -> a
c (Int -> Fin n
forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin Int
i) (Int -> a
go (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1))
{-# INLINE [0] foldrEnumFin #-}
forMFin_ :: Applicative f => SInt n -> (Fin n -> f a) -> f ()
forMFin_ :: SInt n -> (Fin n -> f a) -> f ()
forMFin_ SInt n
n Fin n -> f a
f = SInt n -> (Fin n -> f () -> f ()) -> f () -> 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 f a -> f () -> f ()
forall (f :: Type -> Type) a b. Applicative f => f a -> f b -> f b
*> f ()
rest) (() -> f ()
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure ())
{-# INLINE forMFin_ #-}
foldMapFin :: Monoid m => SInt n -> (Fin n -> (# m #)) -> m
foldMapFin :: SInt n -> (Fin n -> (# m #)) -> m
foldMapFin SInt n
sn Fin n -> (# m #)
f = Int -> m -> m
go Int
0 m
forall a. Monoid a => a
mempty
where
go :: Int -> m -> m
go Int
i m
acc
| Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== SInt n -> Int
forall (n :: Nat). SInt n -> Int
unSInt SInt n
sn = m
acc
| Bool
otherwise = case Fin n -> (# m #)
f (Int -> Fin n
forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin Int
i) of (# m
x #) -> Int -> m -> m
go (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) (m
acc m -> m -> m
forall a. Semigroup a => a -> a -> a
<> m
x)
{-# INLINE foldMapFin #-}
foldMFin_
:: Monad m
=> SInt n -> (a -> Fin n -> m a) -> a -> m ()
foldMFin_ :: SInt n -> (a -> Fin n -> m a) -> a -> m ()
foldMFin_ SInt n
n a -> Fin n -> m a
f a
z = SInt n
-> (Fin n -> (a -> m ()) -> a -> m ()) -> (a -> m ()) -> a -> m ()
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 m a -> (a -> m ()) -> m ()
forall (m :: Type -> Type) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> m ()
rest) (\a
_ -> () -> m ()
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 :: SInt n -> (Fin n -> (# f a #)) -> f [a]
forMFin SInt n
n Fin n -> (# f a #)
f = SInt n -> (Fin n -> f [a] -> f [a]) -> f [a] -> f [a]
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 #) -> (a -> [a] -> [a]) -> f a -> f [a] -> f [a]
forall (f :: Type -> Type) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (:) f a
fx)
([a] -> f [a]
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure [])
{-# INLINE forMFin #-}
prim_ :: (State# s -> State# s) -> ST s ()
prim_ :: (State# s -> State# s) -> ST s ()
prim_ State# s -> State# s
f = STRep s () -> ST s ()
forall s a. STRep s a -> ST s a
ST (STRep s () -> ST s ()) -> STRep s () -> ST s ()
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 :: SInt n -> a -> ST s (MutableVec s n a)
newMV (SI# Int
n) = Int -> a -> ST s (MutableVec s n a)
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 :: Int -> a -> ST s (MutableVec s n a)
unsafeNewMV (I# Int#
n) a
x =
STRep s (MutableVec s n a) -> ST s (MutableVec s n a)
forall s a. STRep s a -> ST s a
ST (STRep s (MutableVec s n a) -> ST s (MutableVec s n a))
-> STRep s (MutableVec s n a) -> ST s (MutableVec s n a)
forall a b. (a -> b) -> a -> b
$ \State# s
s0 ->
case Int# -> a -> State# s -> (# State# s, SmallMutableArray# s a #)
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, SmallMutableArray# s a -> MutableVec s n a
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 :: MutableVec s n a -> Int -> a -> ST s ()
unsafeWriteMV (MV# SmallMutableArray# s a
sma) (I# Int#
i) a
x = (State# s -> State# s) -> ST s ()
forall s. (State# s -> State# s) -> ST s ()
prim_ (SmallMutableArray# s a -> Int# -> a -> State# s -> State# s
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 :: MutableVec s n a -> Fin n -> a -> ST s ()
writeMV MutableVec s n a
mv Fin n
i = MutableVec s n a -> Int -> a -> ST s ()
forall s (n :: Nat) a. MutableVec s n a -> Int -> a -> ST s ()
unsafeWriteMV MutableVec s n a
mv (Fin n -> Int
forall (n :: Nat). Fin n -> Int
finToInt Fin n
i)
{-# INLINE writeMV #-}
unsafeFreezeMV :: MutableVec s n a -> ST s (Vec n a)
unsafeFreezeMV :: MutableVec s n a -> ST s (Vec n a)
unsafeFreezeMV (MV# SmallMutableArray# s a
sma) =
STRep s (Vec n a) -> ST s (Vec n a)
forall s a. STRep s a -> ST s a
ST (STRep s (Vec n a) -> ST s (Vec n a))
-> STRep s (Vec n a) -> ST s (Vec n a)
forall a b. (a -> b) -> a -> b
$ \State# s
s0 ->
case SmallMutableArray# s a -> State# s -> (# State# s, SmallArray# a #)
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, SmallArray# a -> Vec n a
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 :: Vec n a -> ST s (MutableVec s n a)
safeThawMV (V# SmallArray# a
sa) =
STRep s (MutableVec s n a) -> ST s (MutableVec s n a)
forall s a. STRep s a -> ST s a
ST (STRep s (MutableVec s n a) -> ST s (MutableVec s n a))
-> STRep s (MutableVec s n a) -> ST s (MutableVec s n a)
forall a b. (a -> b) -> a -> b
$ \State# s
s0 ->
case SmallArray# a
-> Int#
-> Int#
-> State# s
-> (# State# s, SmallMutableArray# s a #)
forall a d.
SmallArray# a
-> Int#
-> Int#
-> State# d
-> (# State# d, SmallMutableArray# d a #)
thawSmallArray# SmallArray# a
sa Int#
0# (SmallArray# a -> Int#
forall a. SmallArray# a -> Int#
sizeofSmallArray# SmallArray# a
sa) State# s
s0 of { (# State# s
s1, SmallMutableArray# s a
sma #) ->
(# State# s
s1, SmallMutableArray# s a -> MutableVec s n a
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 :: 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) =
(State# s -> State# s) -> ST s ()
forall s. (State# s -> State# s) -> ST s ()
prim_ (SmallArray# a
-> Int#
-> SmallMutableArray# s a
-> Int#
-> Int#
-> State# s
-> State# s
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 :: 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)) =
Bool -> Vec m a -> Vec m a
forall a. (?callStack::CallStack) => Bool -> a -> a
assert (Int
0 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
off Bool -> Bool -> Bool
&& Int
0 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
len Bool -> Bool -> Bool
&& Int
len Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Vec n a -> Int
forall (n :: Nat) a. Vec n a -> Int
vSize Vec n a
xs Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
off) (Vec m a -> Vec m a) -> Vec m a -> Vec m a
forall a b. (a -> b) -> a -> b
$
SmallArray# a -> Vec m a
forall (n :: Nat) a. SmallArray# a -> Vec n a
V# (SmallArray# a -> Int# -> Int# -> SmallArray# a
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 :: Vec n a -> Fin n -> (# a #)
fetch (V# SmallArray# a
arr) (Fin n -> Int
forall (n :: Nat). Fin n -> Int
finToInt -> I# Int#
i) = SmallArray# a -> Int# -> (# a #)
forall a. SmallArray# a -> Int# -> (# a #)
indexSmallArray# SmallArray# a
arr Int#
i
{-# INLINE fetch #-}
fusibleFetch :: Vec n a -> Fin n -> (# a #)
fusibleFetch :: Vec n a -> Fin n -> (# a #)
fusibleFetch = Accessor n a -> Fin n -> (# a #)
forall (n :: Nat) a. Accessor n a -> Fin n -> (# a #)
_aIndex (Accessor n a -> Fin n -> (# a #))
-> (Vec n a -> Accessor n a) -> Vec n a -> Fin n -> (# a #)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec n a -> Accessor n a
forall (n :: Nat) a. Vec n a -> Accessor n a
access
{-# INLINE fusibleFetch #-}
(!) :: Vec n a -> Fin n -> a
(!) Vec n a
xs Fin n
i = case Vec n a -> Fin n -> (# a #)
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 :: Vec n a -> Fin n -> (a -> r) -> r
indexK Vec n a
v Fin n
i a -> r
k = case Vec n a -> Fin n -> (# a #)
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 :: Vec n a -> SInt n
svSize (V# SmallArray# a
sa) = Int -> SInt n
forall (n :: Nat). Int -> SInt n
SI# (Int# -> Int
I# (SmallArray# a -> Int#
forall a. SmallArray# a -> Int#
sizeofSmallArray# SmallArray# a
sa))
{-# INLINE svSize #-}
vSize :: Vec n a -> Int
vSize :: Vec n a -> Int
vSize = SInt n -> Int
forall (n :: Nat). SInt n -> Int
unSInt (SInt n -> Int) -> (Vec n a -> SInt n) -> Vec n a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec n a -> SInt n
forall (n :: Nat) a. Vec n a -> SInt n
svSize
{-# INLINE vSize #-}
uninitialized :: a
uninitialized :: a
uninitialized = [Char] -> a
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 :: Int -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
unsafeCreateVec Int
n = SInt n -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
forall (n :: Nat) a.
SInt n -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
createVec (Int -> SInt n
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 :: 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 s. ST s (Vec n a)) -> Vec n a
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (Vec n a)) -> Vec n a)
-> (forall s. ST s (Vec n a)) -> Vec n a
forall a b. (a -> b) -> a -> b
$ do
MutableVec s n a
mv <- SInt n -> a -> ST s (MutableVec s n a)
forall (n :: Nat) a s. SInt n -> a -> ST s (MutableVec s n a)
newMV SInt n
n a
forall a. a
uninitialized
MutableVec s n a -> ST s ()
forall s. MutableVec s n a -> ST s ()
action MutableVec s n a
mv
MutableVec s n a -> ST s (Vec n a)
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
{ Accessor n a -> SInt n
_aSize :: SInt n
, Accessor n a -> Fin n -> (# a #)
_aIndex :: Fin n -> (# a #)
}
access :: Vec n a -> Accessor n a
access :: Vec n a -> Accessor n a
access Vec n a
v = SInt n -> (Fin n -> (# a #)) -> Accessor n a
forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor (Vec n a -> SInt n
forall (n :: Nat) a. Vec n a -> SInt n
svSize Vec n a
v) (Vec n a -> Fin n -> (# a #)
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 :: Accessor n a -> Vec n a
materialize (Accessor SInt n
n Fin n -> (# a #)
get) = SInt n -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
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 ()) -> Vec n a)
-> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
forall a b. (a -> b) -> a -> b
$ \MutableVec s n a
mv -> SInt n -> (Fin n -> ST s ()) -> ST s ()
forall (f :: Type -> Type) (n :: Nat) a.
Applicative f =>
SInt n -> (Fin n -> f a) -> f ()
forMFin_ SInt n
n ((Fin n -> ST s ()) -> ST s ()) -> (Fin n -> ST s ()) -> ST s ()
forall a b. (a -> b) -> a -> b
$ \Fin n
i ->
case Fin n -> (# a #)
get Fin n
i of (# a
x #) -> MutableVec s n a -> Fin n -> a -> ST s ()
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
-- Transports coercions out from between access/materialize pairs so they can
-- fuse.
"access/coerce/materialize"
forall v. access (coerce v) = mapVA coerce (access v)
-- Eliminates no-op copies of a vector.
"materialize/access" forall v. materialize (access v) = v
#-}
pureVA :: SInt n -> a -> Accessor n a
pureVA :: SInt n -> a -> Accessor n a
pureVA SInt n
n a
x = SInt n -> (Fin n -> (# a #)) -> Accessor n a
forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor SInt n
n ((Fin n -> (# a #)) -> Accessor n a)
-> (Fin n -> (# a #)) -> Accessor n a
forall a b. (a -> b) -> a -> b
$ \Fin n
_ -> (# a
x #)
{-# INLINE [0] pureVA #-}
mapVA :: (a -> b) -> Accessor n a -> Accessor n b
mapVA :: (a -> b) -> Accessor n a -> Accessor n b
mapVA a -> b
f (Accessor SInt n
n Fin n -> (# a #)
get) = SInt n -> (Fin n -> (# b #)) -> Accessor n b
forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor SInt n
n ((Fin n -> (# b #)) -> Accessor n b)
-> (Fin n -> (# b #)) -> Accessor n b
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 :: (Fin n -> a -> b) -> Accessor n a -> Accessor n b
mapWithPosVA Fin n -> a -> b
f (Accessor SInt n
n Fin n -> (# a #)
get) = SInt n -> (Fin n -> (# b #)) -> Accessor n b
forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor SInt n
n ((Fin n -> (# b #)) -> Accessor n b)
-> (Fin n -> (# b #)) -> Accessor n b
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 :: Accessor n a -> Accessor n a
seqVA (Accessor SInt n
n Fin n -> (# a #)
get) = SInt n -> (Fin n -> (# a #)) -> Accessor n a
forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor SInt n
n ((Fin n -> (# a #)) -> Accessor n a)
-> (Fin n -> (# a #)) -> Accessor n a
forall a b. (a -> b) -> a -> b
$
\Fin n
i -> case Fin n -> (# a #)
get Fin n
i of (# a
x #) -> a
x a -> (# a #) -> (# a #)
`seq` (# a
x #)
{-# INLINE [0] seqVA #-}
takeVA
:: SInt m -> Accessor (m + n) a -> Accessor m a
takeVA :: SInt m -> Accessor (m + n) a -> Accessor m a
takeVA SInt m
m (Accessor SInt (m + n)
_ Fin (m + n) -> (# a #)
get) = SInt m -> (Fin m -> (# a #)) -> Accessor m a
forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor SInt m
m (\Fin m
i -> Fin (m + n) -> (# a #)
get (Fin m -> Fin (m + n)
forall (m :: Nat) (n :: Nat). Fin m -> Fin (m + n)
embedPlus Fin m
i))
where
embedPlus :: Fin m -> Fin (m + n)
embedPlus :: Fin m -> Fin (m + n)
embedPlus = Int -> Fin (m + n)
forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin (Int -> Fin (m + n)) -> (Fin m -> Int) -> Fin m -> Fin (m + n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fin m -> Int
forall (n :: Nat). Fin n -> Int
finToInt
{-# INLINE [0] takeVA #-}
dropVA :: SInt m -> Accessor (m + n) a -> Accessor n a
dropVA :: SInt m -> Accessor (m + n) a -> Accessor n a
dropVA SInt m
m (Accessor SInt (m + n)
mn Fin (m + n) -> (# a #)
get) = SInt n -> (Fin n -> (# a #)) -> Accessor n a
forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor (Int -> SInt n
forall (n :: Nat). Int -> SInt n
SI# (SInt (m + n) -> Int
forall (n :: Nat). SInt n -> Int
unSInt SInt (m + n)
mn Int -> Int -> Int
forall a. Num a => a -> a -> a
- SInt m -> Int
forall (n :: Nat). SInt n -> Int
unSInt SInt m
m)) ((Fin n -> (# a #)) -> Accessor n a)
-> (Fin n -> (# a #)) -> Accessor n a
forall a b. (a -> b) -> a -> b
$
\Fin n
i -> Fin (m + n) -> (# a #)
get (Int -> Fin (m + n)
forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin (Fin n -> Int
forall (n :: Nat). Fin n -> Int
finToInt Fin n
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ SInt m -> Int
forall (n :: Nat). SInt n -> Int
unSInt SInt m
m))
{-# INLINE [0] dropVA #-}
revVA :: Accessor n a -> Accessor n a
revVA :: Accessor n a -> Accessor n a
revVA (Accessor SInt n
n Fin n -> (# a #)
get) = SInt n -> (Fin n -> (# a #)) -> Accessor n a
forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor SInt n
n ((Fin n -> (# a #)) -> Accessor n a)
-> (Fin n -> (# a #)) -> Accessor n a
forall a b. (a -> b) -> a -> b
$ \Fin n
i -> Fin n -> (# a #)
get (Fin n -> Fin n
forall (n :: Nat). Fin n -> Fin n
complementIt Fin n
i)
where
!nMinus1 :: Int
nMinus1 = SInt n -> Int
forall (n :: Nat). SInt n -> Int
unSInt SInt n
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1
complementIt :: Fin n -> Fin n
complementIt :: Fin n -> Fin n
complementIt = Int -> Fin n
forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin (Int -> Fin n) -> (Fin n -> Int) -> Fin n -> Fin n
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int
nMinus1 Int -> Int -> Int
forall a. Num a => a -> a -> a
-) (Int -> Int) -> (Fin n -> Int) -> Fin n -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fin n -> Int
forall (n :: Nat). Fin n -> Int
finToInt
{-# INLINE [0] revVA #-}
rotVA :: Fin n -> Accessor n a -> Accessor n a
rotVA :: Fin n -> Accessor n a -> Accessor n a
rotVA (Fin n -> Int
forall (n :: Nat). Fin n -> Int
finToInt -> !Int
o) (Accessor SInt n
n Fin n -> (# a #)
get) = SInt n -> (Fin n -> (# a #)) -> Accessor n a
forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor SInt n
n ((Fin n -> (# a #)) -> Accessor n a)
-> (Fin n -> (# a #)) -> Accessor n a
forall a b. (a -> b) -> a -> b
$
\(Fin n -> Int
forall (n :: Nat). Fin n -> Int
finToInt -> !Int
i) -> Fin n -> (# a #)
get (Fin n -> (# a #)) -> Fin n -> (# a #)
forall a b. (a -> b) -> a -> b
$ Int -> Fin n
forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin (Int -> Fin n) -> Int -> Fin n
forall a b. (a -> b) -> a -> b
$ if Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
o then Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
o else Int
nmo Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i
where
!nmo :: Int
nmo = SInt n -> Int
forall (n :: Nat). SInt n -> Int
unSInt SInt n
n Int -> Int -> Int
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 :: (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) = SInt n -> (Fin n -> (# c #)) -> Accessor n c
forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor SInt n
n ((Fin n -> (# c #)) -> Accessor n c)
-> (Fin n -> (# c #)) -> Accessor n c
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 :: (a -> m) -> Accessor n a -> m
foldMapVA a -> m
f (Accessor SInt n
n Fin n -> (# a #)
get) =
SInt n -> (Fin n -> (# m #)) -> m
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 :: Accessor n (f a) -> f (Vec n a)
sequenceVA (Accessor SInt n
n Fin n -> (# f a #)
get) = SInt n -> [a] -> Vec n a
forall (n :: Nat) a. SInt n -> [a] -> Vec n a
listVec SInt n
n ([a] -> Vec n a) -> f [a] -> f (Vec n a)
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> SInt n -> (Fin n -> (# f a #)) -> f [a]
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 :: SInt n -> Fin (n + m) -> Either (Fin n) (Fin m)
splitFinS (SI# Int
n) (Fin (n + m) -> Int
forall (n :: Nat). Fin n -> Int
finToInt -> Int
i)
| Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
n = Fin n -> Either (Fin n) (Fin m)
forall a b. a -> Either a b
Left (Int -> Fin n
forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin Int
i)
| Bool
otherwise = Fin m -> Either (Fin n) (Fin m)
forall a b. b -> Either a b
Right (Int -> Fin m
forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
n))
addPosSInt :: SInt n -> SInt m -> SInt (n + m)
addPosSInt :: SInt n -> SInt m -> SInt (n + m)
addPosSInt (SI# Int
n) (SI# Int
m) =
let nm :: Int
nm = Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
m
in if Int
nm Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0
then [Char] -> SInt (n + m)
forall a. (?callStack::CallStack) => [Char] -> a
error [Char]
"addPosSInt: Int overflow"
else Int -> SInt (n + m)
forall (n :: Nat). Int -> SInt n
SI# (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
m)
{-# INLINE addPosSInt #-}
appendVA :: Accessor n a -> Accessor m a -> Accessor (n + m) a
appendVA :: 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) = SInt (n + m) -> (Fin (n + m) -> (# a #)) -> Accessor (n + m) a
forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor
(SInt n -> SInt m -> SInt (n + m)
forall (n :: Nat) (m :: Nat). SInt n -> SInt m -> SInt (n + m)
addPosSInt SInt n
n SInt m
m)
(\Fin (n + m)
i -> case SInt n -> Fin (n + m) -> Either (Fin n) (Fin m)
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 :: Int -> (Int -> a) -> Vec n a
unsafeMkVec Int
n Int -> a
f = SInt n -> (Fin n -> a) -> Vec n a
forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
mkVec (Int -> SInt n
forall (n :: Nat). Int -> SInt n
SI# Int
n) ((Fin n -> a) -> Vec n a) -> (Fin n -> a) -> Vec n a
forall a b. (a -> b) -> a -> b
$ \Fin n
i -> Int -> a
f (Fin n -> Int
forall (n :: Nat). Fin n -> Int
finToInt Fin n
i)
{-# INLINE unsafeMkVec #-}
tabulateVec, mkVec :: SInt n -> (Fin n -> a) -> Vec n a
tabulateVec :: SInt n -> (Fin n -> a) -> Vec n a
tabulateVec SInt n
n Fin n -> a
f = Accessor n a -> Vec n a
forall (n :: Nat) a. Accessor n a -> Vec n a
materialize (Accessor n a -> Vec n a) -> Accessor n a -> Vec n a
forall a b. (a -> b) -> a -> b
$ SInt n -> (Fin n -> (# a #)) -> Accessor n a
forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor SInt n
n ((Fin n -> (# a #)) -> Accessor n a)
-> (Fin n -> (# a #)) -> Accessor n a
forall a b. (a -> b) -> a -> b
$ \Fin n
i -> (# Fin n -> a
f Fin n
i #)
mkVec :: SInt n -> (Fin n -> a) -> Vec n a
mkVec = SInt n -> (Fin n -> a) -> Vec n a
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' :: SInt n -> (Fin n -> a) -> Vec n a
tabulateVec' SInt n
n Fin n -> a
f = Accessor n a -> Vec n a
forall (n :: Nat) a. Accessor n a -> Vec n a
materialize (Accessor n a -> Vec n a) -> Accessor n a -> Vec n a
forall a b. (a -> b) -> a -> b
$
SInt n -> (Fin n -> (# a #)) -> Accessor n a
forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor SInt n
n ((Fin n -> (# a #)) -> Accessor n a)
-> (Fin n -> (# a #)) -> Accessor n a
forall a b. (a -> b) -> a -> b
$ \Fin n
i -> let x :: a
x = Fin n -> a
f Fin n
i in a
x a -> (# a #) -> (# a #)
`seq` (# a
x #)
mkVec' :: SInt n -> (Fin n -> a) -> Vec n a
mkVec' = SInt n -> (Fin n -> a) -> Vec n a
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 :: 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 = Accessor m a -> Vec m a
forall (n :: Nat) a. Accessor n a -> Vec n a
materialize (Accessor m a -> Vec m a) -> Accessor m a -> Vec m a
forall a b. (a -> b) -> a -> b
$ SInt m -> (Fin m -> (# a #)) -> Accessor m a
forall (n :: Nat) a. SInt n -> (Fin n -> (# a #)) -> Accessor n a
Accessor SInt m
m ((Fin m -> (# a #)) -> Accessor m a)
-> (Fin m -> (# a #)) -> Accessor m a
forall a b. (a -> b) -> a -> b
$ \Fin m
i -> Vec n a -> Fin n -> (# a #)
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 :: SInt n -> [a] -> Vec n a
listVec SInt n
n [a]
xs = SInt n -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
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 ()) -> Vec n a)
-> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
forall a b. (a -> b) -> a -> b
$ \MutableVec s n a
mv -> (([a] -> ST s ()) -> [a] -> ST s ()
forall a b. (a -> b) -> a -> b
$ [a]
xs) (([a] -> ST s ()) -> ST s ()) -> ([a] -> ST s ()) -> ST s ()
forall a b. (a -> b) -> a -> b
$ SInt n
-> (Fin n -> ([a] -> ST s ()) -> [a] -> ST s ())
-> ([a] -> ST s ())
-> [a]
-> ST s ()
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
[] -> MutableVec s n a -> Fin n -> a -> ST s ()
forall s (n :: Nat) a. MutableVec s n a -> Fin n -> a -> ST s ()
writeMV MutableVec s n a
mv Fin n
i a
forall a. a
uninitialized ST s () -> ST s () -> ST s ()
forall (m :: Type -> Type) a b. Monad m => m a -> m b -> m b
>> [a] -> ST s ()
rest []
(a
x:[a]
xs'') -> MutableVec s n a -> Fin n -> a -> ST s ()
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 ST s () -> ST s () -> ST s ()
forall (m :: Type -> Type) a b. Monad m => m a -> m b -> m b
>> [a] -> ST s ()
rest [a]
xs'')
(\[a]
_ -> () -> ST s ()
forall (m :: Type -> Type) a. Monad m => a -> m a
return ())
{-# INLINE listVec #-}
withVec :: [a] -> (forall n. Vec n a -> r) -> r
withVec :: [a] -> (forall (n :: Nat). Vec n a -> r) -> r
withVec [a]
xs forall (n :: Nat). Vec n a -> r
f = Int -> (forall (n :: Nat). SInt n -> r) -> r
forall r.
(?callStack::CallStack) =>
Int -> (forall (n :: Nat). SInt n -> r) -> r
withSInt ([a] -> Int
forall (t :: Type -> Type) a. Foldable t => t a -> Int
length [a]
xs) ((forall (n :: Nat). SInt n -> r) -> r)
-> (forall (n :: Nat). SInt n -> r) -> r
forall a b. (a -> b) -> a -> b
$ \SInt n
sn -> Vec n a -> r
forall (n :: Nat). Vec n a -> r
f (SInt n -> [a] -> Vec n a
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 :: SInt n -> Int -> [a] -> Vec n a
fromListN SInt n
sn Int
l [a]
xs
| Int
l Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
n = SInt n -> [a] -> Vec n a
forall (n :: Nat) a. SInt n -> [a] -> Vec n a
listVec SInt n
sn [a]
xs
| Bool
otherwise = [Char] -> Vec n a
forall a. (?callStack::CallStack) => [Char] -> a
error ([Char] -> Vec n a) -> [Char] -> Vec n a
forall a b. (a -> b) -> a -> b
$ [Char]
"Vec.fromListN: " [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> Int -> [Char]
forall a. Show a => a -> [Char]
show Int
l [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
" /= " [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> Int -> [Char]
forall a. Show a => a -> [Char]
show Int
n
where
!n :: Int
n = SInt n -> Int
forall (n :: Nat). SInt n -> Int
unSInt SInt n
sn
{-# INLINABLE fromListN #-}
fromList :: HasCallStack => SInt n -> [a] -> Vec n a
fromList :: SInt n -> [a] -> Vec n a
fromList SInt n
sn [a]
xs
| Int
n Int -> [a] -> Bool
forall a. Int -> [a] -> Bool
`eqLength` [a]
xs = SInt n -> [a] -> Vec n a
forall (n :: Nat) a. SInt n -> [a] -> Vec n a
listVec SInt n
sn [a]
xs
| Bool
otherwise = [Char] -> Vec n a
forall a. (?callStack::CallStack) => [Char] -> a
error ([Char] -> Vec n a) -> [Char] -> Vec n a
forall a b. (a -> b) -> a -> b
$ [Char]
"Vec.fromList: length /= " [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> Int -> [Char]
forall a. Show a => a -> [Char]
show Int
n
where
!n :: Int
n = SInt n -> Int
forall (n :: Nat). SInt n -> Int
unSInt SInt n
sn
{-# INLINABLE fromList #-}
eqLength :: Int -> [a] -> Bool
eqLength :: 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) = Int -> [a] -> Bool
forall a. Int -> [a] -> Bool
eqLength (Int
n Int -> Int -> Int
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 = SInt n -> Int -> [a] -> Vec n a
forall (n :: Nat) a.
(?callStack::CallStack) =>
SInt n -> Int -> [a] -> Vec n a
fromListN SInt n
forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal
fromList :: [Item (Vec n a)] -> Vec n a
fromList = SInt n -> [a] -> Vec n a
forall (n :: Nat) a.
(?callStack::CallStack) =>
SInt n -> [a] -> Vec n a
fromList SInt n
forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal
toList :: Vec n a -> [Item (Vec n a)]
toList = Vec n a -> [Item (Vec n a)]
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 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 = ([a] -> Vec n a) -> c ([a] -> Vec n a)
forall g. g -> c g
pur (SInt n -> [a] -> Vec n a
forall (n :: Nat) a.
(?callStack::CallStack) =>
SInt n -> [a] -> Vec n a
fromList SInt n
forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal) c ([a] -> Vec n a) -> [a] -> c (Vec n a)
forall d b. Data d => c (d -> b) -> d -> c b
`app` Vec n a -> [a]
forall (t :: Type -> Type) a. Foldable t => t a -> [a]
F.toList Vec n a
v
gunfold :: (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 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 = c ([a] -> Vec n a) -> c (Vec n a)
forall b r. Data b => c (b -> r) -> c r
app (([a] -> Vec n a) -> c ([a] -> Vec n a)
forall r. r -> c r
pur (SInt n -> [a] -> Vec n a
forall (n :: Nat) a.
(?callStack::CallStack) =>
SInt n -> [a] -> Vec n a
fromList SInt n
forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal))
| Bool
otherwise = [Char] -> c (Vec n a)
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 -> [Char] -> [Char]
showsPrec Int
p Vec n a
xs = Bool -> ([Char] -> [Char]) -> [Char] -> [Char]
showParen (Int
p Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
precedence)
(([Char] -> [Char]) -> [Char] -> [Char])
-> ([Char] -> [Char]) -> [Char] -> [Char]
forall a b. (a -> b) -> a -> b
$ [Char] -> [Char] -> [Char]
showString [Char]
"fromListN "
([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [Char] -> [Char]
forall a. Show a => a -> [Char] -> [Char]
shows (Vec n a -> Int
forall (n :: Nat) a. Vec n a -> Int
vSize Vec n a
xs)
([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char] -> [Char]
showString [Char]
" "
([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> [Char] -> [Char]
forall a. Show a => a -> [Char] -> [Char]
shows (Vec n a -> [a]
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 = Bool -> ReadS (Vec n a) -> ReadS (Vec n a)
forall a. Bool -> ReadS a -> ReadS a
readParen (Int
p Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
precedence) (ReadS (Vec n a) -> ReadS (Vec n a))
-> ReadS (Vec n a) -> ReadS (Vec n a)
forall a b. (a -> b) -> a -> b
$ \[Char]
s ->
[ Int -> (Vec n a, [Char]) -> (Vec n a, [Char])
forall b. Int -> b -> b
assertSize ([a] -> Int
forall (t :: Type -> Type) a. Foldable t => t a -> Int
length [a]
ls) (SInt n -> Int -> [a] -> Vec n a
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'') <- Int -> ReadS Int
forall a. Read a => Int -> ReadS a
readsPrec Int
precedence [Char]
s'
, ([a]
ls, [Char]
s''') <- Int -> (Int -> ReadS [a]) -> Int -> ReadS [a]
forall b. Int -> b -> b
assertSize Int
m Int -> ReadS [a]
forall a. Read a => Int -> ReadS a
readsPrec Int
precedence [Char]
s''
]
where
n :: SInt n
n = (?callStack::CallStack, KnownNat n) => SInt n
forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal @n
assertSize :: Int -> b -> b
assertSize :: Int -> b -> b
assertSize Int
m b
x = if Int
m Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= SInt n -> Int
forall (n :: Nat). SInt n -> Int
unSInt SInt n
n
then [Char] -> b
forall a. (?callStack::CallStack) => [Char] -> a
error ([Char] -> b) -> [Char] -> b
forall a b. (a -> b) -> a -> b
$ [Char]
"Can't read a Vec with " [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> Int -> [Char]
forall a. Show a => a -> [Char]
show Int
m [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<>
[Char]
" elements into a type `Vec " [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> SInt n -> [Char]
forall a. Show a => a -> [Char]
show SInt n
n [Char] -> [Char] -> [Char]
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")
[Int -> Portrayal
forall a. Portray a => a -> Portrayal
portray (Vec n a -> Int
forall (n :: Nat) a. Vec n a -> Int
vSize Vec n a
xs), [a] -> Portrayal
forall a. Portray a => a -> Portrayal
portray ([a] -> Portrayal) -> [a] -> Portrayal
forall a b. (a -> b) -> a -> b
$ Vec n a -> [a]
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 = ([a] -> [a] -> Maybe Portrayal
forall a. Diff a => a -> a -> Maybe Portrayal
diff ([a] -> [a] -> Maybe Portrayal)
-> (Vec n a -> [a]) -> Vec n a -> Vec n a -> Maybe Portrayal
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` Vec n a -> [a]
forall (t :: Type -> Type) a. Foldable t => t a -> [a]
F.toList) Vec n a
x Vec n a
y Maybe Portrayal -> (Portrayal -> Portrayal) -> Maybe Portrayal
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") [Int -> Portrayal
forall a. Portray a => a -> Portrayal
portray (Vec n a -> Int
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 = SInt n -> (Fin n -> (# () #)) -> ()
forall m (n :: Nat). Monoid m => SInt n -> (Fin n -> (# m #)) -> m
foldMapFin (Vec n a -> SInt n
forall (n :: Nat) a. Vec n a -> SInt n
svSize Vec n a
xs) ((Fin n -> (# () #)) -> ()) -> (Fin n -> (# () #)) -> ()
forall a b. (a -> b) -> a -> b
$
\Fin n
i -> case Vec n a -> Fin n -> (a -> ()) -> ()
forall (n :: Nat) a r. Vec n a -> Fin n -> (a -> r) -> r
indexK Vec n a
xs Fin n
i a -> ()
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
(<>) = (a -> a -> a) -> 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 a -> a -> a
forall a. Semigroup a => a -> a -> a
(<>)
instance (KnownNat n, Monoid a) => Monoid (Vec n a) where
mempty :: Vec n a
mempty = a -> Vec n a
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure a
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 = SInt n -> [a] -> Vec n a
forall (n :: Nat) a. SInt n -> [a] -> Vec n a
listVec SInt n
sn ([a] -> Vec n a) -> Gen [a] -> Gen (Vec n a)
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Gen a -> Gen [a]
forall a. Int -> Gen a -> Gen [a]
QC.vectorOf Int
n Gen a
forall a. Arbitrary a => Gen a
QC.arbitrary
where
!sn :: SInt n
sn@(SI# Int
n) = SInt n
forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal
shrink :: Vec n a -> [Vec n a]
shrink Vec n a
xs =
[ Fin n -> Vec n a -> a -> Vec n a
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 <- SInt n -> (Fin n -> [Fin n] -> [Fin n]) -> [Fin n] -> [Fin n]
forall (n :: Nat) a. SInt n -> (Fin n -> a -> a) -> a -> a
foldrEnumFin SInt n
sn (:) [], a
x' <- Vec n a -> Fin n -> (a -> [a]) -> [a]
forall (n :: Nat) a r. Vec n a -> Fin n -> (a -> r) -> r
indexK Vec n a
xs Fin n
i a -> [a]
forall a. Arbitrary a => a -> [a]
QC.shrink
]
where
!sn :: SInt n
sn = Vec n a -> SInt n
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 :: Fin n -> Vec n a -> a -> Vec n a
upd Fin n
i Vec n a
xs a
x = (forall s. ST s (Vec n a)) -> Vec n a
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (Vec n a)) -> Vec n a)
-> (forall s. ST s (Vec n a)) -> Vec n a
forall a b. (a -> b) -> a -> b
$ do
MutableVec s n a
mv <- Vec n a -> ST s (MutableVec s n a)
forall (n :: Nat) a s. Vec n a -> ST s (MutableVec s n a)
safeThawMV Vec n a
xs
MutableVec s n a -> Fin n -> a -> ST s ()
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
MutableVec s n a -> ST s (Vec n a)
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 :: Vec n a -> Gen b -> Gen b
coarbitrary = Vec n a -> Gen b -> Gen b
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
(+) = (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 a -> a -> a
forall a. Num a => a -> a -> a
(+)
* :: Vec n a -> Vec n a -> Vec n 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 a -> a -> a
forall a. Num a => a -> a -> 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 (-)
abs :: Vec n a -> Vec n a
abs = (a -> a) -> Vec n a -> Vec n a
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Num a => a -> a
abs
signum :: Vec n a -> Vec n a
signum = (a -> a) -> Vec n a -> Vec n a
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Num a => a -> a
signum
negate :: Vec n a -> Vec n a
negate = (a -> a) -> Vec n a -> Vec n a
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> a
forall a. Num a => a -> a
negate
fromInteger :: Integer -> Vec n a
fromInteger = a -> Vec n a
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure (a -> Vec n a) -> (Integer -> a) -> Integer -> Vec n a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> a
forall a. Num a => Integer -> a
fromInteger
instance (KnownNat n, Default a) => Default (Vec n a) where
def :: Vec n a
def = a -> Vec n a
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure a
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 (All -> Bool) -> All -> Bool
forall a b. (a -> b) -> a -> b
$ (Bool -> All) -> Vec n Bool -> All
forall (t :: Type -> Type) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Bool -> All
All (Vec n Bool -> All) -> Vec n Bool -> All
forall a b. (a -> b) -> a -> b
$ (a -> a -> Bool) -> Vec n a -> Vec n a -> Vec n Bool
forall (f :: Type -> Type) a b c.
Apply f =>
(a -> b -> c) -> f a -> f b -> f c
liftF2 a -> a -> Bool
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 (Any -> Bool) -> Any -> Bool
forall a b. (a -> b) -> a -> b
$ (Bool -> Any) -> Vec n Bool -> Any
forall (t :: Type -> Type) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Bool -> Any
Any (Vec n Bool -> Any) -> Vec n Bool -> Any
forall a b. (a -> b) -> a -> b
$ (a -> a -> Bool) -> Vec n a -> Vec n a -> Vec n Bool
forall (f :: Type -> Type) a b c.
Apply f =>
(a -> b -> c) -> f a -> f b -> f c
liftF2 a -> a -> Bool
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 = Vec n Ordering -> Ordering
forall (t :: Type -> Type) m. (Foldable t, Monoid m) => t m -> m
F.fold (Vec n Ordering -> Ordering) -> Vec n Ordering -> Ordering
forall a b. (a -> b) -> a -> b
$ (a -> a -> Ordering) -> Vec n a -> Vec n a -> Vec n Ordering
forall (f :: Type -> Type) a b c.
Apply f =>
(a -> b -> c) -> f a -> f b -> f c
liftF2 a -> a -> Ordering
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 :: (a -> b) -> Vec n a -> Vec n b
mapVec a -> b
f = Accessor n b -> Vec n b
forall (n :: Nat) a. Accessor n a -> Vec n a
materialize (Accessor n b -> Vec n b)
-> (Vec n a -> Accessor n b) -> Vec n a -> Vec n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> Accessor n a -> Accessor n b
forall a b (n :: Nat). (a -> b) -> Accessor n a -> Accessor n b
mapVA a -> b
f (Accessor n a -> Accessor n b)
-> (Vec n a -> Accessor n a) -> Vec n a -> Accessor n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec n a -> Accessor n a
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 :: (a -> b) -> Vec n a -> Vec n b
fmap = (a -> b) -> Vec n a -> Vec n b
forall a b (n :: Nat). (a -> b) -> Vec n a -> Vec n b
mapVec
a
x <$ :: a -> Vec n b -> Vec n a
<$ Vec n b
v = SInt n -> a -> Vec n a
forall (n :: Nat) a. SInt n -> a -> Vec n a
pureVec (Accessor n b -> SInt n
forall (n :: Nat) a. Accessor n a -> SInt n
_aSize (Vec n b -> Accessor n b
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 :: (Fin n -> a -> b) -> Vec n a -> Vec n b
imap = (Fin n -> a -> b) -> Vec n a -> Vec n b
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 :: (Fin n -> a -> m) -> Vec n a -> m
ifoldMap Fin n -> a -> m
f = Vec n m -> m
forall (t :: Type -> Type) m. (Foldable t, Monoid m) => t m -> m
F.fold (Vec n m -> m) -> (Vec n a -> Vec n m) -> Vec n a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Fin n -> a -> m) -> Vec n a -> Vec n m
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 :: (Fin n -> a -> f b) -> Vec n a -> f (Vec n b)
itraverse Fin n -> a -> f b
f = Vec n (f b) -> f (Vec n b)
forall (t :: Type -> Type) (f :: Type -> Type) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
sequenceA (Vec n (f b) -> f (Vec n b))
-> (Vec n a -> Vec n (f b)) -> Vec n a -> f (Vec n b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Fin n -> a -> f b) -> Vec n a -> Vec n (f b)
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' :: (a -> b) -> Vec n a -> Vec n b
map' a -> b
f = Accessor n b -> Vec n b
forall (n :: Nat) a. Accessor n a -> Vec n a
materialize (Accessor n b -> Vec n b)
-> (Vec n a -> Accessor n b) -> Vec n a -> Vec n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Accessor n b -> Accessor n b
forall (n :: Nat) a. Accessor n a -> Accessor n a
seqVA (Accessor n b -> Accessor n b)
-> (Vec n a -> Accessor n b) -> Vec n a -> Accessor n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> Accessor n a -> Accessor n b
forall a b (n :: Nat). (a -> b) -> Accessor n a -> Accessor n b
mapVA a -> b
f (Accessor n a -> Accessor n b)
-> (Vec n a -> Accessor n a) -> Vec n a -> Accessor n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec n a -> Accessor n a
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 :: (Fin n -> a -> b) -> Vec n a -> Vec n b
imap Fin n -> a -> b
f = Accessor n b -> Vec n b
forall (n :: Nat) a. Accessor n a -> Vec n a
materialize (Accessor n b -> Vec n b)
-> (Vec n a -> Accessor n b) -> Vec n a -> Vec n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Fin n -> a -> b) -> Accessor n a -> Accessor n b
forall (n :: Nat) a b.
(Fin n -> a -> b) -> Accessor n a -> Accessor n b
mapWithPosVA Fin n -> a -> b
f (Accessor n a -> Accessor n b)
-> (Vec n a -> Accessor n a) -> Vec n a -> Accessor n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec n a -> Accessor n a
forall (n :: Nat) a. Vec n a -> Accessor n a
access
{-# INLINE imap #-}
withPos :: Vec n a -> Vec n (Fin n, a)
withPos :: Vec n a -> Vec n (Fin n, a)
withPos = (Fin n -> a -> (Fin n, a)) -> Vec n a -> Vec n (Fin n, a)
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' :: (Fin n -> a -> b) -> Vec n a -> Vec n b
imap' Fin n -> a -> b
f = Accessor n b -> Vec n b
forall (n :: Nat) a. Accessor n a -> Vec n a
materialize (Accessor n b -> Vec n b)
-> (Vec n a -> Accessor n b) -> Vec n a -> Vec n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Accessor n b -> Accessor n b
forall (n :: Nat) a. Accessor n a -> Accessor n a
seqVA (Accessor n b -> Accessor n b)
-> (Vec n a -> Accessor n b) -> Vec n a -> Accessor n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Fin n -> a -> b) -> Accessor n a -> Accessor n b
forall (n :: Nat) a b.
(Fin n -> a -> b) -> Accessor n a -> Accessor n b
mapWithPosVA Fin n -> a -> b
f (Accessor n a -> Accessor n b)
-> (Vec n a -> Accessor n a) -> Vec n a -> Accessor n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec n a -> Accessor n a
forall (n :: Nat) a. Vec n a -> Accessor n a
access
{-# INLINE imap' #-}
pureVec_, pureVec :: SInt n -> a -> Vec n a
pureVec_ :: SInt n -> a -> Vec n a
pureVec_ SInt n
n a
x = (forall s. ST s (Vec n a)) -> Vec n a
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (Vec n a)) -> Vec n a)
-> (forall s. ST s (Vec n a)) -> Vec n a
forall a b. (a -> b) -> a -> b
$ SInt n -> a -> ST s (MutableVec s n a)
forall (n :: Nat) a s. SInt n -> a -> ST s (MutableVec s n a)
newMV SInt n
n a
x ST s (MutableVec s n a)
-> (MutableVec s n a -> ST s (Vec n a)) -> ST s (Vec n a)
forall (m :: Type -> Type) a b. Monad m => m a -> (a -> m b) -> m b
>>= MutableVec s n a -> ST s (Vec n a)
forall s (n :: Nat) a. MutableVec s n a -> ST s (Vec n a)
unsafeFreezeMV
{-# NOINLINE pureVec_ #-}
pureVec :: SInt n -> a -> Vec n a
pureVec = \SInt n
n a
x -> Accessor n a -> Vec n a
forall (n :: Nat) a. Accessor n a -> Vec n a
materialize (SInt n -> a -> Accessor n a
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 :: (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 = Accessor n c -> Vec n c
forall (n :: Nat) a. Accessor n a -> Vec n a
materialize ((a -> b -> c) -> Accessor n a -> Accessor n b -> Accessor n c
forall a b c (n :: Nat).
(a -> b -> c) -> Accessor n a -> Accessor n b -> Accessor n c
liftA2VA a -> b -> c
f (Vec n a -> Accessor n a
forall (n :: Nat) a. Vec n a -> Accessor n a
access Vec n a
as) (Vec n b -> Accessor n b
forall (n :: Nat) a. Vec n a -> Accessor n a
access Vec n b
bs))
{-# INLINE liftA2Vec #-}
instance Apply (Vec n) where
liftF2 :: (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
liftF2 = (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
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 :: a -> Vec n a
pure = SInt n -> a -> Vec n a
forall (n :: Nat) a. SInt n -> a -> Vec n a
pureVec SInt n
forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal
{-# INLINE pure #-}
liftA2 :: (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
liftA2 = (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
forall a b c (n :: Nat).
(a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
liftA2Vec
{-# INLINE liftA2 #-}
<*> :: Vec n (a -> b) -> Vec n a -> Vec n b
(<*>) = ((a -> b) -> 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 (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
($)
{-# INLINE (<*>) #-}
Vec n a
_ *> :: Vec n a -> Vec n b -> Vec n b
*> Vec n b
ys = Vec n b
ys
{-# INLINE (*>) #-}
Vec n a
xs <* :: 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 >>- :: Vec n a -> (a -> Vec n b) -> Vec n b
>>- a -> Vec n b
f = Accessor n b -> Vec n b
forall (n :: Nat) a. Accessor n a -> Vec n a
materialize (case Vec n a -> Accessor n a
forall (n :: Nat) a. Vec n a -> Accessor n a
access Vec n a
xs of
Accessor SInt n
n Fin n -> (# a #)
get -> SInt n -> (Fin n -> (# b #)) -> Accessor n b
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 Vec n b -> Fin n -> (# b #)
forall (n :: Nat) a. Vec n a -> Fin n -> (# a #)
`fusibleFetch` Fin n
i))
{-# INLINE (>>-) #-}
instance KnownNat n => Monad (Vec n) where >>= :: Vec n a -> (a -> Vec n b) -> Vec n 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 :: 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 = SInt n -> (Fin n -> c) -> Vec n c
forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
tabulateVec SInt n
sn ((Fin n -> c) -> Vec n c) -> (Fin n -> c) -> Vec n c
forall a b. (a -> b) -> a -> b
$ \Fin n
i ->
Vec n a -> Fin n -> (a -> c) -> c
forall (n :: Nat) a r. Vec n a -> Fin n -> (a -> r) -> r
indexK Vec n a
xs Fin n
i ((a -> c) -> c) -> (a -> c) -> c
forall a b. (a -> b) -> a -> b
$ \a
x ->
Vec n b -> Fin n -> (b -> c) -> c
forall (n :: Nat) a r. Vec n a -> Fin n -> (a -> r) -> r
indexK Vec n b
ys Fin n
i ((b -> c) -> c) -> (b -> c) -> c
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 :: Vec n a -> Int -> (a -> r) -> r
unsafeIndexK (V# SmallArray# a
sa) (I# Int#
i) a -> r
k = case SmallArray# a -> Int# -> (# a #)
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 :: Vec n a -> Int
length = Vec n a -> Int
forall (n :: Nat) a. Vec n a -> Int
vSize
{-# INLINE length #-}
null :: Vec n a -> Bool
null = (Int
0 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
==) (Int -> Bool) -> (Vec n a -> Int) -> Vec n a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec n a -> Int
forall (t :: Type -> Type) a. Foldable t => t a -> Int
length
{-# INLINE null #-}
foldMap :: (a -> m) -> Vec n a -> m
foldMap a -> m
f = (a -> m) -> Accessor n a -> m
forall m a (n :: Nat). Monoid m => (a -> m) -> Accessor n a -> m
foldMapVA a -> m
f (Accessor n a -> m) -> (Vec n a -> Accessor n a) -> Vec n a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec n a -> Accessor n a
forall (n :: Nat) a. Vec n a -> Accessor n a
access
{-# INLINE foldMap #-}
fold :: Vec n m -> m
fold = (m -> m) -> Accessor n m -> m
forall m a (n :: Nat). Monoid m => (a -> m) -> Accessor n a -> m
foldMapVA m -> m
forall a. a -> a
id (Accessor n m -> m) -> (Vec n m -> Accessor n m) -> Vec n m -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec n m -> Accessor n m
forall (n :: Nat) a. Vec n a -> Accessor n a
access
{-# INLINE fold #-}
foldr :: (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 = Vec n a -> Accessor n a
forall (n :: Nat) a. Vec n a -> Accessor n a
access Vec n a
v
in SInt n -> (Fin n -> b -> b) -> b -> b
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' :: (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) = Vec n a -> Accessor n a
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 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 = b
acc
| Bool
otherwise =
case Fin n -> (# a #)
get (Int -> Fin n
forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin Int
i) of (# a
x #) -> Int -> b -> b
go (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) (a -> b -> b
f a
x b
acc)
in Int -> b -> b
go (SInt n -> Int
forall (n :: Nat). SInt n -> Int
unSInt SInt n
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) b
acc0
{-# INLINE foldr' #-}
foldl :: (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) = Vec n a -> Accessor n a
forall (n :: Nat) a. Vec n a -> Accessor n a
access Vec n a
v
go :: Int -> b
go !Int
i
| Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 = b
acc0
| Bool
otherwise = case Fin n -> (# a #)
get (Int -> Fin n
forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin Int
i) of (# a
x #) -> b -> a -> b
f (Int -> b
go (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)) a
x
in Int -> b
go (SInt n -> Int
forall (n :: Nat). SInt n -> Int
unSInt SInt n
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)
{-# INLINE foldl #-}
foldl' :: (b -> a -> b) -> b -> Vec n a -> b
foldl' b -> a -> b
f b
acc0 = \Vec n a
v ->
let !(Accessor (SInt n -> Int
forall (n :: Nat). SInt n -> Int
unSInt -> !Int
n) Fin n -> (# a #)
get) = Vec n a -> Accessor n a
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 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
n = b
acc
| Bool
otherwise =
case Fin n -> (# a #)
get (Int -> Fin n
forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin Int
i) of (# a
a #) -> Int -> b -> b
go (Int
iInt -> Int -> Int
forall 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 :: (a -> a -> a) -> Vec n a -> a
foldr1 a -> a -> a
f = \Vec n a
v ->
case Vec n a -> Accessor n a
forall (n :: Nat) a. Vec n a -> Accessor n a
access Vec n a
v of
Accessor (Int -> Int -> Int
forall a. Num a => a -> a -> a
subtract Int
1 (Int -> Int) -> (SInt n -> Int) -> SInt n -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SInt n -> Int
forall (n :: Nat). SInt n -> Int
unSInt -> Int
lMinus1) Fin n -> (# a #)
get
| Int
lMinus1 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 -> [Char] -> a
forall a. (?callStack::CallStack) => [Char] -> a
error [Char]
"foldr1@Vec: empty list"
| Bool
otherwise ->
let !(# a
z #) = Fin n -> (# a #)
get (Int -> Fin n
forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin Int
lMinus1)
go :: Int -> a
go !Int
i | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
lMinus1 = a
z
| Bool
otherwise =
let !(# a
x #) = Fin n -> (# a #)
get (Int -> Fin n
forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin Int
i)
in a -> a -> a
f a
x (Int -> a
go (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1))
in Int -> a
go Int
0
{-# INLINE foldr1 #-}
foldl1 :: (a -> a -> a) -> Vec n a -> a
foldl1 a -> a -> a
f = \Vec n a
v ->
case Vec n a -> Accessor n a
forall (n :: Nat) a. Vec n a -> Accessor n a
access Vec n a
v of
Accessor (Int -> Int -> Int
forall a. Num a => a -> a -> a
subtract Int
1 (Int -> Int) -> (SInt n -> Int) -> SInt n -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SInt n -> Int
forall (n :: Nat). SInt n -> Int
unSInt -> Int
lMinus1) Fin n -> (# a #)
get
| Int
lMinus1 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 -> [Char] -> a
forall a. (?callStack::CallStack) => [Char] -> a
error [Char]
"foldl1@Vec: empty list"
| Bool
otherwise ->
let !(# a
z #) = Fin n -> (# a #)
get (Int -> Fin n
forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin (Int
0 :: Int))
go :: Int -> a
go !Int
i | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0 = a
z
| Bool
otherwise =
let !(# a
x #) = Fin n -> (# a #)
get (Int -> Fin n
forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin Int
i)
in a -> a -> a
f (Int -> a
go (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)) a
x
in Int -> a
go Int
lMinus1
{-# INLINE foldl1 #-}
sum :: Vec n a -> a
sum = Sum a -> a
coerce (Sum a -> a) -> (Vec n a -> Sum a) -> Vec n a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Sum a) -> Vec n a -> Sum a
forall (t :: Type -> Type) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap a -> Sum a
forall a. a -> Sum a
Sum
{-# INLINE sum #-}
product :: Vec n a -> a
product = Product a -> a
coerce (Product a -> a) -> (Vec n a -> Product a) -> Vec n a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Product a) -> Vec n a -> Product a
forall (t :: Type -> Type) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap a -> Product a
forall a. a -> Product a
Product
{-# INLINE product #-}
minimum :: Vec n a -> a
minimum = (a -> a -> a) -> Vec n a -> a
forall (t :: Type -> Type) a.
Foldable t =>
(a -> a -> a) -> t a -> a
foldr1 a -> a -> a
forall a. Ord a => a -> a -> a
min
{-# INLINE minimum #-}
maximum :: Vec n a -> a
maximum = (a -> a -> a) -> Vec n a -> a
forall (t :: Type -> Type) a.
Foldable t =>
(a -> a -> a) -> t a -> a
foldr1 a -> a -> a
forall a. Ord a => a -> a -> a
max
{-# INLINE maximum #-}
elem :: a -> Vec n a -> Bool
elem a
x = Any -> Bool
coerce (Any -> Bool) -> (Vec n a -> Any) -> Vec n a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Any) -> Vec n a -> Any
forall (t :: Type -> Type) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (Bool -> Any
Any (Bool -> Any) -> (a -> Bool) -> a -> Any
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> a -> Bool
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 :: (a -> f b) -> Vec n a -> f (Vec n b)
traverseVec a -> f b
f = Accessor n (f b) -> f (Vec n b)
forall (f :: Type -> Type) (n :: Nat) a.
Applicative f =>
Accessor n (f a) -> f (Vec n a)
sequenceVA (Accessor n (f b) -> f (Vec n b))
-> (Vec n a -> Accessor n (f b)) -> Vec n a -> f (Vec n b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> f b) -> Accessor n a -> Accessor n (f b)
forall a b (n :: Nat). (a -> b) -> Accessor n a -> Accessor n b
mapVA a -> f b
f (Accessor n a -> Accessor n (f b))
-> (Vec n a -> Accessor n a) -> Vec n a -> Accessor n (f b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec n a -> Accessor n a
forall (n :: Nat) a. Vec n a -> Accessor n a
access
{-# INLINE traverseVec #-}
instance Traversable (Vec n) where
traverse :: (a -> f b) -> Vec n a -> f (Vec n b)
traverse = (a -> f b) -> Vec n a -> f (Vec n b)
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 :: f (Vec n a) -> Vec n (f a)
distribute f (Vec n a)
fxs = (Rep (Vec n) -> f a) -> Vec n (f a)
forall (f :: Type -> Type) a.
Representable f =>
(Rep f -> a) -> f a
tabulate ((Rep (Vec n) -> f a) -> Vec n (f a))
-> (Rep (Vec n) -> f a) -> Vec n (f a)
forall a b. (a -> b) -> a -> b
$ \Rep (Vec n)
i -> (Vec n a -> a) -> f (Vec n a) -> f a
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap (Vec n a -> Fin n -> a
forall (n :: Nat) a. Vec n a -> Fin n -> a
! Rep (Vec n)
Fin n
i) f (Vec n a)
fxs
{-# INLINE distribute #-}
instance KnownNat n => Representable (Vec n) where
type Rep (Vec n) = Fin n
tabulate :: (Rep (Vec n) -> a) -> Vec n a
tabulate = SInt n -> (Fin n -> a) -> Vec n a
forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
tabulateVec SInt n
forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal
{-# INLINE tabulate #-}
index :: Vec n a -> Rep (Vec n) -> a
index = (!)
{-# INLINE index #-}
vscanl :: (b -> a -> b) -> b -> Vec n a -> Vec (1 + n) b
vscanl :: (b -> a -> b) -> b -> Vec n a -> Vec (1 + n) b
vscanl b -> a -> b
f b
b Vec n a
v = SInt (1 + n) -> [b] -> Vec (1 + n) b
forall (n :: Nat) a. SInt n -> [a] -> Vec n a
listVec (SInt 1
forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal SInt 1 -> SInt n -> SInt (1 + n)
forall (m :: Nat) (n :: Nat).
(?callStack::CallStack) =>
SInt m -> SInt n -> SInt (m + n)
`addSInt` Vec n a -> SInt n
forall (n :: Nat) a. Vec n a -> SInt n
svSize Vec n a
v) ([b] -> Vec (1 + n) b) -> ([a] -> [b]) -> [a] -> Vec (1 + n) b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (b -> a -> b) -> b -> [a] -> [b]
forall b a. (b -> a -> b) -> b -> [a] -> [b]
scanl b -> a -> b
f b
b ([a] -> Vec (1 + n) b) -> [a] -> Vec (1 + n) b
forall a b. (a -> b) -> a -> b
$ Vec n a -> [a]
forall (t :: Type -> Type) a. Foldable t => t a -> [a]
F.toList Vec n a
v
nil :: Vec 0 a
nil :: Vec 0 a
nil = SInt 0 -> (Fin 0 -> a) -> Vec 0 a
forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
mkVec SInt 0
forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal (\Fin 0
i -> Fin 0
i Fin 0 -> a -> a
`seq` [Char] -> a
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_ :: Vec n a -> Vec m a -> Vec (n + m) a
append_ Vec n a
xs Vec m a
ys = (forall s. ST s (Vec (n + m) a)) -> Vec (n + m) a
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (Vec (n + m) a)) -> Vec (n + m) a)
-> (forall s. ST s (Vec (n + m) a)) -> Vec (n + m) a
forall a b. (a -> b) -> a -> b
$ do
let !n :: Int
n = Vec n a -> Int
forall (n :: Nat) a. Vec n a -> Int
vSize Vec n a
xs
!m :: Int
m = Vec m a -> Int
forall (n :: Nat) a. Vec n a -> Int
vSize Vec m a
ys
MutableVec s (n + m) a
zs <- Int -> a -> ST s (MutableVec s (n + m) a)
forall a s (n :: Nat). Int -> a -> ST s (MutableVec s n a)
unsafeNewMV (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
m) a
forall a. a
uninitialized
Vec n a -> Int -> MutableVec s (n + m) a -> Int -> Int -> ST s ()
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
Vec m a -> Int -> MutableVec s (n + m) a -> Int -> Int -> ST s ()
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
MutableVec s (n + m) a -> ST s (Vec (n + m) a)
forall s (n :: Nat) a. MutableVec s n a -> ST s (Vec n a)
unsafeFreezeMV MutableVec s (n + m) a
zs
{-# NOINLINE append_ #-}
++ :: Vec n a -> Vec m a -> Vec (n + m) a
(++) = \Vec n a
xs Vec m a
ys -> Accessor (n + m) a -> Vec (n + m) a
forall (n :: Nat) a. Accessor n a -> Vec n a
materialize (Accessor n a -> Accessor m a -> Accessor (n + m) a
forall (n :: Nat) a (m :: Nat).
Accessor n a -> Accessor m a -> Accessor (n + m) a
appendVA (Vec n a -> Accessor n a
forall (n :: Nat) a. Vec n a -> Accessor n a
access Vec n a
xs) (Vec m a -> Accessor m a
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_ :: SInt m -> Vec (m + n) a -> Vec m a
take_ SInt m
m Vec (m + n) a
xs = Vec (m + n) a -> Int -> SInt m -> Vec m a
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_ :: SInt m -> Vec (m + n) a -> Vec n a
drop_ SInt m
m Vec (m + n) a
xs =
Vec (m + n) a -> Int -> SInt n -> Vec n a
forall (n :: Nat) a (m :: Nat). Vec n a -> Int -> SInt m -> Vec m a
sliceVec Vec (m + n) a
xs (SInt m -> Int
forall (n :: Nat). SInt n -> Int
unSInt SInt m
m) (SInt n -> Vec n a) -> SInt n -> Vec n a
forall a b. (a -> b) -> a -> b
$
Vec (m + n) a -> SInt (m + n)
forall (n :: Nat) a. Vec n a -> SInt n
svSize Vec (m + n) a
xs SInt (m + n) -> SInt m -> SInt n
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 :: 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 = Vec (m + n) a -> Accessor (m + n) a
forall (n :: Nat) a. Vec n a -> Accessor n a
access Vec (m + n) a
xs
in (Accessor m a -> Vec m a
forall (n :: Nat) a. Accessor n a -> Vec n a
materialize (SInt m -> Accessor (m + n) a -> Accessor m a
forall (m :: Nat) (n :: Nat) a.
SInt m -> Accessor (m + n) a -> Accessor m a
takeVA SInt m
m Accessor (m + n) a
va), Accessor n a -> Vec n a
forall (n :: Nat) a. Accessor n a -> Vec n a
materialize (SInt m -> Accessor (m + n) a -> Accessor n a
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 :: Vec n (Vec m a) -> Vec (n * m) a
concat Vec n (Vec m a)
xs =
let !n :: Int
n = Vec n (Vec m a) -> Int
forall (n :: Nat) a. Vec n a -> Int
vSize Vec n (Vec m a)
xs
in if Int
n Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 then
Int
-> (forall s. MutableVec s (n * m) a -> ST s ()) -> Vec (n * m) a
forall (n :: Nat) a.
Int -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
unsafeCreateVec Int
0 ((forall s. MutableVec s (n * m) a -> ST s ()) -> Vec (n * m) a)
-> (forall s. MutableVec s (n * m) a -> ST s ()) -> Vec (n * m) a
forall a b. (a -> b) -> a -> b
$ \ MutableVec s (n * m) a
_ -> () -> ST s ()
forall (m :: Type -> Type) a. Monad m => a -> m a
return ()
else
let !m :: Int
m = Vec n (Vec m a) -> Int -> (Vec m a -> Int) -> Int
forall (n :: Nat) a r. Vec n a -> Int -> (a -> r) -> r
unsafeIndexK Vec n (Vec m a)
xs Int
0 Vec m a -> Int
forall (n :: Nat) a. Vec n a -> Int
vSize
in Int
-> (forall s. MutableVec s (n * m) a -> ST s ()) -> Vec (n * m) a
forall (n :: Nat) a.
Int -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
unsafeCreateVec (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
m) ((forall s. MutableVec s (n * m) a -> ST s ()) -> Vec (n * m) a)
-> (forall s. MutableVec s (n * m) a -> ST s ()) -> Vec (n * m) a
forall a b. (a -> b) -> a -> b
$ \ MutableVec s (n * m) a
marr ->
[Int] -> (Int -> ST s ()) -> ST s ()
forall (t :: Type -> Type) (m :: Type -> Type) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
F.forM_ [Int
0..Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1] ((Int -> ST s ()) -> ST s ()) -> (Int -> ST s ()) -> ST s ()
forall a b. (a -> b) -> a -> b
$ \ Int
i ->
Vec n (Vec m a) -> Int -> (Vec m a -> ST s ()) -> ST s ()
forall (n :: Nat) a r. Vec n a -> Int -> (a -> r) -> r
unsafeIndexK Vec n (Vec m a)
xs Int
i ((Vec m a -> ST s ()) -> ST s ())
-> (Vec m a -> ST s ()) -> ST s ()
forall a b. (a -> b) -> a -> b
$ \ Vec m a
ys ->
Vec m a -> Int -> MutableVec s (n * m) a -> Int -> Int -> ST s ()
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 Int -> Int -> Int
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 :: SInt m -> Vec (n * m) a -> Vec n (Vec m a)
reshape SInt m
m =
let !m' :: Int
m' = SInt m -> Int
forall (n :: Nat). SInt n -> Int
unSInt SInt m
m
in \Vec (n * m) a
xs ->
SInt n -> (Fin n -> Vec m a) -> Vec n (Vec m a)
forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
mkVec (Vec (n * m) a -> SInt (n * m)
forall (n :: Nat) a. Vec n a -> SInt n
svSize Vec (n * m) a
xs SInt (n * m) -> SInt m -> SInt n
forall (m :: Nat) (n :: Nat). SInt (m * n) -> SInt n -> SInt m
`divSIntR` SInt m
m) (\Fin n
i -> Vec (n * m) a -> Int -> SInt m -> Vec m a
forall (n :: Nat) a (m :: Nat). Vec n a -> Int -> SInt m -> Vec m a
sliceVec Vec (n * m) a
xs (Fin n -> Int
forall (n :: Nat). Fin n -> Int
finToInt Fin n
i Int -> Int -> Int
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 :: (a -> Vec m b) -> Vec n a -> Vec (n * m) b
concatMap a -> Vec m b
f = Vec n (Vec m b) -> Vec (n * m) b
forall (m :: Nat) (n :: Nat) a. Vec n (Vec m a) -> Vec (n * m) a
concat (Vec n (Vec m b) -> Vec (n * m) b)
-> (Vec n a -> Vec n (Vec m b)) -> Vec n a -> Vec (n * m) b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Vec m b) -> Vec n a -> Vec n (Vec m b)
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 :: SInt n -> (a -> a) -> a -> Vec n a
iterate SInt n
sn a -> a
f a
z =
SInt n -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
forall (n :: Nat) a.
SInt n -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
createVec SInt n
sn ((forall s. MutableVec s n a -> ST s ()) -> Vec n a)
-> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
forall a b. (a -> b) -> a -> b
$ \MutableVec s n a
mv ->
SInt n -> (a -> Fin n -> ST s a) -> a -> ST s ()
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 a -> ST s () -> ST s a
forall (f :: Type -> Type) a b. Functor f => a -> f b -> f a
<$ MutableVec s n a -> Fin n -> a -> ST s ()
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' :: SInt n -> (a -> a) -> a -> Vec n a
iterate' SInt n
sn a -> a
f !a
z =
SInt n -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
forall (n :: Nat) a.
SInt n -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
createVec SInt n
sn ((forall s. MutableVec s n a -> ST s ()) -> Vec n a)
-> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
forall a b. (a -> b) -> a -> b
$ \MutableVec s n a
mv ->
SInt n -> (a -> Fin n -> ST s a) -> a -> ST s ()
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 a -> ST s () -> ST s a
forall (f :: Type -> Type) a b. Functor f => a -> f b -> f a
<$ (MutableVec s n a -> Fin n -> a -> ST s ()
forall s (n :: Nat) a. MutableVec s n a -> Fin n -> a -> ST s ()
writeMV MutableVec s n a
mv Fin n
i (a -> ST s ()) -> a -> ST s ()
forall a b. (a -> b) -> a -> b
$! a
x)) a
z
{-# INLINE iterate' #-}
rev :: Vec n a -> Vec n a
rev :: Vec n a -> Vec n a
rev = Accessor n a -> Vec n a
forall (n :: Nat) a. Accessor n a -> Vec n a
materialize (Accessor n a -> Vec n a)
-> (Vec n a -> Accessor n a) -> Vec n a -> Vec n a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Accessor n a -> Accessor n a
forall (n :: Nat) a. Accessor n a -> Accessor n a
revVA (Accessor n a -> Accessor n a)
-> (Vec n a -> Accessor n a) -> Vec n a -> Accessor n a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec n a -> Accessor n a
forall (n :: Nat) a. Vec n a -> Accessor n a
access
{-# INLINE rev #-}
rot, rot_ :: Fin n -> Vec n a -> Vec n a
rot_ :: Fin n -> Vec n a -> Vec n a
rot_ Fin n
o' Vec n a
xs = SInt n -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
forall (n :: Nat) a.
SInt n -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
createVec (Vec n a -> SInt n
forall (n :: Nat) a. Vec n a -> SInt n
svSize Vec n a
xs) ((forall s. MutableVec s n a -> ST s ()) -> Vec n a)
-> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
forall a b. (a -> b) -> a -> b
$ \MutableVec s n a
mv -> do
let o :: Int
o = Fin n -> Int
forall (n :: Nat). Fin n -> Int
finToInt Fin n
o'
nmo :: Int
nmo = Vec n a -> Int
forall (n :: Nat) a. Vec n a -> Int
vSize Vec n a
xs Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
o
Vec n a -> Int -> MutableVec s n a -> Int -> Int -> ST s ()
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
Vec n a -> Int -> MutableVec s n a -> Int -> Int -> ST s ()
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 :: Fin n -> Vec n a -> Vec n a
rot Fin n
o = \Vec n a
v -> Accessor n a -> Vec n a
forall (n :: Nat) a. Accessor n a -> Vec n a
materialize (Fin n -> Accessor n a -> Accessor n a
forall (n :: Nat) a. Fin n -> Accessor n a -> Accessor n a
rotVA Fin n
o (Vec n a -> Accessor n a
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 :: SInt n -> Vec n (Fin n)
viota SInt n
sn = SInt n -> (Fin n -> Fin n) -> Vec n (Fin n)
forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
mkVec SInt n
sn Fin n -> Fin n
forall a. a -> a
id
{-# INLINE viota #-}
cross :: Vec m a -> Vec n b -> Vec n (Vec m (a, b))
cross :: Vec m a -> Vec n b -> Vec n (Vec m (a, b))
cross Vec m a
xs = (b -> Vec m (a, b)) -> Vec n b -> Vec n (Vec m (a, b))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap (\b
y -> (a -> (a, b)) -> Vec m a -> Vec m (a, b)
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 :: Int -> a -> Vec n a -> Vec (n + 1) a
unsafeInsert Int
i a
xi Vec n a
xs =
let !n :: Int
n = Vec n a -> Int
forall (n :: Nat) a. Vec n a -> Int
vSize Vec n a
xs
in Int
-> (forall s. MutableVec s (n + 1) a -> ST s ()) -> Vec (n + 1) a
forall (n :: Nat) a.
Int -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
unsafeCreateVec (Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1) ((forall s. MutableVec s (n + 1) a -> ST s ()) -> Vec (n + 1) a)
-> (forall s. MutableVec s (n + 1) a -> ST s ()) -> Vec (n + 1) a
forall a b. (a -> b) -> a -> b
$ \ MutableVec s (n + 1) a
mv -> do
Vec n a -> Int -> MutableVec s (n + 1) a -> Int -> Int -> ST s ()
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
MutableVec s (n + 1) a -> Int -> a -> ST s ()
forall s (n :: Nat) a. MutableVec s n a -> Int -> a -> ST s ()
unsafeWriteMV MutableVec s (n + 1) a
mv Int
i a
xi
Vec n a -> Int -> MutableVec s (n + 1) a -> Int -> Int -> ST s ()
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 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
i)
insert :: Fin (n+1) -> a -> Vec n a -> Vec (n+1) a
insert :: Fin (n + 1) -> a -> Vec n a -> Vec (n + 1) a
insert Fin (n + 1)
i = Int -> a -> Vec n a -> Vec (n + 1) a
forall a (n :: Nat). Int -> a -> Vec n a -> Vec (n + 1) a
unsafeInsert (Fin (n + 1) -> Int
forall (n :: Nat). Fin n -> Int
finToInt Fin (n + 1)
i)
unsafeRemove :: Int -> Vec (n+1) a -> Vec n a
unsafeRemove :: Int -> Vec (n + 1) a -> Vec n a
unsafeRemove Int
i Vec (n + 1) a
xs =
let !np1 :: Int
np1 = Vec (n + 1) a -> Int
forall (n :: Nat) a. Vec n a -> Int
vSize Vec (n + 1) a
xs
in Int -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
forall (n :: Nat) a.
Int -> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
unsafeCreateVec (Int
np1 Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) ((forall s. MutableVec s n a -> ST s ()) -> Vec n a)
-> (forall s. MutableVec s n a -> ST s ()) -> Vec n a
forall a b. (a -> b) -> a -> b
$ \ MutableVec s n a
mv -> do
Vec (n + 1) a -> Int -> MutableVec s n a -> Int -> Int -> ST s ()
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
Vec (n + 1) a -> Int -> MutableVec s n a -> Int -> Int -> ST s ()
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
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1) MutableVec s n a
mv Int
i (Int
np1 Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1 Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
i)
remove :: Fin (n+1) -> Vec (n+1) a -> Vec n a
remove :: Fin (n + 1) -> Vec (n + 1) a -> Vec n a
remove Fin (n + 1)
i = Int -> Vec (n + 1) a -> Vec n a
forall (n :: Nat) a. Int -> Vec (n + 1) a -> Vec n a
unsafeRemove (Fin (n + 1) -> Int
forall (n :: Nat). Fin n -> Int
finToInt Fin (n + 1)
i)
vsort :: Ord a => Vec n a -> Vec n a
vsort :: Vec n a -> Vec n a
vsort Vec n a
xs = SInt n -> [a] -> Vec n a
forall (n :: Nat) a. SInt n -> [a] -> Vec n a
listVec (Vec n a -> SInt n
forall (n :: Nat) a. Vec n a -> SInt n
svSize Vec n a
xs) ([a] -> Vec n a) -> (Vec n a -> [a]) -> Vec n a -> Vec n a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> [a]
forall a. Ord a => [a] -> [a]
L.sort ([a] -> [a]) -> (Vec n a -> [a]) -> Vec n a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec n a -> [a]
forall (t :: Type -> Type) a. Foldable t => t a -> [a]
F.toList (Vec n a -> Vec n a) -> Vec n a -> Vec n a
forall a b. (a -> b) -> a -> b
$ Vec n a
xs
vsortBy :: (a -> a -> Ordering) -> Vec n a -> Vec n a
vsortBy :: (a -> a -> Ordering) -> Vec n a -> Vec n a
vsortBy a -> a -> Ordering
f Vec n a
xs = SInt n -> [a] -> Vec n a
forall (n :: Nat) a. SInt n -> [a] -> Vec n a
listVec (Vec n a -> SInt n
forall (n :: Nat) a. Vec n a -> SInt n
svSize Vec n a
xs)([a] -> Vec n a) -> (Vec n a -> [a]) -> Vec n a -> Vec n a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> a -> Ordering) -> [a] -> [a]
forall a. (a -> a -> Ordering) -> [a] -> [a]
L.sortBy a -> a -> Ordering
f ([a] -> [a]) -> (Vec n a -> [a]) -> Vec n a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec n a -> [a]
forall (t :: Type -> Type) a. Foldable t => t a -> [a]
F.toList (Vec n a -> Vec n a) -> Vec n a -> Vec n a
forall a b. (a -> b) -> a -> b
$ Vec n a
xs
vsortOn :: Ord b => (a -> b) -> Vec n a -> Vec n a
vsortOn :: (a -> b) -> Vec n a -> Vec n a
vsortOn a -> b
f Vec n a
xs = SInt n -> [a] -> Vec n a
forall (n :: Nat) a. SInt n -> [a] -> Vec n a
listVec (Vec n a -> SInt n
forall (n :: Nat) a. Vec n a -> SInt n
svSize Vec n a
xs)([a] -> Vec n a) -> (Vec n a -> [a]) -> Vec n a -> Vec n a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> [a] -> [a]
forall b a. Ord b => (a -> b) -> [a] -> [a]
L.sortOn a -> b
f ([a] -> [a]) -> (Vec n a -> [a]) -> Vec n a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec n a -> [a]
forall (t :: Type -> Type) a. Foldable t => t a -> [a]
F.toList (Vec n a -> Vec n a) -> Vec n a -> Vec n a
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 :: 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 = Vec n (Vec m a) -> Int
forall (n :: Nat) a. Vec n a -> Int
vSize Vec n (Vec m a)
xs
!t :: Int
t = SInt m -> Int
forall (n :: Nat). SInt n -> Int
unSInt SInt m
sm
in Int -> (Int -> Vec n a) -> Vec m (Vec n a)
forall a (n :: Nat). Int -> (Int -> a) -> Vec n a
unsafeMkVec Int
t ((Int -> Vec n a) -> Vec m (Vec n a))
-> (Int -> Vec n a) -> Vec m (Vec n a)
forall a b. (a -> b) -> a -> b
$ \ Int
i ->
Int -> (Int -> a) -> Vec n a
forall a (n :: Nat). Int -> (Int -> a) -> Vec n a
unsafeMkVec Int
s ((Int -> a) -> Vec n a) -> (Int -> a) -> Vec n a
forall a b. (a -> b) -> a -> b
$ \ Int
j ->
Vec n (Vec m a) -> Int -> (Vec m a -> a) -> a
forall (n :: Nat) a r. Vec n a -> Int -> (a -> r) -> r
unsafeIndexK Vec n (Vec m a)
xs Int
j ((Vec m a -> a) -> a) -> (Vec m a -> a) -> a
forall a b. (a -> b) -> a -> b
$ \ Vec m a
v -> Vec m a -> Int -> (a -> a) -> a
forall (n :: Nat) a r. Vec n a -> Int -> (a -> r) -> r
unsafeIndexK Vec m a
v Int
i a -> a
forall a. a -> a
id
vfindIndex :: (a -> Bool) -> Vec n a -> Maybe (Fin n)
vfindIndex :: (a -> Bool) -> Vec n a -> Maybe (Fin n)
vfindIndex a -> Bool
p = (Int -> Fin n) -> Maybe Int -> Maybe (Fin n)
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap Int -> Fin n
forall a (n :: Nat). Integral a => a -> Fin n
unsafeFin (Maybe Int -> Maybe (Fin n))
-> (Vec n a -> Maybe Int) -> Vec n a -> Maybe (Fin n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Bool) -> [a] -> Maybe Int
forall a. (a -> Bool) -> [a] -> Maybe Int
L.findIndex a -> Bool
p ([a] -> Maybe Int) -> (Vec n a -> [a]) -> Vec n a -> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vec n a -> [a]
forall (t :: Type -> Type) a. Foldable t => t a -> [a]
F.toList
vec1 :: a -> Vec 1 a
vec1 :: a -> Vec 1 a
vec1 = a -> Vec 1 a
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure
{-# INLINE vec1 #-}
vec2 :: a -> a -> Vec 2 a
vec2 :: a -> a -> Vec 2 a
vec2 a
x0 a
x1 = SInt 2 -> (Fin 2 -> a) -> Vec 2 a
forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
mkVec SInt 2
forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal ((Fin 2 -> a) -> Vec 2 a) -> (Fin 2 -> a) -> Vec 2 a
forall a b. (a -> b) -> a -> b
$ \Fin 2
i -> case Fin 2 -> Int
forall (n :: Nat). Fin n -> Int
finToInt Fin 2
i of
Int
0 -> a
x0
Int
1 -> a
x1
Int
_ -> [Char] -> a
forall a. (?callStack::CallStack) => [Char] -> a
error [Char]
"Impossible: Fin out of range"
{-# INLINE vec2 #-}
vec3 :: a -> a -> a -> Vec 3 a
vec3 :: a -> a -> a -> Vec 3 a
vec3 a
x0 a
x1 a
x2 = SInt 3 -> (Fin 3 -> a) -> Vec 3 a
forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
mkVec SInt 3
forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal ((Fin 3 -> a) -> Vec 3 a) -> (Fin 3 -> a) -> Vec 3 a
forall a b. (a -> b) -> a -> b
$ \Fin 3
i -> case Fin 3 -> Int
forall (n :: Nat). Fin n -> Int
finToInt Fin 3
i of
Int
0 -> a
x0
Int
1 -> a
x1
Int
2 -> a
x2
Int
_ -> [Char] -> a
forall a. (?callStack::CallStack) => [Char] -> a
error [Char]
"Impossible: Fin out of range"
{-# INLINE vec3 #-}
vec4 :: a -> a -> a -> a -> Vec 4 a
vec4 :: a -> a -> a -> a -> Vec 4 a
vec4 a
x0 a
x1 a
x2 a
x3 = SInt 4 -> (Fin 4 -> a) -> Vec 4 a
forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
mkVec SInt 4
forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal ((Fin 4 -> a) -> Vec 4 a) -> (Fin 4 -> a) -> Vec 4 a
forall a b. (a -> b) -> a -> b
$ \Fin 4
i -> case Fin 4 -> Int
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
_ -> [Char] -> a
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 :: a -> a -> a -> a -> a -> a -> Vec 6 a
vec6 a
x0 a
x1 a
x2 a
x3 a
x4 a
x5 = SInt 6 -> (Fin 6 -> a) -> Vec 6 a
forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
mkVec SInt 6
forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal ((Fin 6 -> a) -> Vec 6 a) -> (Fin 6 -> a) -> Vec 6 a
forall a b. (a -> b) -> a -> b
$ \Fin 6
i -> case Fin 6 -> Int
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
_ -> [Char] -> a
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 :: 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 = SInt 8 -> (Fin 8 -> a) -> Vec 8 a
forall (n :: Nat) a. SInt n -> (Fin n -> a) -> Vec n a
mkVec SInt 8
forall (n :: Nat). (?callStack::CallStack, KnownNat n) => SInt n
sintVal ((Fin 8 -> a) -> Vec 8 a) -> (Fin 8 -> a) -> Vec 8 a
forall a b. (a -> b) -> a -> b
$ \Fin 8
i -> case Fin 8 -> Int
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
_ -> [Char] -> a
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 :: i
valueOf = Natural -> i
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Natural -> i) -> Natural -> i
forall a b. (a -> b) -> a -> b
$ Proxy# n -> Natural
forall (n :: Nat). KnownNat n => Proxy# n -> Natural
natVal' (Proxy# n
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 :: Fin n -> (a -> a) -> Vec n a -> Vec n a
overIx Fin n
i a -> a
f Vec n a
v = (forall s. ST s (Vec n a)) -> Vec n a
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (Vec n a)) -> Vec n a)
-> (forall s. ST s (Vec n a)) -> Vec n a
forall a b. (a -> b) -> a -> b
$ do
MutableVec s n a
mv <- Vec n a -> ST s (MutableVec s n a)
forall (n :: Nat) a s. Vec n a -> ST s (MutableVec s n a)
safeThawMV Vec n a
v
Vec n a -> Fin n -> (a -> ST s ()) -> ST s ()
forall (n :: Nat) a r. Vec n a -> Fin n -> (a -> r) -> r
indexK Vec n a
v Fin n
i (MutableVec s n a -> Fin n -> a -> ST s ()
forall s (n :: Nat) a. MutableVec s n a -> Fin n -> a -> ST s ()
writeMV MutableVec s n a
mv Fin n
i (a -> ST s ()) -> (a -> a) -> a -> ST s ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a
f)
MutableVec s n a -> ST s (Vec n a)
forall s (n :: Nat) a. MutableVec s n a -> ST s (Vec n a)
unsafeFreezeMV MutableVec s n a
mv
{-# INLINE overIx #-}