{-# LANGUAGE NoImplicitPrelude #-}
{- |
Copyright   :  (c) Henning Thielemann 2006
License     :  GPL

Maintainer  :  synthesizer@henning-thielemann.de
Stability   :  provisional
Portability :  requires multi-parameter type classes


Similar to "Synthesizer.Inference.Monad.Signal.Cut"
but the functions have monadic input and sequentialize it.
See "Synthesizer.Inference.Monad.SignalSeq".
-}
module Synthesizer.Inference.Monad.SignalSeq.Cut (
   {- * dissection -}
   splitAt,
   take,
   drop,
   takeUntilPause,
   unzip,
   unzip3,

   {- * glueing -}
   concat,
   append,
   zip,
   zip3) where

import qualified UniqueLogicNP.Explicit.Process    as Process
import qualified Synthesizer.Inference.Monad.Signal     as SigI
import qualified Synthesizer.Inference.Monad.Signal.Cut as CutI

import qualified Algebra.NormedSpace.Maximum as NormedMax
import qualified Algebra.OccasionallyScalar  as OccScalar
import qualified Algebra.Module              as Module
import qualified Algebra.RealField           as RealField
import qualified Algebra.Field               as Field
import qualified Algebra.Real                as Real
import qualified Algebra.Ring                as Ring

import UniqueLogicNP.Monad(liftP, liftP2, liftP3)
import PreludeBase (Ord, (.), sequence)
-- import NumericPrelude

{- * dissection -}

splitAt :: (RealField.C a, Field.C q, OccScalar.C a q) =>
   q -> SigI.Process a q v -> Process.T q (SigI.T a q v, SigI.T a q v)
splitAt t = liftP (CutI.splitAt t)

take :: (RealField.C a, Field.C q, OccScalar.C a q) =>
   q -> SigI.Process a q v -> SigI.Process a q v
take t = liftP (CutI.take t)

drop :: (RealField.C a, Field.C q, OccScalar.C a q) =>
   q -> SigI.Process a q v -> SigI.Process a q v
drop t = liftP (CutI.drop t)

takeUntilPause :: (RealField.C a, Field.C q,
                   NormedMax.C a v, OccScalar.C a q) =>
   q -> q -> SigI.Process a q v -> SigI.Process a q v
takeUntilPause y t = liftP (CutI.takeUntilPause y t)


unzip ::
   SigI.Process a q (v0, v1) -> Process.T q (SigI.T a q v0, SigI.T a q v1)
unzip = liftP CutI.unzip

unzip3 ::
      SigI.Process a q (v0, v1, v2)
   -> Process.T q (SigI.T a q v0, SigI.T a q v1, SigI.T a q v2)
unzip3 = liftP CutI.unzip3



{- * glueing -}

{- More efficient than 'foldr1 append'
   because it reduces the number of amplifications. -}
concat :: (RealField.C q, Ord q, Ring.C q, OccScalar.C a q,
           Module.C a v) =>
   [SigI.Process a q v] -> SigI.Process a q v
concat = liftP CutI.concat . sequence

append :: (Real.C q, Field.C q, Ord q, OccScalar.C a q,
         Module.C a v) =>
   SigI.Process a q v -> SigI.Process a q v -> SigI.Process a q v
append = liftP2 CutI.append


zip :: (Real.C q, Field.C q, Ord q, OccScalar.C a q,
        Module.C a v0, Module.C a v1)
   => SigI.Process a q v0
   -> SigI.Process a q v1
   -> SigI.Process a q (v0, v1)
zip = liftP2 CutI.zip

zip3 :: (Real.C q, Field.C q, Ord q, OccScalar.C a q,
         Module.C a v0, Module.C a v1, Module.C a v2)
   => SigI.Process a q v0
   -> SigI.Process a q v1
   -> SigI.Process a q v2
   -> SigI.Process a q (v0, v1, v2)
zip3 = liftP3 CutI.zip3