{-# LANGUAGE FlexibleInstances, BangPatterns #-}

{-
    Core.hs - For functions judged to be 'core' to tidal functionality.
    Copyright (C) 2020, Alex McLean and contributors

    This library is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this library.  If not, see <http://www.gnu.org/licenses/>.
-}

module Sound.Tidal.Core where

import           Prelude hiding ((<*), (*>))

import           Data.Fixed (mod')
import qualified Data.Map.Strict as Map
import           Data.Maybe (fromMaybe)
import           Sound.Tidal.Pattern

-- ** Elemental patterns

{-| Takes a function of time to values, and turns it into a 'Pattern'.
  Useful for creating continuous patterns such as 'sine' or 'perlin'.

  For example, 'saw' is defined as

  > saw = sig $ \t -> mod' (fromRational t) 1
-}
sig :: (Time -> a) -> Pattern a
sig :: forall a. (Rational -> a) -> Pattern a
sig Rational -> a
f = (State -> [Event a]) -> Pattern a
forall a. (State -> [Event a]) -> Pattern a
Pattern State -> [Event a]
q
  where q :: State -> [Event a]
q (State (Arc Rational
s Rational
e) ValueMap
_)
          | Rational
s Rational -> Rational -> Bool
forall a. Ord a => a -> a -> Bool
> Rational
e = []
          | Bool
otherwise = [Context -> Maybe (ArcF Rational) -> ArcF Rational -> a -> Event a
forall a b. Context -> Maybe a -> a -> b -> EventF a b
Event ([((Int, Int), (Int, Int))] -> Context
Context []) Maybe (ArcF Rational)
forall a. Maybe a
Nothing (Rational -> Rational -> ArcF Rational
forall a. a -> a -> ArcF a
Arc Rational
s Rational
e) (Rational -> a
f (Rational
sRational -> Rational -> Rational
forall a. Num a => a -> a -> a
+((Rational
eRational -> Rational -> Rational
forall a. Num a => a -> a -> a
-Rational
s)Rational -> Rational -> Rational
forall a. Fractional a => a -> a -> a
/Rational
2)))]

-- | @sine@ - unipolar sinewave. A pattern of continuous values following a
-- sinewave with frequency of one cycle, and amplitude from 0 to 1.
sine :: Fractional a => Pattern a
sine :: forall a. Fractional a => Pattern a
sine = (Rational -> a) -> Pattern a
forall a. (Rational -> a) -> Pattern a
sig ((Rational -> a) -> Pattern a) -> (Rational -> a) -> Pattern a
forall a b. (a -> b) -> a -> b
$ \Rational
t -> (Double -> a
sin_rat ((Double
forall a. Floating a => a
pi :: Double) Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Rational -> Double
forall a. Fractional a => Rational -> a
fromRational Rational
t) a -> a -> a
forall a. Num a => a -> a -> a
+ a
1) a -> a -> a
forall a. Fractional a => a -> a -> a
/ a
2
  where sin_rat :: Double -> a
sin_rat = Rational -> a
forall a. Fractional a => Rational -> a
fromRational (Rational -> a) -> (Double -> Rational) -> Double -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> Rational
forall a. Real a => a -> Rational
toRational (Double -> Rational) -> (Double -> Double) -> Double -> Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> Double
forall a. Floating a => a -> a
sin

-- | @sine2@ - bipolar sinewave. A pattern of continuous values following a
-- sinewave with frequency of one cycle, and amplitude from -1 to 1.
sine2 :: Fractional a => Pattern a
sine2 :: forall a. Fractional a => Pattern a
sine2 = (Rational -> a) -> Pattern a
forall a. (Rational -> a) -> Pattern a
sig ((Rational -> a) -> Pattern a) -> (Rational -> a) -> Pattern a
forall a b. (a -> b) -> a -> b
$ \Rational
t -> Double -> a
sin_rat ((Double
forall a. Floating a => a
pi :: Double) Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Rational -> Double
forall a. Fractional a => Rational -> a
fromRational Rational
t)
  where sin_rat :: Double -> a
sin_rat = Rational -> a
forall a. Fractional a => Rational -> a
fromRational (Rational -> a) -> (Double -> Rational) -> Double -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> Rational
forall a. Real a => a -> Rational
toRational (Double -> Rational) -> (Double -> Double) -> Double -> Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> Double
forall a. Floating a => a -> a
sin

-- | @cosine@ - unipolar cosine wave. A pattern of continuous values
-- following a cosine with frequency of one cycle, and amplitude from
-- 0 to 1. Equivalent to @0.25 ~> sine@.
cosine :: Fractional a => Pattern a
cosine :: forall a. Fractional a => Pattern a
cosine = Rational
0.25 Rational -> Pattern a -> Pattern a
forall a. Rational -> Pattern a -> Pattern a
`rotR` Pattern a
forall a. Fractional a => Pattern a
sine

-- | @cosine2@ - bipolar cosine wave. A pattern of continuous values
-- following a cosine with frequency of one cycle, and amplitude from
-- -1 to 1. Equivalent to @0.25 ~> sine2@.
cosine2 :: Fractional a => Pattern a
cosine2 :: forall a. Fractional a => Pattern a
cosine2 = Rational
0.25 Rational -> Pattern a -> Pattern a
forall a. Rational -> Pattern a -> Pattern a
`rotR` Pattern a
forall a. Fractional a => Pattern a
sine2

-- | @saw@ - unipolar ascending sawtooth wave. A pattern of continuous values
-- following a sawtooth with frequency of one cycle, and amplitude from
-- 0 to 1.
saw :: (Fractional a, Real a) => Pattern a
saw :: forall a. (Fractional a, Real a) => Pattern a
saw = (Rational -> a) -> Pattern a
forall a. (Rational -> a) -> Pattern a
sig ((Rational -> a) -> Pattern a) -> (Rational -> a) -> Pattern a
forall a b. (a -> b) -> a -> b
$ \Rational
t -> a -> a -> a
forall a. Real a => a -> a -> a
mod' (Rational -> a
forall a. Fractional a => Rational -> a
fromRational Rational
t) a
1

-- | @saw2@ - bipolar ascending sawtooth wave. A pattern of continuous values
-- following a sawtooth with frequency of one cycle, and amplitude from
-- -1 to 1.
saw2 :: (Fractional a, Real a) => Pattern a
saw2 :: forall a. (Fractional a, Real a) => Pattern a
saw2 = (Rational -> a) -> Pattern a
forall a. (Rational -> a) -> Pattern a
sig ((Rational -> a) -> Pattern a) -> (Rational -> a) -> Pattern a
forall a b. (a -> b) -> a -> b
$ \Rational
t -> a -> a -> a
forall a. Real a => a -> a -> a
mod' (Rational -> a
forall a. Fractional a => Rational -> a
fromRational Rational
t) a
1 a -> a -> a
forall a. Num a => a -> a -> a
* a
2 a -> a -> a
forall a. Num a => a -> a -> a
- a
1

-- | @isaw@ like @saw@, but a descending (inverse) sawtooth.
isaw :: (Fractional a, Real a) => Pattern a
isaw :: forall a. (Fractional a, Real a) => Pattern a
isaw = (a
1a -> a -> a
forall a. Num a => a -> a -> a
-) (a -> a) -> Pattern a -> Pattern a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a
forall a. (Fractional a, Real a) => Pattern a
saw

-- | @isaw2@ like @saw2@, but a descending (inverse) sawtooth.
isaw2 :: (Fractional a, Real a) => Pattern a
isaw2 :: forall a. (Fractional a, Real a) => Pattern a
isaw2 = (a -> a -> a
forall a. Num a => a -> a -> a
*(-a
1)) (a -> a) -> Pattern a -> Pattern a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a
forall a. (Fractional a, Real a) => Pattern a
saw2

-- | @tri@ - unipolar triangle wave. A pattern of continuous values
-- following a triangle wave with frequency of one cycle, and amplitude from
-- 0 to 1.
tri :: (Fractional a, Real a) => Pattern a
tri :: forall a. (Fractional a, Real a) => Pattern a
tri = Pattern a -> Pattern a -> Pattern a
forall a. Pattern a -> Pattern a -> Pattern a
fastAppend Pattern a
forall a. (Fractional a, Real a) => Pattern a
saw Pattern a
forall a. (Fractional a, Real a) => Pattern a
isaw

-- | @tri2@ - bipolar triangle wave. A pattern of continuous values
-- following a triangle wave with frequency of one cycle, and amplitude from
-- -1 to 1.
tri2 :: (Fractional a, Real a) => Pattern a
tri2 :: forall a. (Fractional a, Real a) => Pattern a
tri2 = Pattern a -> Pattern a -> Pattern a
forall a. Pattern a -> Pattern a -> Pattern a
fastAppend Pattern a
forall a. (Fractional a, Real a) => Pattern a
saw2 Pattern a
forall a. (Fractional a, Real a) => Pattern a
isaw2

-- | @square@ - unipolar square wave. A pattern of continuous values
-- following a square wave with frequency of one cycle, and amplitude from
-- 0 to 1.
-- | @square@ is like 'sine', for square waves.
square :: (Fractional a) => Pattern a
square :: forall a. Fractional a => Pattern a
square = (Rational -> a) -> Pattern a
forall a. (Rational -> a) -> Pattern a
sig ((Rational -> a) -> Pattern a) -> (Rational -> a) -> Pattern a
forall a b. (a -> b) -> a -> b
$
       \Rational
t -> Integer -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral ((Double -> Integer
forall b. Integral b => Double -> b
forall a b. (RealFrac a, Integral b) => a -> b
floor (Double -> Integer) -> Double -> Integer
forall a b. (a -> b) -> a -> b
$ Double -> Double -> Double
forall a. Real a => a -> a -> a
mod' (Rational -> Double
forall a. Fractional a => Rational -> a
fromRational Rational
t :: Double) Double
1 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
2) :: Integer)

-- | @square2@ - bipolar square wave. A pattern of continuous values
-- following a square wave with frequency of one cycle, and amplitude from
-- -1 to 1.
square2 :: (Fractional a) => Pattern a
square2 :: forall a. Fractional a => Pattern a
square2 = (Rational -> a) -> Pattern a
forall a. (Rational -> a) -> Pattern a
sig ((Rational -> a) -> Pattern a) -> (Rational -> a) -> Pattern a
forall a b. (a -> b) -> a -> b
$
       \Rational
t -> Integer -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Double -> Integer
forall b. Integral b => Double -> b
forall a b. (RealFrac a, Integral b) => a -> b
floor (Double -> Double -> Double
forall a. Real a => a -> a -> a
mod' (Rational -> Double
forall a. Fractional a => Rational -> a
fromRational Rational
t :: Double) Double
1 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
2) Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Integer
2 Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- Integer
1 :: Integer)

-- | @envL@ is a 'Pattern' of continuous 'Double' values, representing
-- a linear interpolation between 0 and 1 during the first cycle, then
-- staying constant at 1 for all following cycles. Possibly only
-- useful if you're using something like the retrig function defined
-- in tidal.el.
envL :: Pattern Double
envL :: Pattern Double
envL = (Rational -> Double) -> Pattern Double
forall a. (Rational -> a) -> Pattern a
sig ((Rational -> Double) -> Pattern Double)
-> (Rational -> Double) -> Pattern Double
forall a b. (a -> b) -> a -> b
$ \Rational
t -> Double -> Double -> Double
forall a. Ord a => a -> a -> a
max Double
0 (Double -> Double) -> Double -> Double
forall a b. (a -> b) -> a -> b
$ Double -> Double -> Double
forall a. Ord a => a -> a -> a
min (Rational -> Double
forall a. Fractional a => Rational -> a
fromRational Rational
t) Double
1

