{-# LANGUAGE FlexibleInstances #-}

{-
    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 Data.Fixed (mod')
import Data.List (sortOn)
import qualified Data.Map.Strict as Map
import Data.Maybe (fromMaybe, mapMaybe)
import Sound.Tidal.Pattern
import Prelude hiding ((*>), (<*))

-- ** 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
s)]

-- | @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
1 a -> 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
1 Double -> 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
pi Double -> 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
1 Rational -> 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
pi Double -> 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
1 Rational -> 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
n a -> 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
p : []) = Pattern a
p
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
p : []) = Pattern a
p
fastCat [Pattern a]
ps = Maybe (Pattern Rational) -> Pattern a -> Pattern a
forall a. Maybe (Pattern Rational) -> Pattern a -> Pattern a
setTactus Maybe (Pattern Rational)
t (Pattern a -> Pattern a) -> Pattern a -> Pattern a
forall a b. (a -> b) -> a -> b
$ 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
  where
    t :: Maybe (Pattern Rational)
t = [Pattern Rational] -> Pattern Rational
forall a. [Pattern a] -> Pattern a
fastCat ([Pattern Rational] -> Pattern Rational)
-> Maybe [Pattern Rational] -> Maybe (Pattern Rational)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ([Maybe (Pattern Rational)] -> Maybe [Pattern Rational]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence ([Maybe (Pattern Rational)] -> Maybe [Pattern Rational])
-> [Maybe (Pattern Rational)] -> Maybe [Pattern Rational]
forall a b. (a -> b) -> a -> b
$ (Pattern a -> Maybe (Pattern Rational))
-> [Pattern a] -> [Maybe (Pattern Rational)]
forall a b. (a -> b) -> [a] -> [b]
map Pattern a -> Maybe (Pattern Rational)
forall a. Pattern a -> Maybe (Pattern Rational)
tactus [Pattern a]
ps)

