module Synthesizer.ChunkySize.Cut where
import qualified Synthesizer.ChunkySize as ChunkySize
import qualified Synthesizer.Generic.Cut as Cut
import qualified Synthesizer.Generic.Signal as SigG
import qualified Synthesizer.State.Signal as SigS
import qualified Data.StorableVector.Lazy.Pattern as SigStV
import qualified Data.StorableVector.Lazy as Vector
import Foreign.Storable (Storable)
import qualified Number.NonNegativeChunky as Chunky
import qualified Data.List.Match as Match
import qualified Data.List as List
import Data.Tuple.HT (mapPair, )
import Data.Monoid (Monoid, )
import NumericPrelude.Numeric
import NumericPrelude.Base hiding (splitAt, Read, )
import Prelude ()
class Cut.Read sig => Read sig where
length :: sig -> ChunkySize.T
class (Read sig, Monoid sig) => Transform sig where
take :: ChunkySize.T -> sig -> sig
drop :: ChunkySize.T -> sig -> sig
splitAt :: ChunkySize.T -> sig -> (sig, sig)
instance Storable y => Read (Vector.Vector y) where
{-# INLINE length #-}
length :: Vector y -> T
length = LazySize -> T
ChunkySize.fromStorableVectorSize (LazySize -> T) -> (Vector y -> LazySize) -> Vector y -> T
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector y -> LazySize
forall a. Vector a -> LazySize
SigStV.length
instance Storable y => Transform (Vector.Vector y) where
{-# INLINE take #-}
take :: T -> Vector y -> Vector y
take = LazySize -> Vector y -> Vector y
forall a. Storable a => LazySize -> Vector a -> Vector a
SigStV.take (LazySize -> Vector y -> Vector y)
-> (T -> LazySize) -> T -> Vector y -> Vector y
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T -> LazySize
ChunkySize.toStorableVectorSize
{-# INLINE drop #-}
drop :: T -> Vector y -> Vector y
drop = LazySize -> Vector y -> Vector y
forall a. Storable a => LazySize -> Vector a -> Vector a
SigStV.drop (LazySize -> Vector y -> Vector y)
-> (T -> LazySize) -> T -> Vector y -> Vector y
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T -> LazySize
ChunkySize.toStorableVectorSize
{-# INLINE splitAt #-}
splitAt :: T -> Vector y -> (Vector y, Vector y)
splitAt = LazySize -> Vector y -> (Vector y, Vector y)
forall a.
Storable a =>
LazySize -> Vector a -> (Vector a, Vector a)
SigStV.splitAt (LazySize -> Vector y -> (Vector y, Vector y))
-> (T -> LazySize) -> T -> Vector y -> (Vector y, Vector y)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T -> LazySize
ChunkySize.toStorableVectorSize
instance Read ([] y) where
{-# INLINE length #-}
length :: [y] -> T
length [y]
xs =
[LazySize] -> T
forall a. C a => [a] -> T a
Chunky.fromChunks ([LazySize] -> T) -> [LazySize] -> T
forall a b. (a -> b) -> a -> b
$ [y] -> LazySize -> [LazySize]
forall a b. [a] -> b -> [b]
Match.replicate [y]
xs (LazySize -> [LazySize]) -> LazySize -> [LazySize]
forall a b. (a -> b) -> a -> b
$ Int -> LazySize
SigG.LazySize Int
forall a. C a => a
one
instance Transform ([] y) where
{-# INLINE take #-}
take :: T -> [y] -> [y]
take T
ns =
[()] -> [y] -> [y]
forall b a. [b] -> [a] -> [a]
Match.take (T -> [()]
ChunkySize.toNullList T
ns)
{-# INLINE drop #-}
drop :: T -> [y] -> [y]
drop T
ns [y]
xs =
([y] -> LazySize -> [y]) -> [y] -> [LazySize] -> [y]
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl
(\[y]
x (SigG.LazySize Int
n) -> Int -> [y] -> [y]
forall a. Int -> [a] -> [a]
List.drop Int
n [y]
x)
[y]
xs (T -> [LazySize]
forall a. C a => T a -> [a]
Chunky.toChunks T
ns)
{-# INLINE splitAt #-}
splitAt :: T -> [y] -> ([y], [y])
splitAt T
ns =
[()] -> [y] -> ([y], [y])
forall b a. [b] -> [a] -> ([a], [a])
Match.splitAt (T -> [()]
ChunkySize.toNullList T
ns)
instance Read (SigS.T y) where
{-# INLINE length #-}
length :: T y -> T
length =
[LazySize] -> T
forall a. C a => [a] -> T a
Chunky.fromChunks ([LazySize] -> T) -> (T y -> [LazySize]) -> T y -> T
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T LazySize -> [LazySize]
forall y. T y -> [y]
SigS.toList (T LazySize -> [LazySize])
-> (T y -> T LazySize) -> T y -> [LazySize]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
(y -> LazySize) -> T y -> T LazySize
forall a b. (a -> b) -> T a -> T b
SigS.map (LazySize -> y -> LazySize
forall a b. a -> b -> a
const (Int -> LazySize
SigG.LazySize Int
forall a. C a => a
one))
instance Transform (SigS.T y) where
{-# INLINE take #-}
take :: T -> T y -> T y
take T
size0 =
(y -> (Int, [LazySize]) -> Maybe (y, (Int, [LazySize])))
-> (Int, [LazySize]) -> T y -> T y
forall x acc y. (x -> acc -> Maybe (y, acc)) -> acc -> T x -> T y
SigS.crochetL
(\y
x (Int
n,[LazySize]
ns) ->
if Int
nInt -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>Int
forall a. C a => a
zero
then (y, (Int, [LazySize])) -> Maybe (y, (Int, [LazySize]))
forall a. a -> Maybe a
Just (y
x, (Int -> Int
forall a. Enum a => a -> a
pred Int
n, [LazySize]
ns))
else
case [LazySize]
ns of
SigG.LazySize Int
m : [LazySize]
ms -> (y, (Int, [LazySize])) -> Maybe (y, (Int, [LazySize]))
forall a. a -> Maybe a
Just (y
x, (Int -> Int
forall a. Enum a => a -> a
pred Int
m, [LazySize]
ms))
[] -> Maybe (y, (Int, [LazySize]))
forall a. Maybe a
Nothing)
(Int
forall a. C a => a
zero, T -> [LazySize]
forall a. C a => T a -> [a]
Chunky.toChunks (T -> [LazySize]) -> T -> [LazySize]
forall a b. (a -> b) -> a -> b
$ T -> T
forall a. C a => T a -> T a
Chunky.normalize T
size0)
{-# INLINE drop #-}
drop :: T -> T y -> T y
drop T
ns T y
xs =
(T y -> LazySize -> T y) -> T y -> [LazySize] -> T y
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl
(\T y
x (SigG.LazySize Int
n) -> Int -> T y -> T y
forall a. Int -> T a -> T a
SigS.drop Int
n T y
x)
T y
xs (T -> [LazySize]
forall a. C a => T a -> [a]
Chunky.toChunks T
ns)
{-# INLINE splitAt #-}
splitAt :: T -> T y -> (T y, T y)
splitAt T
n =
([y] -> T y, [y] -> T y) -> ([y], [y]) -> (T y, T y)
forall a c b d. (a -> c, b -> d) -> (a, b) -> (c, d)
mapPair ([y] -> T y
forall y. [y] -> T y
SigS.fromList, [y] -> T y
forall y. [y] -> T y
SigS.fromList) (([y], [y]) -> (T y, T y))
-> (T y -> ([y], [y])) -> T y -> (T y, T y)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
T -> [y] -> ([y], [y])
forall sig. Transform sig => T -> sig -> (sig, sig)
splitAt T
n ([y] -> ([y], [y])) -> (T y -> [y]) -> T y -> ([y], [y])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T y -> [y]
forall y. T y -> [y]
SigS.toList