-- | like 'envL' but reversed.
envLR :: Pattern Double
envLR :: Pattern Double
envLR = (Double
1Double -> Double -> Double
forall a. Num a => a -> a -> a
-) (Double -> Double) -> Pattern Double -> Pattern Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern Double
envL

-- | 'Equal power' version of 'env', for gain-based transitions
envEq :: Pattern Double
envEq :: Pattern Double
envEq = (Rational -> Double) -> Pattern Double
forall a. (Rational -> a) -> Pattern a
sig ((Rational -> Double) -> Pattern Double)
-> (Rational -> Double) -> Pattern Double
forall a b. (a -> b) -> a -> b
$ \Rational
t -> Double -> Double
forall a. Floating a => a -> a
sqrt (Double -> Double
forall a. Floating a => a -> a
sin (Double
forall a. Floating a => a
piDouble -> Double -> Double
forall a. Fractional a => a -> a -> a
/Double
2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double -> Double
forall a. Ord a => a -> a -> a
max Double
0 (Double -> Double -> Double
forall a. Ord a => a -> a -> a
min (Rational -> Double
forall a. Fractional a => Rational -> a
fromRational (Rational
1Rational -> Rational -> Rational
forall a. Num a => a -> a -> a
-Rational
t)) Double
1)))

-- | Equal power reversed
envEqR :: Pattern Double
envEqR :: Pattern Double
envEqR = (Rational -> Double) -> Pattern Double
forall a. (Rational -> a) -> Pattern a
sig ((Rational -> Double) -> Pattern Double)
-> (Rational -> Double) -> Pattern Double
forall a b. (a -> b) -> a -> b
$ \Rational
t -> Double -> Double
forall a. Floating a => a -> a
sqrt (Double -> Double
forall a. Floating a => a -> a
cos (Double
forall a. Floating a => a
piDouble -> Double -> Double
forall a. Fractional a => a -> a -> a
/Double
2 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double -> Double
forall a. Ord a => a -> a -> a
max Double
0 (Double -> Double -> Double
forall a. Ord a => a -> a -> a
min (Rational -> Double
forall a. Fractional a => Rational -> a
fromRational (Rational
1Rational -> Rational -> Rational
forall a. Num a => a -> a -> a
-Rational
t)) Double
1)))

-- ** Pattern algebra

-- class for types that support a left-biased union
class Unionable a where
  union :: a -> a -> a

-- default union is just to take the left hand side..
instance Unionable a where
  union :: a -> a -> a
union = a -> a -> a
forall a b. a -> b -> a
const