--  where t = fromMaybe (toRational $ length ps) $ ((* (toRational $ length ps)) . foldl1 lcmr) <$> (sequence $ map tactus 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
p) : []) = Pattern a
p
timeCat [(Rational, Pattern a)]
tps = Maybe (Pattern Rational) -> Pattern a -> Pattern a
forall a. Maybe (Pattern Rational) -> Pattern a -> Pattern a
setTactus (Pattern Rational -> Maybe (Pattern Rational)
forall a. a -> Maybe a
Just (Pattern Rational -> Maybe (Pattern Rational))
-> Pattern Rational -> Maybe (Pattern Rational)
forall a b. (a -> b) -> a -> b
$ Rational -> Pattern Rational
forall a. a -> Pattern a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Rational
total) (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
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
s Rational -> Rational -> Rational
forall a. Fractional a => a -> a -> a
/ Rational
total) (Rational
e Rational -> 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)] -> [(Rational, Rational, Pattern a)])
-> [(Rational, Pattern a)] -> [(Rational, Rational, Pattern a)]
forall a b. (a -> b) -> a -> b
$ ((Rational, Pattern a) -> Bool)
-> [(Rational, Pattern a)] -> [(Rational, Pattern a)]
forall a. (a -> Bool) -> [a] -> [a]
filter (\(Rational
t, Pattern a
_) -> Rational
t Rational -> Rational -> Bool
forall a. Ord a => a -> a -> Bool
> Rational
0) ([(Rational, Pattern a)] -> [(Rational, Pattern a)])
-> [(Rational, Pattern a)] -> [(Rational, Pattern a)]
forall a b. (a -> b) -> a -> b
$ [(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
t Rational -> 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
t Rational -> 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
(<>)

-- | Serialises a pattern so there's only one event playing at any one
-- time, making it /monophonic/. Events which start/end earlier are given priority.
mono :: Pattern a -> Pattern a
mono :: forall a. Pattern a -> Pattern a
mono Pattern a
p = (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
cm) -> [Event a] -> [Event a]
forall a. [Event a] -> [Event a]
flatten ([Event a] -> [Event a]) -> [Event a] -> [Event a]
forall a b. (a -> b) -> a -> b
$ Pattern a -> State -> [Event a]
forall a. Pattern a -> State -> [Event a]
query Pattern a
p (ArcF Rational -> ValueMap -> State
State ArcF Rational
a ValueMap
cm)
  where
    flatten :: [Event a] -> [Event a]
    flatten :: forall a. [Event a] -> [Event a]
flatten = (Event a -> Maybe (Event a)) -> [Event a] -> [Event a]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe Event a -> Maybe (Event a)
forall a. Event a -> Maybe (Event a)
constrainPart ([Event a] -> [Event a])
-> ([Event a] -> [Event a]) -> [Event a] -> [Event a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Event a] -> [Event a]
forall a. [Event a] -> [Event a]
truncateOverlaps ([Event a] -> [Event a])
-> ([Event a] -> [Event a]) -> [Event a] -> [Event a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Event a -> Maybe (ArcF Rational)) -> [Event a] -> [Event a]
forall b a. Ord b => (a -> b) -> [a] -> [a]
sortOn Event a -> Maybe (ArcF Rational)
forall a b. EventF a b -> Maybe a
whole
    truncateOverlaps :: [Event b] -> [Event b]
truncateOverlaps [] = []
    truncateOverlaps (Event b
e : [Event b]
es) = Event b
e Event b -> [Event b] -> [Event b]
forall a. a -> [a] -> [a]
: [Event b] -> [Event b]
truncateOverlaps ((Event b -> Maybe (Event b)) -> [Event b] -> [Event b]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe (Event b -> Event b -> Maybe (Event b)
forall {a} {b}. Event a -> Event b -> Maybe (Event b)
snip Event b
e) [Event b]
es)
    -- TODO - decide what to do about analog events..
    snip :: Event a -> Event b -> Maybe (Event b)
snip Event a
a Event b
b
      | ArcF Rational -> Rational
forall a. ArcF a -> a
start (Event b -> ArcF Rational
forall a. Event a -> ArcF Rational
wholeOrPart Event b
b) Rational -> Rational -> Bool
forall a. Ord a => a -> a -> Bool
>= ArcF Rational -> Rational
forall a. ArcF a -> a
stop (Event a -> ArcF Rational
forall a. Event a -> ArcF Rational
wholeOrPart Event a
a) = Event b -> Maybe (Event b)
forall a. a -> Maybe a
Just Event b
b
      | ArcF Rational -> Rational
forall a. ArcF a -> a
stop (Event b -> ArcF Rational
forall a. Event a -> ArcF Rational
wholeOrPart Event b
b) Rational -> Rational -> Bool
forall a. Ord a => a -> a -> Bool
<= ArcF Rational -> Rational
forall a. ArcF a -> a
stop (Event a -> ArcF Rational
forall a. Event a -> ArcF Rational
wholeOrPart Event a
a) = Maybe (Event b)
forall a. Maybe a
Nothing
      | Bool
otherwise = Event b -> Maybe (Event b)
forall a. a -> Maybe a
Just Event b
b {whole = Just $ Arc (stop $ wholeOrPart a) (stop $ wholeOrPart b)}
    constrainPart :: Event a -> Maybe (Event a)
    constrainPart :: forall a. Event a -> Maybe (Event a)
constrainPart Event a
e = do
      ArcF Rational
a <- ArcF Rational -> ArcF Rational -> Maybe (ArcF Rational)
subArc (Event a -> ArcF Rational
forall a. Event a -> ArcF Rational
wholeOrPart Event a
e) (Event a -> ArcF Rational
forall a b. EventF a b -> a
part Event a
e)
      Event a -> Maybe (Event a)
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return (Event a -> Maybe (Event a)) -> Event a -> Maybe (Event a)
forall a b. (a -> b) -> a -> b
$ Event a
e {part = 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]
pats = ((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 [Pattern a]
pats) {tactus = t}
  where
    t :: Maybe (Pattern Rational)
t
      | [Pattern a] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Pattern a]
pats Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 = Maybe (Pattern Rational)
forall a. Maybe a
Nothing
      -- TODO - something cleverer..
      | Bool
otherwise = (Pattern Rational -> Pattern Rational
forall a. Pattern a -> Pattern a
mono (Pattern Rational -> Pattern Rational)
-> ([Pattern Rational] -> Pattern Rational)
-> [Pattern Rational]
-> Pattern Rational
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Pattern Rational] -> Pattern Rational
forall a. [Pattern a] -> Pattern a
stack) ([Pattern Rational] -> Pattern Rational)
-> Maybe [Pattern Rational] -> Maybe (Pattern Rational)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ([Maybe (Pattern Rational)] -> Maybe [Pattern Rational]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence ([Maybe (Pattern Rational)] -> Maybe [Pattern Rational])
-> [Maybe (Pattern Rational)] -> Maybe [Pattern Rational]
forall a b. (a -> b) -> a -> b
$ (Pattern a -> Maybe (Pattern Rational))
-> [Pattern a] -> [Maybe (Pattern Rational)]
forall a b. (a -> b) -> [a] -> [b]
map Pattern a -> Maybe (Pattern Rational)
forall a. Pattern a -> Maybe (Pattern Rational)
tactus [Pattern a]
pats)

--          | otherwise = foldl1 lcmr <$> (sequence $ map tactus pats)

-- ** 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 b c a.
(b -> Pattern c -> Pattern a)
-> Pattern b -> Pattern c -> Pattern a
patternify' 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 b c a.
(b -> Pattern c -> Pattern a)
-> Pattern b -> Pattern c -> Pattern a
patternify' 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 b c a.
(b -> Pattern c -> Pattern a)
-> Pattern b -> Pattern c -> Pattern a
patternifySqueeze 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)

zoompat :: Pattern Time -> Pattern Time -> Pattern a -> Pattern a
zoompat :: forall a.
Pattern Rational -> Pattern Rational -> Pattern a -> Pattern a
zoompat = (Rational -> Rational -> Pattern a -> Pattern a)
-> Pattern Rational -> Pattern Rational -> Pattern a -> Pattern a
forall a b c d.
(a -> b -> c -> Pattern d)
-> Pattern a -> Pattern b -> c -> Pattern d
patternify2 ((Rational -> Rational -> Pattern a -> Pattern a)
 -> Pattern Rational -> Pattern Rational -> Pattern a -> Pattern a)
-> (Rational -> Rational -> Pattern a -> Pattern a)
-> Pattern Rational
-> Pattern Rational
-> 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 c. ((a, b) -> c) -> a -> b -> c
curry (Rational, Rational) -> Pattern a -> Pattern a
forall a. (Rational, Rational) -> Pattern a -> Pattern a
zoom

zoomArc :: Arc -> Pattern a -> Pattern a
zoomArc :: forall a. ArcF Rational -> Pattern a -> Pattern a
zoomArc (Arc Rational
s Rational
e) Pattern a
p
  | Rational
s Rational -> Rational -> Bool
forall a. Ord a => a -> a -> Bool
>= Rational
e = Pattern a
forall a. Pattern a
nothing
  | Bool
otherwise =
      (Rational -> Rational) -> Pattern a -> Pattern a
forall a. (Rational -> Rational) -> Pattern a -> Pattern a
withTactus (Rational -> Rational -> Rational
forall a. Num a => a -> a -> a
* Rational
d) (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
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
e Rational -> 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
patternify 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
patternify 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"