instance {-# OVERLAPPING #-} Unionable ValueMap where
  union :: ValueMap -> ValueMap -> ValueMap
union = ValueMap -> ValueMap -> ValueMap
forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union

(|+|) :: (Applicative a, Num b) => a b -> a b -> a b
a b
a |+| :: forall (a :: * -> *) b. (Applicative a, Num b) => a b -> a b -> a b
|+| a b
b = b -> b -> b
forall a. Num a => a -> a -> a
(+) (b -> b -> b) -> a b -> a (b -> b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a b
a a (b -> b) -> a b -> a b
forall a b. a (a -> b) -> a a -> a b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a b
b
(|+ ) :: Num a => Pattern a -> Pattern a -> Pattern a
Pattern a
a |+ :: forall a. Num a => Pattern a -> Pattern a -> Pattern a
|+  Pattern a
b = a -> a -> a
forall a. Num a => a -> a -> a
(+) (a -> a -> a) -> Pattern a -> Pattern (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a
a Pattern (a -> a) -> Pattern a -> Pattern a
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
<* Pattern a
b
( +|) :: Num a => Pattern a -> Pattern a -> Pattern a
Pattern a
a  +| :: forall a. Num a => Pattern a -> Pattern a -> Pattern a
+| Pattern a
b = a -> a -> a
forall a. Num a => a -> a -> a
(+) (a -> a -> a) -> Pattern a -> Pattern (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a
a Pattern (a -> a) -> Pattern a -> Pattern a
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
*> Pattern a
b
(||+) :: Num a => Pattern a -> Pattern a -> Pattern a
Pattern a
a ||+ :: forall a. Num a => Pattern a -> Pattern a -> Pattern a
||+ Pattern a
b = a -> a -> a
forall a. Num a => a -> a -> a
(+) (a -> a -> a) -> Pattern a -> Pattern (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a
a Pattern (a -> a) -> Pattern a -> Pattern a
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
<<* Pattern a
b


(|++|) :: Applicative a => a String -> a String -> a String
a String
a |++| :: forall (a :: * -> *).
Applicative a =>
a String -> a String -> a String
|++| a String
b = String -> String -> String
forall a. [a] -> [a] -> [a]
(++) (String -> String -> String) -> a String -> a (String -> String)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a String
a a (String -> String) -> a String -> a String
forall a b. a (a -> b) -> a a -> a b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a String
b
(|++ ) :: Pattern String -> Pattern String -> Pattern String
Pattern String
a |++ :: Pattern String -> Pattern String -> Pattern String
|++  Pattern String
b = String -> String -> String
forall a. [a] -> [a] -> [a]
(++) (String -> String -> String)
-> Pattern String -> Pattern (String -> String)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern String
a Pattern (String -> String) -> Pattern String -> Pattern String
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
<* Pattern String
b
( ++|) :: Pattern String -> Pattern String -> Pattern String
Pattern String
a  ++| :: Pattern String -> Pattern String -> Pattern String
++| Pattern String
b = String -> String -> String
forall a. [a] -> [a] -> [a]
(++) (String -> String -> String)
-> Pattern String -> Pattern (String -> String)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern String
a Pattern (String -> String) -> Pattern String -> Pattern String
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
*> Pattern String
b
(||++) :: Pattern String -> Pattern String -> Pattern String
Pattern String
a ||++ :: Pattern String -> Pattern String -> Pattern String
||++ Pattern String
b = String -> String -> String
forall a. [a] -> [a] -> [a]
(++) (String -> String -> String)
-> Pattern String -> Pattern (String -> String)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern String
a Pattern (String -> String) -> Pattern String -> Pattern String
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
<<* Pattern String
b

(|/|) :: (Applicative a, Fractional b) => a b -> a b -> a b
a b
a |/| :: forall (a :: * -> *) b.
(Applicative a, Fractional b) =>
a b -> a b -> a b
|/| a b
b = b -> b -> b
forall a. Fractional a => a -> a -> a
(/) (b -> b -> b) -> a b -> a (b -> b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a b
a a (b -> b) -> a b -> a b
forall a b. a (a -> b) -> a a -> a b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a b
b
(|/ ) :: Fractional a => Pattern a -> Pattern a -> Pattern a
Pattern a
a |/ :: forall a. Fractional a => Pattern a -> Pattern a -> Pattern a
|/  Pattern a
b = a -> a -> a
forall a. Fractional a => a -> a -> a
(/) (a -> a -> a) -> Pattern a -> Pattern (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a
a Pattern (a -> a) -> Pattern a -> Pattern a
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
<* Pattern a
b
( /|) :: Fractional a => Pattern a -> Pattern a -> Pattern a
Pattern a
a  /| :: forall a. Fractional a => Pattern a -> Pattern a -> Pattern a
/| Pattern a
b = a -> a -> a
forall a. Fractional a => a -> a -> a
(/) (a -> a -> a) -> Pattern a -> Pattern (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a
a Pattern (a -> a) -> Pattern a -> Pattern a
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
*> Pattern a
b
(||/) :: Fractional a => Pattern a -> Pattern a -> Pattern a
Pattern a
a ||/ :: forall a. Fractional a => Pattern a -> Pattern a -> Pattern a
||/ Pattern a
b = a -> a -> a
forall a. Fractional a => a -> a -> a
(/) (a -> a -> a) -> Pattern a -> Pattern (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a
a Pattern (a -> a) -> Pattern a -> Pattern a
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
<<* Pattern a
b

(|*|) :: (Applicative a, Num b) => a b -> a b -> a b
a b
a |*| :: forall (a :: * -> *) b. (Applicative a, Num b) => a b -> a b -> a b
|*| a b
b = b -> b -> b
forall a. Num a => a -> a -> a
(*) (b -> b -> b) -> a b -> a (b -> b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a b
a a (b -> b) -> a b -> a b
forall a b. a (a -> b) -> a a -> a b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a b
b
(|* ) :: Num a => Pattern a -> Pattern a -> Pattern a
Pattern a
a |* :: forall a. Num a => Pattern a -> Pattern a -> Pattern a
|*  Pattern a
b = a -> a -> a
forall a. Num a => a -> a -> a
(*) (a -> a -> a) -> Pattern a -> Pattern (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a
a Pattern (a -> a) -> Pattern a -> Pattern a
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
<* Pattern a
b
( *|) :: Num a => Pattern a -> Pattern a -> Pattern a
Pattern a
a  *| :: forall a. Num a => Pattern a -> Pattern a -> Pattern a
*| Pattern a
b = a -> a -> a
forall a. Num a => a -> a -> a
(*) (a -> a -> a) -> Pattern a -> Pattern (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a
a Pattern (a -> a) -> Pattern a -> Pattern a
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
*> Pattern a
b
(||*) :: Num a => Pattern a -> Pattern a -> Pattern a
Pattern a
a ||* :: forall a. Num a => Pattern a -> Pattern a -> Pattern a
||* Pattern a
b = a -> a -> a
forall a. Num a => a -> a -> a
(*) (a -> a -> a) -> Pattern a -> Pattern (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a
a Pattern (a -> a) -> Pattern a -> Pattern a
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
<<* Pattern a
b

(|-|) :: (Applicative a, Num b) => a b -> a b -> a b
a b
a |-| :: forall (a :: * -> *) b. (Applicative a, Num b) => a b -> a b -> a b
|-| a b
b = (-) (b -> b -> b) -> a b -> a (b -> b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a b
a a (b -> b) -> a b -> a b
forall a b. a (a -> b) -> a a -> a b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a b
b
(|- ) :: Num a => Pattern a -> Pattern a -> Pattern a
Pattern a
a |- :: forall a. Num a => Pattern a -> Pattern a -> Pattern a
|-  Pattern a
b = (-) (a -> a -> a) -> Pattern a -> Pattern (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a
a Pattern (a -> a) -> Pattern a -> Pattern a
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
<* Pattern a
b
( -|) :: Num a => Pattern a -> Pattern a -> Pattern a
Pattern a
a  -| :: forall a. Num a => Pattern a -> Pattern a -> Pattern a
-| Pattern a
b = (-) (a -> a -> a) -> Pattern a -> Pattern (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a
a Pattern (a -> a) -> Pattern a -> Pattern a
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
*> Pattern a
b
(||-) :: Num a => Pattern a -> Pattern a -> Pattern a
Pattern a
a ||- :: forall a. Num a => Pattern a -> Pattern a -> Pattern a
||- Pattern a
b = (-) (a -> a -> a) -> Pattern a -> Pattern (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a
a Pattern (a -> a) -> Pattern a -> Pattern a
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
<<* Pattern a
b

(|%|) :: (Applicative a, Moddable b) => a b -> a b -> a b
a b
a |%| :: forall (a :: * -> *) b.
(Applicative a, Moddable b) =>
a b -> a b -> a b
|%| a b
b = b -> b -> b
forall a. Moddable a => a -> a -> a
gmod (b -> b -> b) -> a b -> a (b -> b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a b
a a (b -> b) -> a b -> a b
forall a b. a (a -> b) -> a a -> a b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a b
b
(|% ) :: Moddable a => Pattern a -> Pattern a -> Pattern a
Pattern a
a |% :: forall a. Moddable a => Pattern a -> Pattern a -> Pattern a
|%  Pattern a
b = a -> a -> a
forall a. Moddable a => a -> a -> a
gmod (a -> a -> a) -> Pattern a -> Pattern (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a
a Pattern (a -> a) -> Pattern a -> Pattern a
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
<* Pattern a
b
( %|) :: Moddable a => Pattern a -> Pattern a -> Pattern a
Pattern a
a  %| :: forall a. Moddable a => Pattern a -> Pattern a -> Pattern a
%| Pattern a
b = a -> a -> a
forall a. Moddable a => a -> a -> a
gmod (a -> a -> a) -> Pattern a -> Pattern (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a
a Pattern (a -> a) -> Pattern a -> Pattern a
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
*> Pattern a
b
(||%) :: Moddable a => Pattern a -> Pattern a -> Pattern a
Pattern a
a ||% :: forall a. Moddable a => Pattern a -> Pattern a -> Pattern a
||% Pattern a
b = a -> a -> a
forall a. Moddable a => a -> a -> a
gmod (a -> a -> a) -> Pattern a -> Pattern (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a
a Pattern (a -> a) -> Pattern a -> Pattern a
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
<<* Pattern a
b

(|**|) :: (Applicative a, Floating b) => a b -> a b -> a b
a b
a |**| :: forall (a :: * -> *) b.
(Applicative a, Floating b) =>
a b -> a b -> a b
|**| a b
b = b -> b -> b
forall a. Floating a => a -> a -> a
(**) (b -> b -> b) -> a b -> a (b -> b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a b
a a (b -> b) -> a b -> a b
forall a b. a (a -> b) -> a a -> a b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a b
b
(|** ) :: Floating a => Pattern a -> Pattern a -> Pattern a
Pattern a
a |** :: forall a. Floating a => Pattern a -> Pattern a -> Pattern a
|**  Pattern a
b = a -> a -> a
forall a. Floating a => a -> a -> a
(**) (a -> a -> a) -> Pattern a -> Pattern (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a
a Pattern (a -> a) -> Pattern a -> Pattern a
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
<* Pattern a
b
( **|) :: Floating a => Pattern a -> Pattern a -> Pattern a
Pattern a
a  **| :: forall a. Floating a => Pattern a -> Pattern a -> Pattern a
**| Pattern a
b = a -> a -> a
forall a. Floating a => a -> a -> a
(**) (a -> a -> a) -> Pattern a -> Pattern (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a
a Pattern (a -> a) -> Pattern a -> Pattern a
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
*> Pattern a
b
(||**) :: Floating a => Pattern a -> Pattern a -> Pattern a
Pattern a
a ||** :: forall a. Floating a => Pattern a -> Pattern a -> Pattern a
||** Pattern a
b = a -> a -> a
forall a. Floating a => a -> a -> a
(**) (a -> a -> a) -> Pattern a -> Pattern (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a
a Pattern (a -> a) -> Pattern a -> Pattern a
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
<<* Pattern a
b

(|>|) :: (Applicative a, Unionable b) => a b -> a b -> a b
a b
a |>| :: forall (a :: * -> *) b.
(Applicative a, Unionable b) =>
a b -> a b -> a b
|>| a b
b = (b -> b -> b) -> b -> b -> b
forall a b c. (a -> b -> c) -> b -> a -> c
flip b -> b -> b
forall a. Unionable a => a -> a -> a
union (b -> b -> b) -> a b -> a (b -> b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a b
a a (b -> b) -> a b -> a b
forall a b. a (a -> b) -> a a -> a b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a b
b
(|> ) :: Unionable a => Pattern a -> Pattern a -> Pattern a
Pattern a
a |> :: forall a. Unionable a => Pattern a -> Pattern a -> Pattern a
|>  Pattern a
b = (a -> a -> a) -> a -> a -> a
forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> a -> a
forall a. Unionable a => a -> a -> a
union (a -> a -> a) -> Pattern a -> Pattern (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a
a Pattern (a -> a) -> Pattern a -> Pattern a
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
<* Pattern a
b
( >|) :: Unionable a => Pattern a -> Pattern a -> Pattern a
Pattern a
a  >| :: forall a. Unionable a => Pattern a -> Pattern a -> Pattern a
>| Pattern a
b = (a -> a -> a) -> a -> a -> a
forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> a -> a
forall a. Unionable a => a -> a -> a
union (a -> a -> a) -> Pattern a -> Pattern (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a
a Pattern (a -> a) -> Pattern a -> Pattern a
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
*> Pattern a
b
(||>) :: Unionable a => Pattern a -> Pattern a -> Pattern a
Pattern a
a ||> :: forall a. Unionable a => Pattern a -> Pattern a -> Pattern a
||> Pattern a
b = (a -> a -> a) -> a -> a -> a
forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> a -> a
forall a. Unionable a => a -> a -> a
union (a -> a -> a) -> Pattern a -> Pattern (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a
a Pattern (a -> a) -> Pattern a -> Pattern a
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
<<* Pattern a
b

(|<|) :: (Applicative a, Unionable b) => a b -> a b -> a b
a b
a |<| :: forall (a :: * -> *) b.
(Applicative a, Unionable b) =>
a b -> a b -> a b
|<| a b
b = b -> b -> b
forall a. Unionable a => a -> a -> a
union (b -> b -> b) -> a b -> a (b -> b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a b
a a (b -> b) -> a b -> a b
forall a b. a (a -> b) -> a a -> a b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> a b
b
(|< ) :: Unionable a => Pattern a -> Pattern a -> Pattern a
Pattern a
a |< :: forall a. Unionable a => Pattern a -> Pattern a -> Pattern a
|<  Pattern a
b = a -> a -> a
forall a. Unionable a => a -> a -> a
union (a -> a -> a) -> Pattern a -> Pattern (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a
a Pattern (a -> a) -> Pattern a -> Pattern a
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
<* Pattern a
b
( <|) :: Unionable a => Pattern a -> Pattern a -> Pattern a
Pattern a
a  <| :: forall a. Unionable a => Pattern a -> Pattern a -> Pattern a
<| Pattern a
b = a -> a -> a
forall a. Unionable a => a -> a -> a
union (a -> a -> a) -> Pattern a -> Pattern (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a
a Pattern (a -> a) -> Pattern a -> Pattern a
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
*> Pattern a
b
(||<) :: Unionable a => Pattern a -> Pattern a -> Pattern a
Pattern a
a ||< :: forall a. Unionable a => Pattern a -> Pattern a -> Pattern a
||< Pattern a
b = a -> a -> a
forall a. Unionable a => a -> a -> a
union (a -> a -> a) -> Pattern a -> Pattern (a -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern a
a Pattern (a -> a) -> Pattern a -> Pattern a
forall a b. Pattern (a -> b) -> Pattern a -> Pattern b
<<* Pattern a
b

-- Backward compatibility - structure from left, values from right.
(#) :: Unionable b => Pattern b -> Pattern b -> Pattern b
# :: forall a. Unionable a => Pattern a -> Pattern a -> Pattern a
(#) = Pattern b -> Pattern b -> Pattern b
forall a. Unionable a => Pattern a -> Pattern a -> Pattern a
(|>)



-- ** Constructing patterns

{-| Turns a list of values into a pattern, playing one of them per cycle.
  The following are equivalent:

  > d1 $ n (fromList [0, 1, 2]) # s "superpiano"
  > d1 $ n "<0 1 2>" # s "superpiano"
-}
fromList :: [a] -> Pattern a
fromList :: forall a. [a] -> Pattern a
fromList = [Pattern a] -> Pattern a
forall a. [Pattern a] -> Pattern a
cat ([Pattern a] -> Pattern a)
-> ([a] -> [Pattern a]) -> [a] -> Pattern a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Pattern a) -> [a] -> [Pattern a]
forall a b. (a -> b) -> [a] -> [b]
map a -> Pattern a
forall a. a -> Pattern a
forall (f :: * -> *) a. Applicative f => a -> f a
pure

{-| Turns a list of values into a pattern, playing /all/ of them per cycle.
  The following are equivalent:

  > d1 $ n (fastFromList [0, 1, 2]) # s "superpiano"
  > d1 $ n "[0 1 2]" # s "superpiano"
-}
fastFromList :: [a] -> Pattern a
fastFromList :: forall a. [a] -> Pattern a
fastFromList = [Pattern a] -> Pattern a
forall a. [Pattern a] -> Pattern a
fastcat ([Pattern a] -> Pattern a)
-> ([a] -> [Pattern a]) -> [a] -> Pattern a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Pattern a) -> [a] -> [Pattern a]
forall a b. (a -> b) -> [a] -> [b]
map a -> Pattern a
forall a. a -> Pattern a
forall (f :: * -> *) a. Applicative f => a -> f a
pure

-- | A synonym for 'fastFromList'
listToPat :: [a] -> Pattern a
listToPat :: forall a. [a] -> Pattern a
listToPat = [a] -> Pattern a
forall a. [a] -> Pattern a
fastFromList

-- | 'fromMaybes; is similar to 'fromList', but allows values to
-- be optional using the 'Maybe' type, so that 'Nothing' results in
-- gaps in the pattern.
-- The following are equivalent:
-- > d1 $ n (fromMaybes [Just 0, Nothing, Just 2]) # s "superpiano"
-- > d1 $ n "0 ~ 2" # s "superpiano"
fromMaybes :: [Maybe a] -> Pattern a
fromMaybes :: forall a. [Maybe a] -> Pattern a
fromMaybes = [Pattern a] -> Pattern a
forall a. [Pattern a] -> Pattern a
fastcat ([Pattern a] -> Pattern a)
-> ([Maybe a] -> [Pattern a]) -> [Maybe a] -> Pattern a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe a -> Pattern a) -> [Maybe a] -> [Pattern a]
forall a b. (a -> b) -> [a] -> [b]
map Maybe a -> Pattern a
forall {a}. Maybe a -> Pattern a
f
  where f :: Maybe a -> Pattern a
f Maybe a
Nothing = Pattern a
forall a. Pattern a
silence
        f (Just a
x) = a -> Pattern a
forall a. a -> Pattern a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
x

{-| A pattern of whole numbers from 0 to the given number, in a single cycle.
  Can be used used to @run@ through a folder of samples in order:

  > d1 $ n (run 8) # sound "amencutup"

  The first parameter to run can be given as a pattern:

  > d1 $ n (run "<4 8 4 6>") # sound "amencutup"
-}
run :: (Enum a, Num a) => Pattern a -> Pattern a
run :: forall a. (Enum a, Num a) => Pattern a -> Pattern a
run = (Pattern a -> (a -> Pattern a) -> Pattern a
forall a b. Pattern a -> (a -> Pattern b) -> Pattern b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Pattern a
forall a. (Enum a, Num a) => a -> Pattern a
_run)

_run :: (Enum a, Num a) => a -> Pattern a
_run :: forall a. (Enum a, Num a) => a -> Pattern a
_run a
n = [a] -> Pattern a
forall a. [a] -> Pattern a
fastFromList [a
0 .. a
na -> a -> a
forall a. Num a => a -> a -> a
-a
1]

-- | Similar to 'run', but starts from @1@ for the first cycle, successively
-- adds a number until it gets up to @n@.
-- > d1 $ n (scan 8) # sound "amencutup"
scan :: (Enum a, Num a) => Pattern a -> Pattern a
scan :: forall a. (Enum a, Num a) => Pattern a -> Pattern a
scan = (Pattern a -> (a -> Pattern a) -> Pattern a
forall a b. Pattern a -> (a -> Pattern b) -> Pattern b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Pattern a
forall a. (Enum a, Num a) => a -> Pattern a
_scan)

_scan :: (Enum a, Num a) => a -> Pattern a
_scan :: forall a. (Enum a, Num a) => a -> Pattern a
_scan a
n = [Pattern a] -> Pattern a
forall a. [Pattern a] -> Pattern a
slowcat ([Pattern a] -> Pattern a) -> [Pattern a] -> Pattern a
forall a b. (a -> b) -> a -> b
$ (a -> Pattern a) -> [a] -> [Pattern a]
forall a b. (a -> b) -> [a] -> [b]
map a -> Pattern a
forall a. (Enum a, Num a) => a -> Pattern a
_run [a
1 .. a
n]

-- ** Combining patterns

-- | Alternate between cycles of the two given patterns
-- > d1 $ append (sound "bd*2 sn") (sound "arpy jvbass*2")
append :: Pattern a -> Pattern a -> Pattern a
append :: forall a. Pattern a -> Pattern a -> Pattern a
append Pattern a
a Pattern a
b = [Pattern a] -> Pattern a
forall a. [Pattern a] -> Pattern a
cat [Pattern a
a,Pattern a
b]

{- |
  Like 'append', but for a list of patterns. Interlaces them, playing the
  first cycle from each in turn, then the second cycle from each, and so on. It
  concatenates a list of patterns into a new pattern; each pattern in the list
  will maintain its original duration. For example:

  > d1 $ cat [sound "bd*2 sn", sound "arpy jvbass*2"]
  > d1 $ cat [sound "bd*2 sn", sound "arpy jvbass*2", sound "drum*2"]
  > d1 $ cat [sound "bd*2 sn", sound "jvbass*3", sound "drum*2", sound "ht mt"]
-}
cat :: [Pattern a] -> Pattern a
cat :: forall a. [Pattern a] -> Pattern a
cat [] = Pattern a
forall a. Pattern a
silence
cat [Pattern a]
ps = (State -> [Event a]) -> Pattern a
forall a. (State -> [Event a]) -> Pattern a
Pattern State -> [Event a]
q
  where n :: Int
n = [Pattern a] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Pattern a]
ps
        q :: State -> [Event a]
q State
st = (ArcF Rational -> [Event a]) -> [ArcF Rational] -> [Event a]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (State -> ArcF Rational -> [Event a]
f State
st) ([ArcF Rational] -> [Event a]) -> [ArcF Rational] -> [Event a]
forall a b. (a -> b) -> a -> b
$ ArcF Rational -> [ArcF Rational]
arcCyclesZW (State -> ArcF Rational
arc State
st)
        f :: State -> ArcF Rational -> [Event a]
f State
st ArcF Rational
a = Pattern a -> State -> [Event a]
forall a. Pattern a -> State -> [Event a]
query ((Rational -> Rational) -> Pattern a -> Pattern a
forall a. (Rational -> Rational) -> Pattern a -> Pattern a
withResultTime (Rational -> Rational -> Rational
forall a. Num a => a -> a -> a
+Rational
offset) Pattern a
p) (State -> [Event a]) -> State -> [Event a]
forall a b. (a -> b) -> a -> b
$ State
st {arc = Arc (subtract offset (start a)) (subtract offset (stop a))}
          where p :: Pattern a
p = [Pattern a]
ps [Pattern a] -> Int -> Pattern a
forall a. HasCallStack => [a] -> Int -> a
!! Int
i
                cyc :: Int
cyc = (Rational -> Int
forall b. Integral b => Rational -> b
forall a b. (RealFrac a, Integral b) => a -> b
floor (Rational -> Int) -> Rational -> Int
forall a b. (a -> b) -> a -> b
$ ArcF Rational -> Rational
forall a. ArcF a -> a
start ArcF Rational
a) :: Int
                i :: Int
i = Int
cyc Int -> Int -> Int
forall a. Integral a => a -> a -> a
`mod` Int
n
                offset :: Rational
offset = (Int -> Rational
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Rational) -> Int -> Rational
forall a b. (a -> b) -> a -> b
$ Int
cyc Int -> Int -> Int
forall a. Num a => a -> a -> a
- ((Int
cyc Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
i) Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
n)) :: Time

-- | Alias for 'cat'
slowCat :: [Pattern a] -> Pattern a
slowCat :: forall a. [Pattern a] -> Pattern a
slowCat = [Pattern a] -> Pattern a
forall a. [Pattern a] -> Pattern a
cat
slowcat :: [Pattern a] -> Pattern a
slowcat :: forall a. [Pattern a] -> Pattern a
slowcat = [Pattern a] -> Pattern a
forall a. [Pattern a] -> Pattern a
slowCat

-- | Alias for 'append'
slowAppend :: Pattern a -> Pattern a -> Pattern a
slowAppend :: forall a. Pattern a -> Pattern a -> Pattern a
slowAppend = Pattern a -> Pattern a -> Pattern a
forall a. Pattern a -> Pattern a -> Pattern a
append
slowappend :: Pattern a -> Pattern a -> Pattern a
slowappend :: forall a. Pattern a -> Pattern a -> Pattern a
slowappend = Pattern a -> Pattern a -> Pattern a
forall a. Pattern a -> Pattern a -> Pattern a
append

-- | Like 'append', but twice as fast
-- > d1 $ fastAppend (sound "bd*2 sn") (sound "arpy jvbass*2")
fastAppend :: Pattern a -> Pattern a -> Pattern a
fastAppend :: forall a. Pattern a -> Pattern a -> Pattern a
fastAppend Pattern a
a Pattern a
b = Rational -> Pattern a -> Pattern a
forall a. Rational -> Pattern a -> Pattern a
_fast Rational
2 (Pattern a -> Pattern a) -> Pattern a -> Pattern a
forall a b. (a -> b) -> a -> b
$ Pattern a -> Pattern a -> Pattern a
forall a. Pattern a -> Pattern a -> Pattern a
append Pattern a
a Pattern a
b
fastappend :: Pattern a -> Pattern a -> Pattern a
fastappend :: forall a. Pattern a -> Pattern a -> Pattern a
fastappend = Pattern a -> Pattern a -> Pattern a
forall a. Pattern a -> Pattern a -> Pattern a
fastAppend

{-| The same as 'cat', but speeds up the result by the number of
  patterns there are, so the cycles from each are squashed to fit a
  single cycle.

  > d1 $ fastcat [sound "bd*2 sn", sound "arpy jvbass*2"]
  > d1 $ fastcat [sound "bd*2 sn", sound "arpy jvbass*2", sound "drum*2"]
  > d1 $ fastcat [sound "bd*2 sn", sound "jvbass*3", sound "drum*2", sound "ht mt"]
-}
fastCat :: [Pattern a] -> Pattern a
fastCat :: forall a. [Pattern a] -> Pattern a
fastCat [Pattern a]
ps = Rational -> Pattern a -> Pattern a
forall a. Rational -> Pattern a -> Pattern a
_fast (Int -> Rational
forall a. Real a => a -> Rational
toTime (Int -> Rational) -> Int -> Rational
forall a b. (a -> b) -> a -> b
$ [Pattern a] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Pattern a]
ps) (Pattern a -> Pattern a) -> Pattern a -> Pattern a
forall a b. (a -> b) -> a -> b
$ [Pattern a] -> Pattern a
forall a. [Pattern a] -> Pattern a
cat [Pattern a]
ps

-- | Alias for @fastCat@
fastcat :: [Pattern a] -> Pattern a
fastcat :: forall a. [Pattern a] -> Pattern a
fastcat = [Pattern a] -> Pattern a
forall a. [Pattern a] -> Pattern a
fastCat

{- | Similar to @fastCat@, but each pattern is given a relative duration.
  You provide proportionate sizes of the patterns to each other for when they’re
  concatenated into one cycle. The larger the value in the list, the larger
  relative size the pattern takes in the final loop. If all values are equal
  then this is equivalent to fastcat (e.g. the following two code fragments are
  equivalent).

  > d1 $ fastcat [s "bd*4", s "hh27*8", s "superpiano" # n 0]

  > d1 $ timeCat [ (1, s "bd*4")
  >              , (1, s "hh27*8")
  >              , (1, s "superpiano" # n 0)
  >              ]

-}
timeCat :: [(Time, Pattern a)] -> Pattern a
timeCat :: forall a. [(Rational, Pattern a)] -> Pattern a
timeCat [(Rational, Pattern a)]
tps = [Pattern a] -> Pattern a
forall a. [Pattern a] -> Pattern a
stack ([Pattern a] -> Pattern a) -> [Pattern a] -> Pattern a
forall a b. (a -> b) -> a -> b
$ ((Rational, Rational, Pattern a) -> Pattern a)
-> [(Rational, Rational, Pattern a)] -> [Pattern a]
forall a b. (a -> b) -> [a] -> [b]
map (\(Rational
s,Rational
e,Pattern a
p) -> ArcF Rational -> Pattern a -> Pattern a
forall a. ArcF Rational -> Pattern a -> Pattern a
compressArc (Rational -> Rational -> ArcF Rational
forall a. a -> a -> ArcF a
Arc (Rational
sRational -> Rational -> Rational
forall a. Fractional a => a -> a -> a
/Rational
total) (Rational
eRational -> Rational -> Rational
forall a. Fractional a => a -> a -> a
/Rational
total)) Pattern a
p) ([(Rational, Rational, Pattern a)] -> [Pattern a])
-> [(Rational, Rational, Pattern a)] -> [Pattern a]
forall a b. (a -> b) -> a -> b
$ Rational
-> [(Rational, Pattern a)] -> [(Rational, Rational, Pattern a)]
forall a.
Rational
-> [(Rational, Pattern a)] -> [(Rational, Rational, Pattern a)]
arrange Rational
0 [(Rational, Pattern a)]
tps
    where total :: Rational
total = [Rational] -> Rational
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Rational] -> Rational) -> [Rational] -> Rational
forall a b. (a -> b) -> a -> b
$ ((Rational, Pattern a) -> Rational)
-> [(Rational, Pattern a)] -> [Rational]
forall a b. (a -> b) -> [a] -> [b]
map (Rational, Pattern a) -> Rational
forall a b. (a, b) -> a
fst [(Rational, Pattern a)]
tps
          arrange :: Time -> [(Time, Pattern a)] -> [(Time, Time, Pattern a)]
          arrange :: forall a.
Rational
-> [(Rational, Pattern a)] -> [(Rational, Rational, Pattern a)]
arrange Rational
_ [] = []
          arrange Rational
t ((Rational
t',Pattern a
p):[(Rational, Pattern a)]
tps') = (Rational
t,Rational
tRational -> Rational -> Rational
forall a. Num a => a -> a -> a
+Rational
t',Pattern a
p) (Rational, Rational, Pattern a)
-> [(Rational, Rational, Pattern a)]
-> [(Rational, Rational, Pattern a)]
forall a. a -> [a] -> [a]
: Rational
-> [(Rational, Pattern a)] -> [(Rational, Rational, Pattern a)]
forall a.
Rational
-> [(Rational, Pattern a)] -> [(Rational, Rational, Pattern a)]
arrange (Rational
tRational -> Rational -> Rational
forall a. Num a => a -> a -> a
+Rational
t') [(Rational, Pattern a)]
tps'

-- | Alias for @timeCat@
timecat :: [(Time, Pattern a)] -> Pattern a
timecat :: forall a. [(Rational, Pattern a)] -> Pattern a
timecat = [(Rational, Pattern a)] -> Pattern a
forall a. [(Rational, Pattern a)] -> Pattern a
timeCat

{- | @overlay@ combines two 'Pattern's into a new pattern, so that their events
are combined over time. For example, the following two lines are equivalent:

> d1 $ sound (overlay "bd sn:2" "cp*3")
> d1 $ sound "[bd sn:2, cp*3]"

@overlay@ is equal to '<>',

> (<>) :: Semigroup a => a -> a -> a

which can thus be used as an infix operator equivalent of 'overlay':

> d1 $ sound ("bd sn:2" <> "cp*3")
-}
overlay :: Pattern a -> Pattern a -> Pattern a
overlay :: forall a. Pattern a -> Pattern a -> Pattern a
overlay = Pattern a -> Pattern a -> Pattern a
forall a. Semigroup a => a -> a -> a
(<>)

{- | 'stack' combines a list of 'Pattern's into a new pattern, so that their
events are combined over time, i.e., all of the patterns in the list are played
simultaneously.

> d1 $ stack [
>  sound "bd bd*2",
>  sound "hh*2 [sn cp] cp future*4",
>  sound "arpy" +| n "0 .. 15"
> ]

This is particularly useful if you want to apply a function or synth control
pattern to multiple patterns at once:

> d1 $ whenmod 5 3 (striate 3) $ stack [
>  sound "bd bd*2",
>  sound "hh*2 [sn cp] cp future*4",
>  sound "arpy" +| n "0 .. 15"
> ] # speed "[[1 0.8], [1.5 2]*2]/3"
-}
stack :: [Pattern a] -> Pattern a
stack :: forall a. [Pattern a] -> Pattern a
stack = (Pattern a -> Pattern a -> Pattern a)
-> Pattern a -> [Pattern a] -> Pattern a
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Pattern a -> Pattern a -> Pattern a
forall a. Pattern a -> Pattern a -> Pattern a
overlay Pattern a
forall a. Pattern a
silence

-- ** Manipulating time

-- | Shifts a pattern back in time by the given amount, expressed in cycles
(<~) :: Pattern Time -> Pattern a -> Pattern a
<~ :: forall a. Pattern Rational -> Pattern a -> Pattern a
(<~) = (Rational -> Pattern a -> Pattern a)
-> Pattern Rational -> Pattern a -> Pattern a
forall t1 t2 a.
(t1 -> t2 -> Pattern a) -> Pattern t1 -> t2 -> Pattern a
tParam Rational -> Pattern a -> Pattern a
forall a. Rational -> Pattern a -> Pattern a
rotL

-- | Shifts a pattern forward in time by the given amount, expressed in cycles
(~>) :: Pattern Time -> Pattern a -> Pattern a
~> :: forall a. Pattern Rational -> Pattern a -> Pattern a
(~>) = (Rational -> Pattern a -> Pattern a)
-> Pattern Rational -> Pattern a -> Pattern a
forall t1 t2 a.
(t1 -> t2 -> Pattern a) -> Pattern t1 -> t2 -> Pattern a
tParam Rational -> Pattern a -> Pattern a
forall a. Rational -> Pattern a -> Pattern a
rotR

{-| Slow down a pattern by the factors in the given time pattern, "squeezing"
  the pattern to fit the slot given in the time pattern. It is the slow analogue
  to 'fastSqueeze'.

  If the time pattern only has a single value in a cycle, @slowSqueeze@ becomes equivalent to slow. These are equivalent:

  > d1 $ slow "<2 4>" $ s "bd*8"
  > d1 $ slowSqueeze "<2 4>" $ s "bd*8"

  When the time pattern has multiple values, however, the behavior is a little
  different. Instead, a slowed version of the pattern will be made for each value
  in the time pattern, and they’re all combined together in a cycle according to
  the structure of the time pattern. For example, these are equivalent:

  > d1 $ slowSqueeze "2 4 8 16" $ s "bd*8"
  > d1 $ s "bd*4 bd*2 bd bd/2"

  as are these:

  > d1 $ slowSqueeze "2 4 [8 16]" $ s "bd*8"
  > d1 $ s "bd*4 bd*2 [bd bd/2]"
-}
slowSqueeze :: Pattern Time -> Pattern a -> Pattern a
slowSqueeze :: forall a. Pattern Rational -> Pattern a -> Pattern a
slowSqueeze = (Rational -> Pattern a -> Pattern a)
-> Pattern Rational -> Pattern a -> Pattern a
forall a b c.
(a -> Pattern b -> Pattern c)
-> Pattern a -> Pattern b -> Pattern c
tParamSqueeze Rational -> Pattern a -> Pattern a
forall a. Rational -> Pattern a -> Pattern a
_slow

-- | An alias for @slow@
sparsity :: Pattern Time -> Pattern a -> Pattern a
sparsity :: forall a. Pattern Rational -> Pattern a -> Pattern a
sparsity = Pattern Rational -> Pattern a -> Pattern a
forall a. Pattern Rational -> Pattern a -> Pattern a
slow

{- | Plays a portion of a pattern, specified by a time arc (start and end time).
  The new resulting pattern is played over the time period of the original pattern.

  > d1 $ zoom (0.25, 0.75) $ sound "bd*2 hh*3 [sn bd]*2 drum"

  In the pattern above, @zoom@ is used with an arc from 25% to 75%. It is
  equivalent to:

  > d1 $ sound "hh*3 [sn bd]*2"

  Here’s an example of it being used with a conditional:

  > d1 $ every 4 (zoom (0.25, 0.75)) $ sound "bd*2 hh*3 [sn bd]*2 drum"
-}
zoom :: (Time, Time) -> Pattern a -> Pattern a
zoom :: forall a. (Rational, Rational) -> Pattern a -> Pattern a
zoom (Rational
s,Rational
e) = ArcF Rational -> Pattern a -> Pattern a
forall a. ArcF Rational -> Pattern a -> Pattern a
zoomArc (Rational -> Rational -> ArcF Rational
forall a. a -> a -> ArcF a
Arc Rational
s Rational
e)

zoomArc :: Arc -> Pattern a -> Pattern a
zoomArc :: forall a. ArcF Rational -> Pattern a -> Pattern a
zoomArc (Arc Rational
s Rational
e) Pattern a
p = Pattern a -> Pattern a
forall a. Pattern a -> Pattern a
splitQueries (Pattern a -> Pattern a) -> Pattern a -> Pattern a
forall a b. (a -> b) -> a -> b
$
  (ArcF Rational -> ArcF Rational) -> Pattern a -> Pattern a
forall a.
(ArcF Rational -> ArcF Rational) -> Pattern a -> Pattern a
withResultArc ((Rational -> Rational) -> ArcF Rational -> ArcF Rational
mapCycle ((Rational -> Rational -> Rational
forall a. Fractional a => a -> a -> a
/Rational
d) (Rational -> Rational)
-> (Rational -> Rational) -> Rational -> Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rational -> Rational -> Rational
forall a. Num a => a -> a -> a
subtract Rational
s)) (Pattern a -> Pattern a) -> Pattern a -> Pattern a
forall a b. (a -> b) -> a -> b
$ (ArcF Rational -> ArcF Rational) -> Pattern a -> Pattern a
forall a.
(ArcF Rational -> ArcF Rational) -> Pattern a -> Pattern a
withQueryArc ((Rational -> Rational) -> ArcF Rational -> ArcF Rational
mapCycle ((Rational -> Rational -> Rational
forall a. Num a => a -> a -> a
+Rational
s) (Rational -> Rational)
-> (Rational -> Rational) -> Rational -> Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Rational -> Rational -> Rational
forall a. Num a => a -> a -> a
*Rational
d))) Pattern a
p
     where d :: Rational
d = Rational
eRational -> Rational -> Rational
forall a. Num a => a -> a -> a
-Rational
s

{-| @fastGap@ is similar to 'fast' but maintains its cyclic alignment, i.e.,
  rather than playing the pattern multiple times, it instead leaves a gap in
  the remaining space of the cycle. For example, @fastGap 2 p@ would squash the
  events in pattern @p@ into the first half of each cycle (and the second halves
  would be empty). The factor should be at least 1.
-}
fastGap :: Pattern Time -> Pattern a -> Pattern a
fastGap :: forall a. Pattern Rational -> Pattern a -> Pattern a
fastGap = (Rational -> Pattern a -> Pattern a)
-> Pattern Rational -> Pattern a -> Pattern a
forall t1 t2 a.
(t1 -> t2 -> Pattern a) -> Pattern t1 -> t2 -> Pattern a
tParam Rational -> Pattern a -> Pattern a
forall a. Rational -> Pattern a -> Pattern a
_fastGap

-- | An alias for @fastGap@
densityGap :: Pattern Time -> Pattern a -> Pattern a
densityGap :: forall a. Pattern Rational -> Pattern a -> Pattern a
densityGap = Pattern Rational -> Pattern a -> Pattern a
forall a. Pattern Rational -> Pattern a -> Pattern a
fastGap

{-|
  @compress@ takes a pattern and squeezes it within the specified time span (i.e.
  the ‘arc’). The new resulting pattern is a sped up version of the original.

  > d1 $ compress (1/4, 3/4) $ s "[bd sn]!"

  In the above example, the pattern will play in an arc spanning from 25% to 75%
  of the duration of a cycle. It is equivalent to:

  > d1 $ s "~ [bd sn]! ~"

  Another example, where all events are different:

  > d1 $ compress (1/4, 3/4) $ n (run 4) # s "arpy"

  It differs from 'zoom' in that it preserves the original pattern but it speeds
  up its events so to match with the new time period.
-}
compress :: (Time,Time) -> Pattern a -> Pattern a
compress :: forall a. (Rational, Rational) -> Pattern a -> Pattern a
compress (Rational
s,Rational
e) = ArcF Rational -> Pattern a -> Pattern a
forall a. ArcF Rational -> Pattern a -> Pattern a
compressArc (Rational -> Rational -> ArcF Rational
forall a. a -> a -> ArcF a
Arc Rational
s Rational
e)

compressTo :: (Time,Time) -> Pattern a -> Pattern a
compressTo :: forall a. (Rational, Rational) -> Pattern a -> Pattern a
compressTo (Rational
s,Rational
e) = ArcF Rational -> Pattern a -> Pattern a
forall a. ArcF Rational -> Pattern a -> Pattern a
compressArcTo (Rational -> Rational -> ArcF Rational
forall a. a -> a -> ArcF a
Arc Rational
s Rational
e)

repeatCycles :: Pattern Int -> Pattern a -> Pattern a
repeatCycles :: forall a. Pattern Int -> Pattern a -> Pattern a
repeatCycles = (Int -> Pattern a -> Pattern a)
-> Pattern Int -> Pattern a -> Pattern a
forall t1 t2 a.
(t1 -> t2 -> Pattern a) -> Pattern t1 -> t2 -> Pattern a
tParam Int -> Pattern a -> Pattern a
forall a. Int -> Pattern a -> Pattern a
_repeatCycles

_repeatCycles :: Int -> Pattern a -> Pattern a
_repeatCycles :: forall a. Int -> Pattern a -> Pattern a
_repeatCycles Int
n Pattern a
p = [Pattern a] -> Pattern a
forall a. [Pattern a] -> Pattern a
cat (Int -> Pattern a -> [Pattern a]
forall a. Int -> a -> [a]
replicate Int
n Pattern a
p)

fastRepeatCycles :: Int -> Pattern a -> Pattern a
fastRepeatCycles :: forall a. Int -> Pattern a -> Pattern a
fastRepeatCycles Int
n Pattern a
p = [Pattern a] -> Pattern a
forall a. [Pattern a] -> Pattern a
cat (Int -> Pattern a -> [Pattern a]
forall a. Int -> a -> [a]
replicate Int
n Pattern a
p)

-- | * Higher order functions

-- | Functions which work on other functions (higher order functions)

{- | @every n f p@ applies the function @f@ to @p@, but only affects
  every @n@ cycles.

  It takes three inputs: how often the function should be applied (e.g. 3 to
  apply it every 3 cycles), the function to be applied, and the pattern you are
  applying it to. For example: to reverse a pattern every three cycles (and for
  the other two play it normally)

  > d1 $ every 3 rev $ n "0 1 [~ 2] 3" # sound "arpy"

  Note that if the function you’re applying requires additional parameters
  itself (such as fast 2 to make a pattern twice as fast), then you’ll need to
  wrap it in parenthesis, like so:

  > d1 $ every 3 (fast 2) $ n "0 1 [~ 2] 3" # sound "arpy"

  Otherwise, the every function will think it is being passed too many parameters.
-}
every :: Pattern Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
every :: forall a.
Pattern Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
every Pattern Int
tp Pattern a -> Pattern a
f Pattern a
p = Pattern (Pattern a) -> Pattern a
forall a. Pattern (Pattern a) -> Pattern a
innerJoin (Pattern (Pattern a) -> Pattern a)
-> Pattern (Pattern a) -> Pattern a
forall a b. (a -> b) -> a -> b
$ (\Int
t -> Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
forall a. Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
_every Int
t Pattern a -> Pattern a
f Pattern a
p) (Int -> Pattern a) -> Pattern Int -> Pattern (Pattern a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern Int
tp

_every :: Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
_every :: forall a. Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
_every Int
0 Pattern a -> Pattern a
_ Pattern a
p = Pattern a
p
_every Int
n Pattern a -> Pattern a
f Pattern a
p = (Int -> Bool) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
forall a.
(Int -> Bool) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
when ((Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0) (Int -> Bool) -> (Int -> Int) -> Int -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Int -> Int
forall a. Integral a => a -> a -> a
`mod` Int
n)) Pattern a -> Pattern a
f Pattern a
p

{-| @every' n o f p@ is like @every n f p@ but with an offset of @o@ cycles.

  For example, @every' 3 0 (fast 2)@ will speed up the cycle on cycles 0,3,6,…
  whereas @every' 3 1 (fast 2)@ will transform the pattern on cycles 1,4,7,….

  With this in mind, setting the second argument of @every'@ to 0 gives the
  equivalent every function. For example, every 3 is equivalent to every' 3 0.

  The @every@ functions can be used to silence a full cycle or part of a cycle
  by using silent or mask "~". Mask provides additional flexibility to turn on/off
  individual steps.

  > d1 $ every 3 silent $ n "2 9 11 2" # s "hh27"
  > d1 $ every 3 (mask "~") $ n "2 9 10 2" # s "hh27"
  > d1 $ every 3 (mask "0 0 0 0") $ n "2 9 11 2" # s "hh27"
-}
every' :: Pattern Int -> Pattern Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
every' :: forall a.
Pattern Int
-> Pattern Int
-> (Pattern a -> Pattern a)
-> Pattern a
-> Pattern a
every' Pattern Int
np Pattern Int
op Pattern a -> Pattern a
f Pattern a
p = do { Int
n <- Pattern Int
np; Int
o <- Pattern Int
op; Int -> Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
forall a.
Int -> Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
_every' Int
n Int
o Pattern a -> Pattern a
f Pattern a
p }

_every' :: Int -> Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
_every' :: forall a.
Int -> Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
_every' Int
n Int
o = (Int -> Bool) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
forall a.
(Int -> Bool) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
when ((Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
o) (Int -> Bool) -> (Int -> Int) -> Int -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Int -> Int
forall a. Integral a => a -> a -> a
`mod` Int
n))

{- | @foldEvery ns f p@ applies the function @f@ to @p@, and is applied for
  each cycle in @ns@.

  It is similar to chaining multiple @every@ functions together. It transforms
  a pattern with a function, once per any of the given number of cycles. If a
  particular cycle is the start of more than one of the given cycle periods, then
  it it applied more than once.

  > d1 $ foldEvery [5,3] (|+ n 1) $ s "moog" # legato 1

  The first moog samples are tuned to C2, C3 and C4. Note how on cycles that are
  multiples of 3 or 5 the pitch is an octave higher, and on multiples of 15 the
  pitch is two octaves higher, as the transformation is applied twice.
-}
foldEvery :: [Int] -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
foldEvery :: forall a.
[Int] -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
foldEvery [Int]
ns Pattern a -> Pattern a
f Pattern a
p = (Int -> Pattern a -> Pattern a) -> Pattern a -> [Int] -> Pattern a
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
forall a. Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
`_every` Pattern a -> Pattern a
f) Pattern a
p [Int]
ns

{-|
The given pattern transformation is applied only @when@ the given test function
returns @True@. The test function will be called with the current cycle as
a number.

> d1 $ when (elem '4' . show)
>           (striate 4)
>    $ sound "hh hc"

The above will only apply @striate 4@ to the pattern if the current
cycle number contains the number 4. So the fourth cycle will be
striated and the fourteenth and so on. Expect lots of striates after
cycle number 399.
-}
when :: (Int -> Bool) -> (Pattern a -> Pattern a) ->  Pattern a -> Pattern a
when :: forall a.
(Int -> Bool) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
when Int -> Bool
test Pattern a -> Pattern a
f Pattern a
p = Pattern a -> Pattern a
forall a. Pattern a -> Pattern a
splitQueries (Pattern a -> Pattern a) -> Pattern a -> Pattern a
forall a b. (a -> b) -> a -> b
$ Pattern a
p {query = apply}
  where apply :: State -> [Event a]
apply State
st | Int -> Bool
test (Rational -> Int
forall b. Integral b => Rational -> b
forall a b. (RealFrac a, Integral b) => a -> b
floor (Rational -> Int) -> Rational -> Int
forall a b. (a -> b) -> a -> b
$ ArcF Rational -> Rational
forall a. ArcF a -> a
start (ArcF Rational -> Rational) -> ArcF Rational -> Rational
forall a b. (a -> b) -> a -> b
$ State -> ArcF Rational
arc State
st) = Pattern a -> State -> [Event a]
forall a. Pattern a -> State -> [Event a]
query (Pattern a -> Pattern a
f Pattern a
p) State
st
                 | Bool
otherwise = Pattern a -> State -> [Event a]
forall a. Pattern a -> State -> [Event a]
query Pattern a
p State
st

{- | Like 'when', but works on continuous time values rather than cycle numbers.
  The following will apply @# speed 2@ only when the remainder of the current
  @Time@ divided by 2 is less than 0.5:

  > d1 $ whenT ((< 0.5) . (flip Data.Fixed.mod' 2))
  >            (# speed 2)
  >    $ sound "hh(4,8) hc(3,8)"
-}
whenT :: (Time -> Bool) -> (Pattern a -> Pattern a) ->  Pattern a -> Pattern a
whenT :: forall a.
(Rational -> Bool)
-> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
whenT Rational -> Bool
test Pattern a -> Pattern a
f Pattern a
p = Pattern a -> Pattern a
forall a. Pattern a -> Pattern a
splitQueries (Pattern a -> Pattern a) -> Pattern a -> Pattern a
forall a b. (a -> b) -> a -> b
$ Pattern a
p {query = apply}
  where apply :: State -> [Event a]
apply State
st | Rational -> Bool
test (ArcF Rational -> Rational
forall a. ArcF a -> a
start (ArcF Rational -> Rational) -> ArcF Rational -> Rational
forall a b. (a -> b) -> a -> b
$ State -> ArcF Rational
arc State
st) = Pattern a -> State -> [Event a]
forall a. Pattern a -> State -> [Event a]
query (Pattern a -> Pattern a
f Pattern a
p) State
st
                 | Bool
otherwise = Pattern a -> State -> [Event a]
forall a. Pattern a -> State -> [Event a]
query Pattern a
p State
st

_getP_ :: (Value -> Maybe a) -> Pattern Value -> Pattern a
_getP_ :: forall a. (Value -> Maybe a) -> Pattern Value -> Pattern a
_getP_ Value -> Maybe a
f Pattern Value
pat = Pattern (Maybe a) -> Pattern a
forall a. Pattern (Maybe a) -> Pattern a
filterJust (Pattern (Maybe a) -> Pattern a) -> Pattern (Maybe a) -> Pattern a
forall a b. (a -> b) -> a -> b
$ Value -> Maybe a
f (Value -> Maybe a) -> Pattern Value -> Pattern (Maybe a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern Value
pat

_getP :: a -> (Value -> Maybe a) -> Pattern Value -> Pattern a
_getP :: forall a. a -> (Value -> Maybe a) -> Pattern Value -> Pattern a
_getP a
d Value -> Maybe a
f Pattern Value
pat = a -> Maybe a -> a
forall a. a -> Maybe a -> a
fromMaybe a
d (Maybe a -> a) -> (Value -> Maybe a) -> Value -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Maybe a
f (Value -> a) -> Pattern Value -> Pattern a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern Value
pat

_cX :: a -> (Value -> Maybe a) -> String -> Pattern a
_cX :: forall a. a -> (Value -> Maybe a) -> String -> Pattern a
_cX a
d Value -> Maybe a
f String
s = (State -> [Event a]) -> Pattern a
forall a. (State -> [Event a]) -> Pattern a
Pattern ((State -> [Event a]) -> Pattern a)
-> (State -> [Event a]) -> Pattern a
forall a b. (a -> b) -> a -> b
$ \(State ArcF Rational
a ValueMap
m) -> Pattern a -> ArcF Rational -> [Event a]
forall a. Pattern a -> ArcF Rational -> [Event a]
queryArc (Pattern a -> (Value -> Pattern a) -> Maybe Value -> Pattern a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (a -> Pattern a
forall a. a -> Pattern a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
d) (a -> (Value -> Maybe a) -> Pattern Value -> Pattern a
forall a. a -> (Value -> Maybe a) -> Pattern Value -> Pattern a
_getP a
d Value -> Maybe a
f (Pattern Value -> Pattern a)
-> (Value -> Pattern Value) -> Value -> Pattern a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Pattern Value
valueToPattern) (Maybe Value -> Pattern a) -> Maybe Value -> Pattern a
forall a b. (a -> b) -> a -> b
$ String -> ValueMap -> Maybe Value
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup String
s ValueMap
m) ArcF Rational
a

_cX_ :: (Value -> Maybe a) -> String -> Pattern a
_cX_ :: forall a. (Value -> Maybe a) -> String -> Pattern a
_cX_ Value -> Maybe a
f String
s = (State -> [Event a]) -> Pattern a
forall a. (State -> [Event a]) -> Pattern a
Pattern ((State -> [Event a]) -> Pattern a)
-> (State -> [Event a]) -> Pattern a
forall a b. (a -> b) -> a -> b
$ \(State ArcF Rational
a ValueMap
m) -> Pattern a -> ArcF Rational -> [Event a]
forall a. Pattern a -> ArcF Rational -> [Event a]
queryArc (Pattern a -> (Value -> Pattern a) -> Maybe Value -> Pattern a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Pattern a
forall a. Pattern a
silence ((Value -> Maybe a) -> Pattern Value -> Pattern a
forall a. (Value -> Maybe a) -> Pattern Value -> Pattern a
_getP_ Value -> Maybe a
f (Pattern Value -> Pattern a)
-> (Value -> Pattern Value) -> Value -> Pattern a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Pattern Value
valueToPattern) (Maybe Value -> Pattern a) -> Maybe Value -> Pattern a
forall a b. (a -> b) -> a -> b
$ String -> ValueMap -> Maybe Value
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup String
s ValueMap
m) ArcF Rational
a

cF :: Double -> String -> Pattern Double
cF :: Double -> String -> Pattern Double
cF Double
d = Double -> (Value -> Maybe Double) -> String -> Pattern Double
forall a. a -> (Value -> Maybe a) -> String -> Pattern a
_cX Double
d Value -> Maybe Double
getF
cF_ :: String -> Pattern Double
cF_ :: String -> Pattern Double
cF_ = (Value -> Maybe Double) -> String -> Pattern Double
forall a. (Value -> Maybe a) -> String -> Pattern a
_cX_ Value -> Maybe Double
getF
cF0 :: String -> Pattern Double
cF0 :: String -> Pattern Double
cF0 = Double -> (Value -> Maybe Double) -> String -> Pattern Double
forall a. a -> (Value -> Maybe a) -> String -> Pattern a
_cX Double
0 Value -> Maybe Double
getF

cN :: Note -> String -> Pattern Note
cN :: Note -> String -> Pattern Note
cN Note
d = Note -> (Value -> Maybe Note) -> String -> Pattern Note
forall a. a -> (Value -> Maybe a) -> String -> Pattern a
_cX Note
d Value -> Maybe Note
getN
cN_ :: String -> Pattern Note
cN_ :: String -> Pattern Note
cN_ = (Value -> Maybe Note) -> String -> Pattern Note
forall a. (Value -> Maybe a) -> String -> Pattern a
_cX_ Value -> Maybe Note
getN
cN0 :: String -> Pattern Note
cN0 :: String -> Pattern Note
cN0 = Note -> (Value -> Maybe Note) -> String -> Pattern Note
forall a. a -> (Value -> Maybe a) -> String -> Pattern a
_cX (Double -> Note
Note Double
0) Value -> Maybe Note
getN

cI :: Int -> String -> Pattern Int
cI :: Int -> String -> Pattern Int
cI Int
d = Int -> (Value -> Maybe Int) -> String -> Pattern Int
forall a. a -> (Value -> Maybe a) -> String -> Pattern a
_cX Int
d Value -> Maybe Int
getI
cI_ :: String -> Pattern Int
cI_ :: String -> Pattern Int
cI_ = (Value -> Maybe Int) -> String -> Pattern Int
forall a. (Value -> Maybe a) -> String -> Pattern a
_cX_ Value -> Maybe Int
getI
cI0 :: String -> Pattern Int
cI0 :: String -> Pattern Int
cI0 = Int -> (Value -> Maybe Int) -> String -> Pattern Int
forall a. a -> (Value -> Maybe a) -> String -> Pattern a
_cX Int
0 Value -> Maybe Int
getI

cB :: Bool -> String -> Pattern Bool
cB :: Bool -> String -> Pattern Bool
cB Bool
d = Bool -> (Value -> Maybe Bool) -> String -> Pattern Bool
forall a. a -> (Value -> Maybe a) -> String -> Pattern a
_cX Bool
d Value -> Maybe Bool
getB
cB_ :: String -> Pattern Bool
cB_ :: String -> Pattern Bool
cB_ = (Value -> Maybe Bool) -> String -> Pattern Bool
forall a. (Value -> Maybe a) -> String -> Pattern a
_cX_ Value -> Maybe Bool
getB
cB0 :: String -> Pattern Bool
cB0 :: String -> Pattern Bool
cB0 = Bool -> (Value -> Maybe Bool) -> String -> Pattern Bool
forall a. a -> (Value -> Maybe a) -> String -> Pattern a
_cX Bool
False Value -> Maybe Bool
getB

cR :: Rational -> String -> Pattern Rational
cR :: Rational -> String -> Pattern Rational
cR Rational
d = Rational -> (Value -> Maybe Rational) -> String -> Pattern Rational
forall a. a -> (Value -> Maybe a) -> String -> Pattern a
_cX Rational
d Value -> Maybe Rational
getR
cR_ :: String -> Pattern Rational
cR_ :: String -> Pattern Rational
cR_ = (Value -> Maybe Rational) -> String -> Pattern Rational
forall a. (Value -> Maybe a) -> String -> Pattern a
_cX_ Value -> Maybe Rational
getR
cR0 :: String -> Pattern Rational
cR0 :: String -> Pattern Rational
cR0 = Rational -> (Value -> Maybe Rational) -> String -> Pattern Rational
forall a. a -> (Value -> Maybe a) -> String -> Pattern a
_cX Rational
0 Value -> Maybe Rational
getR

cT :: Time -> String -> Pattern Time
cT :: Rational -> String -> Pattern Rational
cT = Rational -> String -> Pattern Rational
cR
cT0 :: String -> Pattern Time
cT0 :: String -> Pattern Rational
cT0 = String -> Pattern Rational
cR0
cT_ :: String -> Pattern Time
cT_ :: String -> Pattern Rational
cT_ = String -> Pattern Rational
cR_

cS :: String -> String -> Pattern String
cS :: String -> String -> Pattern String
cS String
d = String -> (Value -> Maybe String) -> String -> Pattern String
forall a. a -> (Value -> Maybe a) -> String -> Pattern a
_cX String
d Value -> Maybe String
getS
cS_ :: String -> Pattern String
cS_ :: String -> Pattern String
cS_ = (Value -> Maybe String) -> String -> Pattern String
forall a. (Value -> Maybe a) -> String -> Pattern a
_cX_ Value -> Maybe String
getS
cS0 :: String -> Pattern String
cS0 :: String -> Pattern String
cS0 = String -> (Value -> Maybe String) -> String -> Pattern String
forall a. a -> (Value -> Maybe a) -> String -> Pattern a
_cX String
"" Value -> Maybe String
getS

-- Default controller inputs (for MIDI)
in0 :: Pattern Double
in0 :: Pattern Double
in0 = Double -> String -> Pattern Double
cF Double
0 String
"0"
in1 :: Pattern Double
in1 :: Pattern Double
in1 = Double -> String -> Pattern Double
cF Double
0 String
"1"
in2 :: Pattern Double
in2 :: Pattern Double
in2 = Double -> String -> Pattern Double
cF Double
0 String
"2"
in3 :: Pattern Double
in3 :: Pattern Double
in3 = Double -> String -> Pattern Double
cF Double
0 String
"3"
in4 :: Pattern Double
in4 :: Pattern Double
in4 = Double -> String -> Pattern Double
cF Double
0 String
"4"
in5 :: Pattern Double
in5 :: Pattern Double
in5 = Double -> String -> Pattern Double
cF Double
0 String
"5"
in6 :: Pattern Double
in6 :: Pattern Double
in6 = Double -> String -> Pattern Double
cF Double
0 String
"6"
in7 :: Pattern Double
in7 :: Pattern Double
in7 = Double -> String -> Pattern Double
cF Double
0 String
"7"
in8 :: Pattern Double
in8 :: Pattern Double
in8 = Double -> String -> Pattern Double
cF Double
0 String
"8"
in9 :: Pattern Double
in9 :: Pattern Double
in9 = Double -> String -> Pattern Double
cF Double
0 String
"9"
in10 :: Pattern Double
in10 :: Pattern Double
in10 = Double -> String -> Pattern Double
cF Double
0 String
"10"
in11 :: Pattern Double
in11 :: Pattern Double
in11 = Double -> String -> Pattern Double
cF Double
0 String
"11"
in12 :: Pattern Double
in12 :: Pattern Double
in12 = Double -> String -> Pattern Double
cF Double
0 String
"12"
in13 :: Pattern Double
in13 :: Pattern Double
in13 = Double -> String -> Pattern Double
cF Double
0 String
"13"
in14 :: Pattern Double
in14 :: Pattern Double
in14 = Double -> String -> Pattern Double
cF Double
0 String
"14"
in15 :: Pattern Double
in15 :: Pattern Double
in15 = Double -> String -> Pattern Double
cF Double
0 String
"15"
in16 :: Pattern Double
in16 :: Pattern Double
in16 = Double -> String -> Pattern Double
cF Double
0 String
"16"
in17 :: Pattern Double
in17 :: Pattern Double
in17 = Double -> String -> Pattern Double
cF Double
0 String
"17"
in18 :: Pattern Double
in18 :: Pattern Double
in18 = Double -> String -> Pattern Double
cF Double
0 String
"18"
in19 :: Pattern Double
in19 :: Pattern Double
in19 = Double -> String -> Pattern Double
cF Double
0 String
"19"
in20 :: Pattern Double
in20 :: Pattern Double
in20 = Double -> String -> Pattern Double
cF Double
0 String
"20"
in21 :: Pattern Double
in21 :: Pattern Double
in21 = Double -> String -> Pattern Double
cF Double
0 String
"21"
in22 :: Pattern Double
in22 :: Pattern Double
in22 = Double -> String -> Pattern Double
cF Double
0 String
"22"
in23 :: Pattern Double
in23 :: Pattern Double
in23 = Double -> String -> Pattern Double
cF Double
0 String
"23"
in24 :: Pattern Double
in24 :: Pattern Double
in24 = Double -> String -> Pattern Double
cF Double
0 String
"24"
in25 :: Pattern Double
in25 :: Pattern Double
in25 = Double -> String -> Pattern Double
cF Double
0 String
"25"
in26 :: Pattern Double
in26 :: Pattern Double
in26 = Double -> String -> Pattern Double
cF Double
0 String
"26"
in27 :: Pattern Double
in27 :: Pattern Double
in27 = Double -> String -> Pattern Double
cF Double
0 String
"27"
in28 :: Pattern Double
in28 :: Pattern Double
in28 = Double -> String -> Pattern Double
cF Double
0 String
"28"
in29 :: Pattern Double
in29 :: Pattern Double
in29 = Double -> String -> Pattern Double
cF Double
0 String
"29"
in30 :: Pattern Double
in30 :: Pattern Double
in30 = Double -> String -> Pattern Double
cF Double
0 String
"30"
in31 :: Pattern Double
in31 :: Pattern Double
in31 = Double -> String -> Pattern Double
cF Double
0 String
"31"
in32 :: Pattern Double
in32 :: Pattern Double
in32 = Double -> String -> Pattern Double
cF Double
0 String
"32"
in33 :: Pattern Double
in33 :: Pattern Double
in33 = Double -> String -> Pattern Double
cF Double
0 String
"33"
in34 :: Pattern Double
in34 :: Pattern Double
in34 = Double -> String -> Pattern Double
cF Double
0 String
"34"
in35 :: Pattern Double
in35 :: Pattern Double
in35 = Double -> String -> Pattern Double
cF Double
0 String
"35"
in36 :: Pattern Double
in36 :: Pattern Double
in36 = Double -> String -> Pattern Double
cF Double
0 String
"36"
in37 :: Pattern Double
in37 :: Pattern Double
in37 = Double -> String -> Pattern Double
cF Double
0 String
"37"
in38 :: Pattern Double
in38 :: Pattern Double
in38 = Double -> String -> Pattern Double
cF Double
0 String
"38"
in39 :: Pattern Double
in39 :: Pattern Double
in39 = Double -> String -> Pattern Double
cF Double
0 String
"39"
in40 :: Pattern Double
in40 :: Pattern Double
in40 = Double -> String -> Pattern Double
cF Double
0 String
"40"
in41 :: Pattern Double
in41 :: Pattern Double
in41 = Double -> String -> Pattern Double
cF Double
0 String
"41"
in42 :: Pattern Double
in42 :: Pattern Double
in42 = Double -> String -> Pattern Double
cF Double
0 String
"42"
in43 :: Pattern Double
in43 :: Pattern Double
in43 = Double -> String -> Pattern Double
cF Double
0 String
"43"
in44 :: Pattern Double
in44 :: Pattern Double
in44 = Double -> String -> Pattern Double
cF Double
0 String
"44"
in45 :: Pattern Double
in45 :: Pattern Double
in45 = Double -> String -> Pattern Double
cF Double
0 String
"45"
in46 :: Pattern Double
in46 :: Pattern Double
in46 = Double -> String -> Pattern Double
cF Double
0 String
"46"
in47 :: Pattern Double
in47 :: Pattern Double
in47 = Double -> String -> Pattern Double
cF Double
0 String
"47"
in48 :: Pattern Double
in48 :: Pattern Double
in48 = Double -> String -> Pattern Double
cF Double
0 String
"48"
in49 :: Pattern Double
in49 :: Pattern Double
in49 = Double -> String -> Pattern Double
cF Double
0 String
"49"
in50 :: Pattern Double
in50 :: Pattern Double
in50 = Double -> String -> Pattern Double
cF Double
0 String
"50"
in51 :: Pattern Double
in51 :: Pattern Double
in51 = Double -> String -> Pattern Double
cF Double
0 String
"51"
in52 :: Pattern Double
in52 :: Pattern Double
in52 = Double -> String -> Pattern Double
cF Double
0 String
"52"
in53 :: Pattern Double
in53 :: Pattern Double
in53 = Double -> String -> Pattern Double
cF Double
0 String
"53"
in54 :: Pattern Double
in54 :: Pattern Double
in54 = Double -> String -> Pattern Double
cF Double
0 String
"54"
in55 :: Pattern Double
in55 :: Pattern Double
in55 = Double -> String -> Pattern Double
cF Double
0 String
"55"
in56 :: Pattern Double
in56 :: Pattern Double
in56 = Double -> String -> Pattern Double
cF Double
0 String
"56"
in57 :: Pattern Double
in57 :: Pattern Double
in57 = Double -> String -> Pattern Double
cF Double
0 String
"57"
in58 :: Pattern Double
in58 :: Pattern Double
in58 = Double -> String -> Pattern Double
cF Double
0 String
"58"
in59 :: Pattern Double
in59 :: Pattern Double
in59 = Double -> String -> Pattern Double
cF Double
0 String
"59"
in60 :: Pattern Double
in60 :: Pattern Double
in60 = Double -> String -> Pattern Double
cF Double
0 String
"60"
in61 :: Pattern Double
in61 :: Pattern Double
in61 = Double -> String -> Pattern Double
cF Double
0 String
"61"
in62 :: Pattern Double
in62 :: Pattern Double
in62 = Double -> String -> Pattern Double
cF Double
0 String
"62"
in63 :: Pattern Double
in63 :: Pattern Double
in63 = Double -> String -> Pattern Double
cF Double
0 String
"63"
in64 :: Pattern Double
in64 :: Pattern Double
in64 = Double -> String -> Pattern Double
cF Double
0 String
"64"
in65 :: Pattern Double
in65 :: Pattern Double
in65 = Double -> String -> Pattern Double
cF Double
0 String
"65"
in66 :: Pattern Double
in66 :: Pattern Double
in66 = Double -> String -> Pattern Double
cF Double
0 String
"66"
in67 :: Pattern Double
in67 :: Pattern Double
in67 = Double -> String -> Pattern Double
cF Double
0 String
"67"
in68 :: Pattern Double
in68 :: Pattern Double
in68 = Double -> String -> Pattern Double
cF Double
0 String
"68"
in69 :: Pattern Double
in69 :: Pattern Double
in69 = Double -> String -> Pattern Double
cF Double
0 String
"69"
in70 :: Pattern Double
in70 :: Pattern Double
in70 = Double -> String -> Pattern Double
cF Double
0 String
"70"
in71 :: Pattern Double
in71 :: Pattern Double
in71 = Double -> String -> Pattern Double
cF Double
0 String
"71"
in72 :: Pattern Double
in72 :: Pattern Double
in72 = Double -> String -> Pattern Double
cF Double
0 String
"72"
in73 :: Pattern Double
in73 :: Pattern Double
in73 = Double -> String -> Pattern Double
cF Double
0 String
"73"
in74 :: Pattern Double
in74 :: Pattern Double
in74 = Double -> String -> Pattern Double
cF Double
0 String
"74"
in75 :: Pattern Double
in75 :: Pattern Double
in75 = Double -> String -> Pattern Double
cF Double
0 String
"75"
in76 :: Pattern Double
in76 :: Pattern Double
in76 = Double -> String -> Pattern Double
cF Double
0 String
"76"
in77 :: Pattern Double
in77 :: Pattern Double
in77 = Double -> String -> Pattern Double
cF Double
0 String
"77"
in78 :: Pattern Double
in78 :: Pattern Double
in78 = Double -> String -> Pattern Double
cF Double
0 String
"78"
in79 :: Pattern Double
in79 :: Pattern Double
in79 = Double -> String -> Pattern Double
cF Double
0 String
"79"
in80 :: Pattern Double
in80 :: Pattern Double
in80 = Double -> String -> Pattern Double
cF Double
0 String
"80"
in81 :: Pattern Double
in81 :: Pattern Double
in81 = Double -> String -> Pattern Double
cF Double
0 String
"81"
in82 :: Pattern Double
in82 :: Pattern Double
in82 = Double -> String -> Pattern Double
cF Double
0 String
"82"
in83 :: Pattern Double
in83 :: Pattern Double
in83 = Double -> String -> Pattern Double
cF Double
0 String
"83"
in84 :: Pattern Double
in84 :: Pattern Double
in84 = Double -> String -> Pattern Double
cF Double
0 String
"84"
in85 :: Pattern Double
in85 :: Pattern Double
in85 = Double -> String -> Pattern Double
cF Double
0 String
"85"
in86 :: Pattern Double
in86 :: Pattern Double
in86 = Double -> String -> Pattern Double
cF Double
0 String
"86"
in87 :: Pattern Double
in87 :: Pattern Double
in87 = Double -> String -> Pattern Double
cF Double
0 String
"87"
in88 :: Pattern Double
in88 :: Pattern Double
in88 = Double -> String -> Pattern Double
cF Double
0 String
"88"
in89 :: Pattern Double
in89 :: Pattern Double
in89 = Double -> String -> Pattern Double
cF Double
0 String
"89"
in90 :: Pattern Double
in90 :: Pattern Double
in90 = Double -> String -> Pattern Double
cF Double
0 String
"90"
in91 :: Pattern Double
in91 :: Pattern Double
in91 = Double -> String -> Pattern Double
cF Double
0 String
"91"
in92 :: Pattern Double
in92 :: Pattern Double
in92 = Double -> String -> Pattern Double
cF Double
0 String
"92"
in93 :: Pattern Double
in93 :: Pattern Double
in93 = Double -> String -> Pattern Double
cF Double
0 String
"93"
in94 :: Pattern Double
in94 :: Pattern Double
in94 = Double -> String -> Pattern Double
cF Double
0 String
"94"
in95 :: Pattern Double
in95 :: Pattern Double
in95 = Double -> String -> Pattern Double
cF Double
0 String
"95"
in96 :: Pattern Double
in96 :: Pattern Double
in96 = Double -> String -> Pattern Double
cF Double
0 String
"96"
in97 :: Pattern Double
in97 :: Pattern Double
in97 = Double -> String -> Pattern Double
cF Double
0 String
"97"
in98 :: Pattern Double
in98 :: Pattern Double
in98 = Double -> String -> Pattern Double
cF Double
0 String
"98"
in99 :: Pattern Double
in99 :: Pattern Double
in99 = Double -> String -> Pattern Double
cF Double
0 String
"99"
in100 :: Pattern Double
in100 :: Pattern Double
in100 = Double -> String -> Pattern Double
cF Double
0 String
"100"
in101 :: Pattern Double
in101 :: Pattern Double
in101 = Double -> String -> Pattern Double
cF Double
0 String
"101"
in102 :: Pattern Double
in102 :: Pattern Double
in102 = Double -> String -> Pattern Double
cF Double
0 String
"102"
in103 :: Pattern Double
in103 :: Pattern Double
in103 = Double -> String -> Pattern Double
cF Double
0 String
"103"
in104 :: Pattern Double
in104 :: Pattern Double
in104 = Double -> String -> Pattern Double
cF Double
0 String
"104"
in105 :: Pattern Double
in105 :: Pattern Double
in105 = Double -> String -> Pattern Double
cF Double
0 String
"105"
in106 :: Pattern Double
in106 :: Pattern Double
in106 = Double -> String -> Pattern Double
cF Double
0 String
"106"
in107 :: Pattern Double
in107 :: Pattern Double
in107 = Double -> String -> Pattern Double
cF Double
0 String
"107"
in108 :: Pattern Double
in108 :: Pattern Double
in108 = Double -> String -> Pattern Double
cF Double
0 String
"108"
in109 :: Pattern Double
in109 :: Pattern Double
in109 = Double -> String -> Pattern Double
cF Double
0 String
"109"
in110 :: Pattern Double
in110 :: Pattern Double
in110 = Double -> String -> Pattern Double
cF Double
0 String
"110"
in111 :: Pattern Double
in111 :: Pattern Double
in111 = Double -> String -> Pattern Double
cF Double
0 String
"111"
in112 :: Pattern Double
in112 :: Pattern Double
in112 = Double -> String -> Pattern Double
cF Double
0 String
"112"
in113 :: Pattern Double
in113 :: Pattern Double
in113 = Double -> String -> Pattern Double
cF Double
0 String
"113"
in114 :: Pattern Double
in114 :: Pattern Double
in114 = Double -> String -> Pattern Double
cF Double
0 String
"114"
in115 :: Pattern Double
in115 :: Pattern Double
in115 = Double -> String -> Pattern Double
cF Double
0 String
"115"
in116 :: Pattern Double
in116 :: Pattern Double
in116 = Double -> String -> Pattern Double
cF Double
0 String
"116"
in117 :: Pattern Double
in117 :: Pattern Double
in117 = Double -> String -> Pattern Double
cF Double
0 String
"117"
in118 :: Pattern Double
in118 :: Pattern Double
in118 = Double -> String -> Pattern Double
cF Double
0 String
"118"
in119 :: Pattern Double
in119 :: Pattern Double
in119 = Double -> String -> Pattern Double
cF Double
0 String
"119"
in120 :: Pattern Double
in120 :: Pattern Double
in120 = Double -> String -> Pattern Double
cF Double
0 String
"120"
in121 :: Pattern Double
in121 :: Pattern Double
in121 = Double -> String -> Pattern Double
cF Double
0 String
"121"
in122 :: Pattern Double
in122 :: Pattern Double
in122 = Double -> String -> Pattern Double
cF Double
0 String
"122"
in123 :: Pattern Double
in123 :: Pattern Double
in123 = Double -> String -> Pattern Double
cF Double
0 String
"123"
in124 :: Pattern Double
in124 :: Pattern Double
in124 = Double -> String -> Pattern Double
cF Double
0 String
"124"
in125 :: Pattern Double
in125 :: Pattern Double
in125 = Double -> String -> Pattern Double
cF Double
0 String
"125"
in126 :: Pattern Double
in126 :: Pattern Double
in126 = Double -> String -> Pattern Double
cF Double
0 String
"126"
in127 :: Pattern Double
in127 :: Pattern Double
in127 = Double -> String -> Pattern Double
cF Double
0 String
"127"