{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TemplateHaskell #-}

module Sound.Tidal.Parse (parseTidal) where

import Control.Applicative (Alternative (empty, (<|>)))
import Control.Monad.Except (MonadError (throwError))
import Data.Bifunctor (Bifunctor (bimap))
import Data.Char (isSpace)
import Data.List (dropWhileEnd)
import qualified Data.Text
import Language.Haskellish as Haskellish
import Sound.Tidal.Chords as T
import Sound.Tidal.Control as T
import Sound.Tidal.Core as T
import Sound.Tidal.Params as T
import Sound.Tidal.Parse.TH
  ( fromHaskell,
    fromTidal,
    fromTidalList,
  )
import Sound.Tidal.ParseBP (Enumerable, Parseable, parseBP)
import Sound.Tidal.Pattern as T
import Sound.Tidal.Scales as T (scale)
import Sound.Tidal.Simple as T (silent)
import Sound.Tidal.UI as T

type H = Haskellish ()

-- This is depended upon by Estuary, and changes to its type will cause problems downstream for Estuary.
parseTidal :: String -> Either String ControlPattern
parseTidal :: [Char] -> Either [Char] (Pattern ValueMap)
parseTidal [Char]
x = if [Char] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Char]
x' then Pattern ValueMap -> Either [Char] (Pattern ValueMap)
forall a. a -> Either [Char] a
forall (m :: * -> *) a. Monad m => a -> m a
return Pattern ValueMap
forall a. Pattern a
silence else Either [Char] (Pattern ValueMap)
r
  where
    x' :: [Char]
x' = (Char -> Bool) -> [Char] -> [Char]
forall a. (a -> Bool) -> [a] -> [a]
dropWhileEnd Char -> Bool
isSpace ([Char] -> [Char]) -> [Char] -> [Char]
forall a b. (a -> b) -> a -> b
$ (Char -> Bool) -> [Char] -> [Char]
forall a. (a -> Bool) -> [a] -> [a]
dropWhile Char -> Bool
isSpace ([Char] -> [Char]) -> [Char] -> [Char]
forall a b. (a -> b) -> a -> b
$ [Char] -> [Char]
Haskellish.removeComments [Char]
x
    r :: Either [Char] (Pattern ValueMap)
r = ((Span, Text) -> [Char])
-> ((Pattern ValueMap, ()) -> Pattern ValueMap)
-> Either (Span, Text) (Pattern ValueMap, ())
-> Either [Char] (Pattern ValueMap)
forall a b c d. (a -> b) -> (c -> d) -> Either a c -> Either b d
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap (Span, Text) -> [Char]
showSyntaxError (Pattern ValueMap, ()) -> Pattern ValueMap
forall a b. (a, b) -> a
fst (Either (Span, Text) (Pattern ValueMap, ())
 -> Either [Char] (Pattern ValueMap))
-> Either (Span, Text) (Pattern ValueMap, ())
-> Either [Char] (Pattern ValueMap)
forall a b. (a -> b) -> a -> b
$ Haskellish () (Pattern ValueMap)
-> () -> [Char] -> Either (Span, Text) (Pattern ValueMap, ())
forall st a.
Haskellish st a -> st -> [Char] -> Either (Span, Text) (a, st)
Haskellish.parseAndRun Haskellish () (Pattern ValueMap)
forall a. Parse a => H a
parser () [Char]
x

showSyntaxError :: (Span, Data.Text.Text) -> String
showSyntaxError :: (Span, Text) -> [Char]
showSyntaxError (((Int
lineNumber, Int
columnNumber), (Int
_, Int
_)), Text
msg) =
  Int -> [Char]
forall a. Show a => a -> [Char]
show Int
lineNumber [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
":" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
columnNumber [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
Data.Text.unpack Text
msg

-- The class Parse is a class for all of the types that we know how to parse.
-- For each type, we provide all the ways we can think of producing that type
-- via expressions in Parse.

class Parse a where
  parser :: H a

instance Parse Bool where
  parser :: H Bool
parser = (Bool
True Bool -> Haskellish () () -> H Bool
forall a b. a -> Haskellish () b -> Haskellish () a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ [Char] -> Haskellish () ()
forall st. [Char] -> Haskellish st ()
reserved [Char]
"True") H Bool -> H Bool -> H Bool
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Bool
False Bool -> Haskellish () () -> H Bool
forall a b. a -> Haskellish () b -> Haskellish () a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ [Char] -> Haskellish () ()
forall st. [Char] -> Haskellish st ()
reserved [Char]
"False") H Bool -> Text -> H Bool
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected literal Bool"

instance Parse Int where
  parser :: H Int
parser = (Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Int) -> Haskellish () Integer -> H Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Haskellish () Integer
forall st. Haskellish st Integer
integer) H Int -> Text -> H Int
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected literal Int"

instance Parse Integer where
  parser :: Haskellish () Integer
parser = Haskellish () Integer
forall st. Haskellish st Integer
integer Haskellish () Integer -> Text -> Haskellish () Integer
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected literal Integer"

instance Parse Time where
  parser :: H Time
parser = (Integer -> Time
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Time) -> Haskellish () Integer -> H Time
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Haskellish () Integer
forall st. Haskellish st Integer
integer) H Time -> H Time -> H Time
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H Time
forall st. Haskellish st Time
rational H Time -> Text -> H Time
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected literal Time"

instance Parse Double where
  parser :: H Double
parser = (Integer -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Double) -> Haskellish () Integer -> H Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Haskellish () Integer
forall st. Haskellish st Integer
integer) H Double -> H Double -> H Double
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Time -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac (Time -> Double) -> H Time -> H Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> H Time
forall st. Haskellish st Time
rational) H Double -> Text -> H Double
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected literal Double"

instance Parse Note where
  parser :: H Note
parser = (Double -> Note
Note (Double -> Note) -> (Integer -> Double) -> Integer -> Note
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Note) -> Haskellish () Integer -> H Note
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Haskellish () Integer
forall st. Haskellish st Integer
integer) H Note -> H Note -> H Note
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Double -> Note
Note (Double -> Note) -> (Time -> Double) -> Time -> Note
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Time -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac (Time -> Note) -> H Time -> H Note
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> H Time
forall st. Haskellish st Time
rational) H Note -> Text -> H Note
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected literal Note"

instance Parse String where
  parser :: H [Char]
parser =
    H [Char]
forall st. Haskellish st [Char]
string
      H [Char] -> H [Char] -> H [Char]
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H ([Char] -> [Char])
forall a. Parse a => H a
parser :: H (String -> String))
        H ([Char] -> [Char]) -> H [Char] -> H [Char]
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H [Char]
forall a. Parse a => H a
parser
        H [Char] -> Text -> H [Char]
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected String"

instance (Parse a, Parse b) => Parse (a, b) where
  parser :: H (a, b)
parser = Haskellish () a -> Haskellish () b -> H (a, b)
forall st a b.
Haskellish st a -> Haskellish st b -> Haskellish st (a, b)
Haskellish.tuple Haskellish () a
forall a. Parse a => H a
parser Haskellish () b
forall a. Parse a => H a
parser

-- Parse instances for lists of things
-- for Num types we define the common pathway numList that includes chords
-- then for other types we default to just parsing "literal" lists [a,a,...]

instance Parse [Int] where parser :: H [Int]
parser = H [Int]
forall a. (Parse a, Num a) => H [a]
numList

instance Parse [Integer] where parser :: H [Integer]
parser = H [Integer]
forall a. (Parse a, Num a) => H [a]
numList

instance Parse [Time] where parser :: H [Time]
parser = H [Time]
forall a. (Parse a, Num a) => H [a]
numList

instance Parse [Double] where parser :: H [Double]
parser = H [Double]
forall a. (Parse a, Num a) => H [a]
numList

instance Parse [Note] where parser :: H [Note]
parser = H [Note]
forall a. (Parse a, Num a) => H [a]
numList

instance {-# OVERLAPPABLE #-} (Parse a) => Parse [a] where parser :: H [a]
parser = Haskellish () a -> H [a]
forall st a. Haskellish st a -> Haskellish st [a]
list Haskellish () a
forall a. Parse a => H a
parser

numList :: (Parse a, Num a) => H [a]
numList :: forall a. (Parse a, Num a) => H [a]
numList = Haskellish () a -> Haskellish () [a]
forall st a. Haskellish st a -> Haskellish st [a]
list Haskellish () a
forall a. Parse a => H a
parser Haskellish () [a] -> Haskellish () [a] -> Haskellish () [a]
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Haskellish () [a]
forall a. Num a => H [a]
chords

chords :: (Num a) => H [a]
chords :: forall a. Num a => H [a]
chords =
  $( fromTidalList
       [ "major",
         "aug",
         "six",
         "sixNine",
         "major7",
         "major9",
         "add9",
         "major11",
         "add11",
         "major13",
         "add13",
         "dom7",
         "dom9",
         "dom11",
         "dom13",
         "sevenFlat5",
         "sevenSharp5",
         "sevenFlat9",
         "nine",
         "eleven",
         "thirteen",
         "minor",
         "diminished",
         "minorSharp5",
         "minor6",
         "minorSixNine",
         "minor7flat5",
         "minor7",
         "minor7sharp5",
         "minor7flat9",
         "minor7sharp9",
         "diminished7",
         "minor9",
         "minor11",
         "minor13",
         "one",
         "five",
         "sus2",
         "sus4",
         "sevenSus2",
         "sevenSus4",
         "nineSus4",
         "sevenFlat10",
         "nineSharp5",
         "minor9sharp5",
         "sevenSharp5flat9",
         "minor7sharp5flat9",
         "elevenSharp",
         "minor11sharp"
       ]
   )

instance Parse ValueMap where
  parser :: H ValueMap
parser = H ValueMap
forall a. Haskellish () a
forall (f :: * -> *) a. Alternative f => f a
Control.Applicative.empty

instance Parse ControlPattern where
  parser :: Haskellish () (Pattern ValueMap)
parser =
    (H (Pattern [Char] -> Pattern ValueMap)
forall a. Parse a => H a
parser :: H (Pattern String -> ControlPattern)) H (Pattern [Char] -> Pattern ValueMap)
-> Haskellish () (Pattern [Char])
-> Haskellish () (Pattern ValueMap)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern [Char])
forall a. Parse a => H a
parser
      Haskellish () (Pattern ValueMap)
-> Haskellish () (Pattern ValueMap)
-> Haskellish () (Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern Double -> Pattern ValueMap)
forall a. Parse a => H a
parser :: H (Pattern Double -> ControlPattern)) H (Pattern Double -> Pattern ValueMap)
-> Haskellish () (Pattern Double)
-> Haskellish () (Pattern ValueMap)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Double)
forall a. Parse a => H a
parser
      Haskellish () (Pattern ValueMap)
-> Haskellish () (Pattern ValueMap)
-> Haskellish () (Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern Note -> Pattern ValueMap)
forall a. Parse a => H a
parser :: H (Pattern Note -> ControlPattern)) H (Pattern Note -> Pattern ValueMap)
-> Haskellish () (Pattern Note) -> Haskellish () (Pattern ValueMap)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Note)
forall a. Parse a => H a
parser
      Haskellish () (Pattern ValueMap)
-> Haskellish () (Pattern ValueMap)
-> Haskellish () (Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern Int -> Pattern ValueMap)
forall a. Parse a => H a
parser :: H (Pattern Int -> ControlPattern)) H (Pattern Int -> Pattern ValueMap)
-> Haskellish () (Pattern Int) -> Haskellish () (Pattern ValueMap)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Int)
forall a. Parse a => H a
parser
      Haskellish () (Pattern ValueMap)
-> Haskellish () (Pattern ValueMap)
-> Haskellish () (Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H ([Pattern ValueMap] -> Pattern ValueMap)
listCp_cp H ([Pattern ValueMap] -> Pattern ValueMap)
-> Haskellish () [Pattern ValueMap]
-> Haskellish () (Pattern ValueMap)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () [Pattern ValueMap]
forall a. Parse a => H a
parser
      Haskellish () (Pattern ValueMap)
-> Haskellish () (Pattern ValueMap)
-> Haskellish () (Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Haskellish () (Pattern ValueMap)
forall a.
(Parse a, Parse (Pattern a), Parse (Pattern a -> Pattern a),
 Parse [a]) =>
H (Pattern a)
genericPatternExpressions
        Haskellish () (Pattern ValueMap)
-> Text -> Haskellish () (Pattern ValueMap)
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected ControlPattern"

genericPatternExpressions :: forall a. (Parse a, Parse (Pattern a), Parse (Pattern a -> Pattern a), Parse [a]) => H (Pattern a)
genericPatternExpressions :: forall a.
(Parse a, Parse (Pattern a), Parse (Pattern a -> Pattern a),
 Parse [a]) =>
H (Pattern a)
genericPatternExpressions =
  (H (Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H (Pattern a -> Pattern a)) H (Pattern a -> Pattern a)
-> Haskellish () (Pattern a) -> Haskellish () (Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern a)
forall a. Parse a => H a
parser
    Haskellish () (Pattern a)
-> Haskellish () (Pattern a) -> Haskellish () (Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H ([a] -> Pattern a)
forall a. Parse a => H a
parser :: H ([a] -> Pattern a)) H ([a] -> Pattern a)
-> Haskellish () [a] -> Haskellish () (Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () [a]
forall a. Parse a => H a
parser
    Haskellish () (Pattern a)
-> Haskellish () (Pattern a) -> Haskellish () (Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H ([Pattern a] -> Pattern a)
forall a. Parse a => H a
parser :: H ([Pattern a] -> Pattern a)) H ([Pattern a] -> Pattern a)
-> Haskellish () [Pattern a] -> Haskellish () (Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () [Pattern a]
forall a. Parse a => H a
parser
    Haskellish () (Pattern a)
-> Haskellish () (Pattern a) -> Haskellish () (Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H ([(Pattern a, Pattern Double)] -> Pattern a)
forall a. Parse a => H a
parser :: H ([(Pattern a, Pattern Double)] -> Pattern a)) H ([(Pattern a, Pattern Double)] -> Pattern a)
-> Haskellish () [(Pattern a, Pattern Double)]
-> Haskellish () (Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () [(Pattern a, Pattern Double)]
forall a. Parse a => H a
parser
    Haskellish () (Pattern a)
-> Haskellish () (Pattern a) -> Haskellish () (Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H ([Pattern a -> Pattern a] -> Pattern a)
forall a. Parse a => H a
parser :: H ([Pattern a -> Pattern a] -> Pattern a)) H ([Pattern a -> Pattern a] -> Pattern a)
-> Haskellish () [Pattern a -> Pattern a]
-> Haskellish () (Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () [Pattern a -> Pattern a]
forall a. Parse a => H a
parser
    Haskellish () (Pattern a)
-> Haskellish () (Pattern a) -> Haskellish () (Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H ([(Time, Pattern a)] -> Pattern a)
forall a. Parse a => H a
parser :: H ([(Time, Pattern a)] -> Pattern a)) H ([(Time, Pattern a)] -> Pattern a)
-> Haskellish () [(Time, Pattern a)] -> Haskellish () (Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () [(Time, Pattern a)]
forall a. Parse a => H a
parser
    Haskellish () (Pattern a)
-> Haskellish () (Pattern a) -> Haskellish () (Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Int -> Pattern a)
forall a. Parse [a] => H (Pattern Int -> Pattern a)
pInt_p H (Pattern Int -> Pattern a)
-> Haskellish () (Pattern Int) -> Haskellish () (Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Int)
forall a. Parse a => H a
parser
    Haskellish () (Pattern a)
-> Haskellish () (Pattern a) -> Haskellish () (Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H ([a] -> Pattern a)
forall a. Parse a => H ([a] -> Pattern a)
list_p H ([a] -> Pattern a)
-> Haskellish () [a] -> Haskellish () (Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () [a]
forall a. Parse a => H a
parser
    Haskellish () (Pattern a)
-> Haskellish () (Pattern a) -> Haskellish () (Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H ([(a, Pattern Double)] -> Pattern a)
forall a. Parse a => H ([(a, Pattern Double)] -> Pattern a)
tupleApDouble_p H ([(a, Pattern Double)] -> Pattern a)
-> Haskellish () [(a, Pattern Double)] -> Haskellish () (Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () [(a, Pattern Double)]
forall a. Parse a => H a
parser
    Haskellish () (Pattern a)
-> Haskellish () (Pattern a) -> Haskellish () (Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H ([([Char], Pattern a -> Pattern a)] -> Pattern a)
forall a.
(Parse (Pattern a), Parse (Pattern a -> Pattern a)) =>
H ([([Char], Pattern a -> Pattern a)] -> Pattern a)
listTupleStringTransformation_p H ([([Char], Pattern a -> Pattern a)] -> Pattern a)
-> Haskellish () [([Char], Pattern a -> Pattern a)]
-> Haskellish () (Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () [([Char], Pattern a -> Pattern a)]
forall a. Parse a => H a
parser
    Haskellish () (Pattern a)
-> Haskellish () (Pattern a) -> Haskellish () (Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Haskellish () (Pattern a)
forall a. H (Pattern a)
parseSilence

listTupleStringTransformation_p :: forall a. (Parse (Pattern a), Parse (Pattern a -> Pattern a)) => H ([(String, Pattern a -> Pattern a)] -> Pattern a)
listTupleStringTransformation_p :: forall a.
(Parse (Pattern a), Parse (Pattern a -> Pattern a)) =>
H ([([Char], Pattern a -> Pattern a)] -> Pattern a)
listTupleStringTransformation_p = H ([([Char], Pattern a)]
   -> [([Char], Pattern a -> Pattern a)] -> Pattern a)
forall a.
H ([([Char], Pattern a)]
   -> [([Char], Pattern a -> Pattern a)] -> Pattern a)
listTupleStringPattern_listTupleStringTransformation_p H ([([Char], Pattern a)]
   -> [([Char], Pattern a -> Pattern a)] -> Pattern a)
-> Haskellish () [([Char], Pattern a)]
-> Haskellish () ([([Char], Pattern a -> Pattern a)] -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () [([Char], Pattern a)]
forall a. Parse a => H a
parser

listTupleStringPattern_listTupleStringTransformation_p :: H ([(String, Pattern a)] -> [(String, Pattern a -> Pattern a)] -> Pattern a)
listTupleStringPattern_listTupleStringTransformation_p :: forall a.
H ([([Char], Pattern a)]
   -> [([Char], Pattern a -> Pattern a)] -> Pattern a)
listTupleStringPattern_listTupleStringTransformation_p = H (Pattern [Char]
   -> [([Char], Pattern a)]
   -> [([Char], Pattern a -> Pattern a)]
   -> Pattern a)
forall a.
H (Pattern [Char]
   -> [([Char], Pattern a)]
   -> [([Char], Pattern a -> Pattern a)]
   -> Pattern a)
pString_listTupleStringPattern_listTupleStringTransformation_p H (Pattern [Char]
   -> [([Char], Pattern a)]
   -> [([Char], Pattern a -> Pattern a)]
   -> Pattern a)
-> Haskellish () (Pattern [Char])
-> Haskellish
     ()
     ([([Char], Pattern a)]
      -> [([Char], Pattern a -> Pattern a)] -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern [Char])
forall a. Parse a => H a
parser

pString_listTupleStringPattern_listTupleStringTransformation_p :: H (Pattern String -> [(String, Pattern a)] -> [(String, Pattern a -> Pattern a)] -> Pattern a)
pString_listTupleStringPattern_listTupleStringTransformation_p :: forall a.
H (Pattern [Char]
   -> [([Char], Pattern a)]
   -> [([Char], Pattern a -> Pattern a)]
   -> Pattern a)
pString_listTupleStringPattern_listTupleStringTransformation_p = H (Time
   -> Pattern [Char]
   -> [([Char], Pattern a)]
   -> [([Char], Pattern a -> Pattern a)]
   -> Pattern a)
forall a.
H (Time
   -> Pattern [Char]
   -> [([Char], Pattern a)]
   -> [([Char], Pattern a -> Pattern a)]
   -> Pattern a)
time_pString_listTupleStringPattern_listTupleStringTransformation_p H (Time
   -> Pattern [Char]
   -> [([Char], Pattern a)]
   -> [([Char], Pattern a -> Pattern a)]
   -> Pattern a)
-> H Time
-> Haskellish
     ()
     (Pattern [Char]
      -> [([Char], Pattern a)]
      -> [([Char], Pattern a -> Pattern a)]
      -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H Time
forall a. Parse a => H a
parser

time_pString_listTupleStringPattern_listTupleStringTransformation_p :: H (Time -> Pattern String -> [(String, Pattern a)] -> [(String, Pattern a -> Pattern a)] -> Pattern a)
time_pString_listTupleStringPattern_listTupleStringTransformation_p :: forall a.
H (Time
   -> Pattern [Char]
   -> [([Char], Pattern a)]
   -> [([Char], Pattern a -> Pattern a)]
   -> Pattern a)
time_pString_listTupleStringPattern_listTupleStringTransformation_p = $(fromTidal "ur")

numPatternExpressions :: (Num a, Parse a, Parse [a]) => H (Pattern a)
numPatternExpressions :: forall a. (Num a, Parse a, Parse [a]) => H (Pattern a)
numPatternExpressions =
  $(fromTidal "irand") Haskellish () (Pattern Int -> Pattern a)
-> Haskellish () (Pattern Int) -> Haskellish () (Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Int)
forall a. Parse a => H a
parser
    Haskellish () (Pattern a)
-> Haskellish () (Pattern a) -> Haskellish () (Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Haskellish () (Pattern Int -> Pattern a)
forall a. (Num a, Parse [a]) => H (Pattern Int -> Pattern a)
pInt_pNumA Haskellish () (Pattern Int -> Pattern a)
-> Haskellish () (Pattern Int) -> Haskellish () (Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Int)
forall a. Parse a => H a
parser

fractionalPatternExpressions :: (Fractional a) => H (Pattern a)
fractionalPatternExpressions :: forall a. Fractional a => H (Pattern a)
fractionalPatternExpressions =
  $(fromTidal "rand")
    Haskellish () (Pattern a)
-> Haskellish () (Pattern a) -> Haskellish () (Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "perlin")
    Haskellish () (Pattern a)
-> Haskellish () (Pattern a) -> Haskellish () (Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Int -> Pattern a)
forall a. Fractional a => H (Pattern Int -> Pattern a)
pInt_pFractionalA H (Pattern Int -> Pattern a)
-> Haskellish () (Pattern Int) -> Haskellish () (Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Int)
forall a. Parse a => H a
parser
    Haskellish () (Pattern a)
-> Haskellish () (Pattern a) -> Haskellish () (Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Double -> Pattern a)
forall a. Fractional a => H (Pattern Double -> Pattern a)
pDouble_pFractionalA H (Pattern Double -> Pattern a)
-> Haskellish () (Pattern Double) -> Haskellish () (Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Double)
forall a. Parse a => H a
parser

parseSilence :: H (Pattern a)
parseSilence :: forall a. H (Pattern a)
parseSilence = $(fromTidal "silence") -- ie. silence <$ reserved "silence", see Sound.Tidal.Parse.TH

instance Parse (Pattern Bool) where
  parser :: H (Pattern Bool)
parser =
    H (Pattern Bool)
forall a. (Enumerable a, Parseable a) => H (Pattern a)
haskellishParseBP
      H (Pattern Bool) -> H (Pattern Bool) -> H (Pattern Bool)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern [Char] -> Pattern Bool)
forall a. Parse a => H a
parser :: H (Pattern String -> Pattern Bool)) H (Pattern [Char] -> Pattern Bool)
-> Haskellish () (Pattern [Char]) -> H (Pattern Bool)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern [Char])
forall a. Parse a => H a
parser
      H (Pattern Bool) -> H (Pattern Bool) -> H (Pattern Bool)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern Int -> Pattern Bool)
forall a. Parse a => H a
parser :: H (Pattern Int -> Pattern Bool)) H (Pattern Int -> Pattern Bool)
-> Haskellish () (Pattern Int) -> H (Pattern Bool)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Int)
forall a. Parse a => H a
parser
      H (Pattern Bool) -> H (Pattern Bool) -> H (Pattern Bool)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Bool)
forall a.
(Parse a, Parse (Pattern a), Parse (Pattern a -> Pattern a),
 Parse [a]) =>
H (Pattern a)
genericPatternExpressions
        H (Pattern Bool) -> Text -> H (Pattern Bool)
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected Pattern Bool"

instance Parse (Pattern String) where
  parser :: Haskellish () (Pattern [Char])
parser =
    Haskellish () (Pattern [Char])
forall a. (Enumerable a, Parseable a) => H (Pattern a)
haskellishParseBP
      Haskellish () (Pattern [Char])
-> Haskellish () (Pattern [Char]) -> Haskellish () (Pattern [Char])
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Haskellish () (Pattern [Char])
forall a.
(Parse a, Parse (Pattern a), Parse (Pattern a -> Pattern a),
 Parse [a]) =>
H (Pattern a)
genericPatternExpressions
      Haskellish () (Pattern [Char])
-> Haskellish () (Pattern [Char]) -> Haskellish () (Pattern [Char])
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern Int -> Pattern [Char])
forall a. Parse a => H a
parser :: H (Pattern Int -> Pattern String)) H (Pattern Int -> Pattern [Char])
-> Haskellish () (Pattern Int) -> Haskellish () (Pattern [Char])
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Int)
forall a. Parse a => H a
parser
      Haskellish () (Pattern [Char])
-> Haskellish () (Pattern [Char]) -> Haskellish () (Pattern [Char])
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H ([Char] -> Pattern [Char])
forall a. Parse a => H a
parser :: H (String -> Pattern String)) H ([Char] -> Pattern [Char])
-> H [Char] -> Haskellish () (Pattern [Char])
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H [Char]
forall a. Parse a => H a
parser
      Haskellish () (Pattern [Char])
-> Haskellish () (Pattern [Char]) -> Haskellish () (Pattern [Char])
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H ([([Char], [Char])] -> Pattern [Char])
forall a. Parse a => H a
parser :: H ([(String, String)] -> Pattern String))
        H ([([Char], [Char])] -> Pattern [Char])
-> Haskellish () [([Char], [Char])]
-> Haskellish () (Pattern [Char])
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () [([Char], [Char])]
forall a. Parse a => H a
parser
        Haskellish () (Pattern [Char])
-> Text -> Haskellish () (Pattern [Char])
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected Pattern String"

haskellishParseBP :: (Enumerable a, Parseable a) => H (Pattern a)
haskellishParseBP :: forall a. (Enumerable a, Parseable a) => H (Pattern a)
haskellishParseBP = do
  ((Int, Int)
b, (Int, Int)
_) <- Haskellish () Span
forall st. Haskellish st Span
Haskellish.span
  Either ParseError (Pattern a)
p <- [Char] -> Either ParseError (Pattern a)
forall a.
(Enumerable a, Parseable a) =>
[Char] -> Either ParseError (Pattern a)
parseBP ([Char] -> Either ParseError (Pattern a))
-> H [Char] -> Haskellish () (Either ParseError (Pattern a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> H [Char]
forall st. Haskellish st [Char]
string
  case Either ParseError (Pattern a)
p of
    Left ParseError
e -> Text -> H (Pattern a)
forall a. Text -> Haskellish () a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> H (Pattern a)) -> Text -> H (Pattern a)
forall a b. (a -> b) -> a -> b
$ [Char] -> Text
Data.Text.pack ([Char] -> Text) -> [Char] -> Text
forall a b. (a -> b) -> a -> b
$ ParseError -> [Char]
forall a. Show a => a -> [Char]
show ParseError
e
    Right Pattern a
p' -> do
      Pattern a -> H (Pattern a)
forall a. a -> Haskellish () a
forall (m :: * -> *) a. Monad m => a -> m a
return (Pattern a -> H (Pattern a)) -> Pattern a -> H (Pattern a)
forall a b. (a -> b) -> a -> b
$ (Context -> Context) -> Pattern a -> Pattern a
forall a. (Context -> Context) -> Pattern a -> Pattern a
withContext ((Int, Int) -> Context -> Context
updateContext (Int, Int)
b) Pattern a
p'
      where
        updateContext :: (Int, Int) -> Context -> Context
updateContext (Int
dx, Int
dy) c :: Context
c@Context {contextPosition :: Context -> [Span]
contextPosition = [Span]
poss} =
          Context
c {contextPosition = map (\((Int
bx, Int
by), (Int
ex, Int
ey)) -> ((Int
bx Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
dx, Int
by Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
dy), (Int
ex Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
dx, Int
ey Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
dy))) poss}

instance Parse (Pattern Int) where
  parser :: Haskellish () (Pattern Int)
parser =
    Int -> Pattern Int
forall a. a -> Pattern a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int -> Pattern Int) -> (Integer -> Int) -> Integer -> Pattern Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Pattern Int)
-> Haskellish () Integer -> Haskellish () (Pattern Int)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Haskellish () Integer
forall st. Haskellish st Integer
integer
      Haskellish () (Pattern Int)
-> Haskellish () (Pattern Int) -> Haskellish () (Pattern Int)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Haskellish () (Pattern Int)
forall a. (Enumerable a, Parseable a) => H (Pattern a)
haskellishParseBP
      Haskellish () (Pattern Int)
-> Haskellish () (Pattern Int) -> Haskellish () (Pattern Int)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Haskellish () (Pattern Int)
forall a.
(Parse a, Parse (Pattern a), Parse (Pattern a -> Pattern a),
 Parse [a]) =>
H (Pattern a)
genericPatternExpressions
      Haskellish () (Pattern Int)
-> Haskellish () (Pattern Int) -> Haskellish () (Pattern Int)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Haskellish () (Pattern Int)
forall a. (Num a, Parse a, Parse [a]) => H (Pattern a)
numPatternExpressions
        Haskellish () (Pattern Int) -> Text -> Haskellish () (Pattern Int)
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected Pattern Int"

instance Parse (Pattern Integer) where
  parser :: H (Pattern Integer)
parser =
    Integer -> Pattern Integer
forall a. a -> Pattern a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Integer -> Pattern Integer)
-> Haskellish () Integer -> H (Pattern Integer)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Haskellish () Integer
forall st. Haskellish st Integer
integer
      H (Pattern Integer) -> H (Pattern Integer) -> H (Pattern Integer)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Integer)
forall a. (Enumerable a, Parseable a) => H (Pattern a)
haskellishParseBP
      H (Pattern Integer) -> H (Pattern Integer) -> H (Pattern Integer)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Integer)
forall a.
(Parse a, Parse (Pattern a), Parse (Pattern a -> Pattern a),
 Parse [a]) =>
H (Pattern a)
genericPatternExpressions
      H (Pattern Integer) -> H (Pattern Integer) -> H (Pattern Integer)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Integer)
forall a. (Num a, Parse a, Parse [a]) => H (Pattern a)
numPatternExpressions
        H (Pattern Integer) -> Text -> H (Pattern Integer)
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected Pattern Integer"

instance Parse (Pattern Double) where
  parser :: Haskellish () (Pattern Double)
parser =
    Double -> Pattern Double
forall a. a -> Pattern a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Double -> Pattern Double)
-> (Integer -> Double) -> Integer -> Pattern Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Pattern Double)
-> Haskellish () Integer -> Haskellish () (Pattern Double)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Haskellish () Integer
forall st. Haskellish st Integer
integer
      Haskellish () (Pattern Double)
-> Haskellish () (Pattern Double) -> Haskellish () (Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Double -> Pattern Double
forall a. a -> Pattern a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Double -> Pattern Double)
-> (Time -> Double) -> Time -> Pattern Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Time -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac (Time -> Pattern Double)
-> H Time -> Haskellish () (Pattern Double)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> H Time
forall st. Haskellish st Time
rational
      Haskellish () (Pattern Double)
-> Haskellish () (Pattern Double) -> Haskellish () (Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Haskellish () (Pattern Double)
forall a. (Enumerable a, Parseable a) => H (Pattern a)
haskellishParseBP
      Haskellish () (Pattern Double)
-> Haskellish () (Pattern Double) -> Haskellish () (Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Haskellish () (Pattern Double)
forall a.
(Parse a, Parse (Pattern a), Parse (Pattern a -> Pattern a),
 Parse [a]) =>
H (Pattern a)
genericPatternExpressions
      Haskellish () (Pattern Double)
-> Haskellish () (Pattern Double) -> Haskellish () (Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Haskellish () (Pattern Double)
forall a. (Num a, Parse a, Parse [a]) => H (Pattern a)
numPatternExpressions
      Haskellish () (Pattern Double)
-> Haskellish () (Pattern Double) -> Haskellish () (Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Haskellish () (Pattern Double)
forall a. Fractional a => H (Pattern a)
fractionalPatternExpressions
      Haskellish () (Pattern Double)
-> Haskellish () (Pattern Double) -> Haskellish () (Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "sine")
      Haskellish () (Pattern Double)
-> Haskellish () (Pattern Double) -> Haskellish () (Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "saw")
      Haskellish () (Pattern Double)
-> Haskellish () (Pattern Double) -> Haskellish () (Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "isaw")
      Haskellish () (Pattern Double)
-> Haskellish () (Pattern Double) -> Haskellish () (Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "tri")
      Haskellish () (Pattern Double)
-> Haskellish () (Pattern Double) -> Haskellish () (Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "square")
      Haskellish () (Pattern Double)
-> Haskellish () (Pattern Double) -> Haskellish () (Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "cosine")
      Haskellish () (Pattern Double)
-> Haskellish () (Pattern Double) -> Haskellish () (Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "envEq")
      Haskellish () (Pattern Double)
-> Haskellish () (Pattern Double) -> Haskellish () (Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "envEqR")
      Haskellish () (Pattern Double)
-> Haskellish () (Pattern Double) -> Haskellish () (Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "envL")
      Haskellish () (Pattern Double)
-> Haskellish () (Pattern Double) -> Haskellish () (Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "envLR")
      Haskellish () (Pattern Double)
-> Haskellish () (Pattern Double) -> Haskellish () (Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H ([Char] -> Pattern Double)
forall a. Parse a => H a
parser :: H (String -> Pattern Double)) H ([Char] -> Pattern Double)
-> H [Char] -> Haskellish () (Pattern Double)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H [Char]
forall a. Parse a => H a
parser
      Haskellish () (Pattern Double)
-> Haskellish () (Pattern Double) -> Haskellish () (Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidalList (fmap (\x -> "in" ++ show x) ([0 .. 127] :: [Int])))
        Haskellish () (Pattern Double)
-> Text -> Haskellish () (Pattern Double)
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected Pattern Double"

instance Parse (Pattern Note) where
  parser :: Haskellish () (Pattern Note)
parser =
    Note -> Pattern Note
forall a. a -> Pattern a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Note -> Pattern Note)
-> (Integer -> Note) -> Integer -> Pattern Note
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Note
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Pattern Note)
-> Haskellish () Integer -> Haskellish () (Pattern Note)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Haskellish () Integer
forall st. Haskellish st Integer
integer
      Haskellish () (Pattern Note)
-> Haskellish () (Pattern Note) -> Haskellish () (Pattern Note)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Note -> Pattern Note
forall a. a -> Pattern a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Note -> Pattern Note) -> (Time -> Note) -> Time -> Pattern Note
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Time -> Note
forall a b. (Real a, Fractional b) => a -> b
realToFrac (Time -> Pattern Note) -> H Time -> Haskellish () (Pattern Note)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> H Time
forall st. Haskellish st Time
rational
      Haskellish () (Pattern Note)
-> Haskellish () (Pattern Note) -> Haskellish () (Pattern Note)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Haskellish () (Pattern Note)
forall a. (Enumerable a, Parseable a) => H (Pattern a)
haskellishParseBP
      Haskellish () (Pattern Note)
-> Haskellish () (Pattern Note) -> Haskellish () (Pattern Note)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Haskellish () (Pattern Note)
forall a.
(Parse a, Parse (Pattern a), Parse (Pattern a -> Pattern a),
 Parse [a]) =>
H (Pattern a)
genericPatternExpressions
      Haskellish () (Pattern Note)
-> Haskellish () (Pattern Note) -> Haskellish () (Pattern Note)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Haskellish () (Pattern Note)
forall a. (Num a, Parse a, Parse [a]) => H (Pattern a)
numPatternExpressions
      Haskellish () (Pattern Note)
-> Haskellish () (Pattern Note) -> Haskellish () (Pattern Note)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Haskellish () (Pattern Note)
forall a. Fractional a => H (Pattern a)
fractionalPatternExpressions
        Haskellish () (Pattern Note)
-> Text -> Haskellish () (Pattern Note)
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected Pattern Note"

instance Parse (Pattern Time) where
  parser :: H (Pattern Time)
parser =
    Time -> Pattern Time
forall a. a -> Pattern a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Time -> Pattern Time)
-> (Integer -> Time) -> Integer -> Pattern Time
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Time
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Pattern Time)
-> Haskellish () Integer -> H (Pattern Time)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Haskellish () Integer
forall st. Haskellish st Integer
integer
      H (Pattern Time) -> H (Pattern Time) -> H (Pattern Time)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Time -> Pattern Time
forall a. a -> Pattern a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Time -> Pattern Time) -> H Time -> H (Pattern Time)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> H Time
forall st. Haskellish st Time
rational
      H (Pattern Time) -> H (Pattern Time) -> H (Pattern Time)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Time)
forall a. (Enumerable a, Parseable a) => H (Pattern a)
haskellishParseBP
      H (Pattern Time) -> H (Pattern Time) -> H (Pattern Time)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Time)
forall a.
(Parse a, Parse (Pattern a), Parse (Pattern a -> Pattern a),
 Parse [a]) =>
H (Pattern a)
genericPatternExpressions
      H (Pattern Time) -> H (Pattern Time) -> H (Pattern Time)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Time)
forall a. (Num a, Parse a, Parse [a]) => H (Pattern a)
numPatternExpressions
      H (Pattern Time) -> H (Pattern Time) -> H (Pattern Time)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Time)
forall a. Fractional a => H (Pattern a)
fractionalPatternExpressions
        H (Pattern Time) -> Text -> H (Pattern Time)
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected Pattern Time"

-- * -> *

a_patternB :: forall a b. (Parse (a -> Pattern b)) => H (a -> Pattern b)
a_patternB :: forall a b. Parse (a -> Pattern b) => H (a -> Pattern b)
a_patternB = H ([a -> Pattern b] -> a -> Pattern b)
forall a b. H ([a -> Pattern b] -> a -> Pattern b)
listAtoPatternB_a_patternB H ([a -> Pattern b] -> a -> Pattern b)
-> Haskellish () [a -> Pattern b] -> Haskellish () (a -> Pattern b)
forall a b.
Haskellish () (a -> b) -> Haskellish () a -> Haskellish () b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Haskellish () [a -> Pattern b]
forall a. Parse a => H a
parser Haskellish () [a -> Pattern b]
-> Text -> Haskellish () [a -> Pattern b]
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected a -> Pattern b"

listAtoPatternB_a_patternB :: H ([a -> Pattern b] -> a -> Pattern b)
listAtoPatternB_a_patternB :: forall a b. H ([a -> Pattern b] -> a -> Pattern b)
listAtoPatternB_a_patternB =
  $(fromTidal "layer")
    Haskellish () ([a -> Pattern b] -> a -> Pattern b)
-> Haskellish () ([a -> Pattern b] -> a -> Pattern b)
-> Haskellish () ([a -> Pattern b] -> a -> Pattern b)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "spreadf")

{- -- a_patternB2 :: (Parse (a -> b -> Pattern c),Parse [a]) => H (b -> Pattern c)
-- a_patternB2 = return id
--listA_b_patternC <*!> parser <?> "expected a -> Pattern b"

-- listA_b_patternC :: forall a b c. Parse (a -> b -> Pattern c) => H ([a] -> b -> Pattern c)
listA_b_patternC = (parser :: H ((a -> b -> Pattern c) -> [a] -> b -> Pattern c)) <*!> parser
-}

instance Parse (ControlPattern -> ControlPattern) where
  parser :: H (Pattern ValueMap -> Pattern ValueMap)
parser =
    H (Pattern ValueMap -> Pattern ValueMap)
forall a.
(Parse (Pattern a), Parse (Pattern a -> Pattern a),
 Parse (Pattern a -> Pattern a -> Pattern a),
 Parse ((Pattern a -> Pattern a) -> Pattern a -> Pattern a),
 Parse ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)) =>
H (Pattern a -> Pattern a)
genericTransformations
      H (Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "ghost")
      H (Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "silent")
      H (Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
forall a. Parse a => H a
parser :: H (Pattern Int -> ControlPattern -> ControlPattern)) H (Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
-> Haskellish () (Pattern Int)
-> H (Pattern ValueMap -> Pattern ValueMap)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Int)
forall a. Parse a => H a
parser
      H (Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern Double -> Pattern ValueMap -> Pattern ValueMap)
forall a. Parse a => H a
parser :: H (Pattern Double -> ControlPattern -> ControlPattern)) H (Pattern Double -> Pattern ValueMap -> Pattern ValueMap)
-> Haskellish () (Pattern Double)
-> H (Pattern ValueMap -> Pattern ValueMap)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Double)
forall a. Parse a => H a
parser
      H (Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern Time -> Pattern ValueMap -> Pattern ValueMap)
forall a. Parse a => H a
parser :: H (Pattern Time -> ControlPattern -> ControlPattern))
        H (Pattern Time -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Time) -> H (Pattern ValueMap -> Pattern ValueMap)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H (Pattern Time)
forall a. Parse a => H a
parser
        -- lCpCp_cp_cp <*!> parser
        H (Pattern ValueMap -> Pattern ValueMap)
-> Text -> H (Pattern ValueMap -> Pattern ValueMap)
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected ControlPattern -> ControlPattern"

instance Parse (Pattern Bool -> Pattern Bool) where
  parser :: H (Pattern Bool -> Pattern Bool)
parser = H (Pattern Bool -> Pattern Bool)
forall a.
(Parse (Pattern a), Parse (Pattern a -> Pattern a),
 Parse (Pattern a -> Pattern a -> Pattern a),
 Parse ((Pattern a -> Pattern a) -> Pattern a -> Pattern a),
 Parse ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)) =>
H (Pattern a -> Pattern a)
genericTransformations H (Pattern Bool -> Pattern Bool)
-> H (Pattern Bool -> Pattern Bool)
-> H (Pattern Bool -> Pattern Bool)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Bool -> Pattern Bool)
forall a. Ord a => H (Pattern a -> Pattern a)
ordTransformations H (Pattern Bool -> Pattern Bool)
-> H (Pattern Bool -> Pattern Bool)
-> H (Pattern Bool -> Pattern Bool)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Bool -> Pattern Bool)
forall (f :: * -> *). Functor f => H (f Bool -> f Bool)
fBool_fBool H (Pattern Bool -> Pattern Bool)
-> Text -> H (Pattern Bool -> Pattern Bool)
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected Pattern Bool -> Pattern Bool"

instance Parse (Pattern String -> Pattern String) where
  parser :: H (Pattern [Char] -> Pattern [Char])
parser = H (Pattern [Char] -> Pattern [Char])
forall a.
(Parse (Pattern a), Parse (Pattern a -> Pattern a),
 Parse (Pattern a -> Pattern a -> Pattern a),
 Parse ((Pattern a -> Pattern a) -> Pattern a -> Pattern a),
 Parse ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)) =>
H (Pattern a -> Pattern a)
genericTransformations H (Pattern [Char] -> Pattern [Char])
-> H (Pattern [Char] -> Pattern [Char])
-> H (Pattern [Char] -> Pattern [Char])
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern [Char] -> Pattern [Char])
forall a. Ord a => H (Pattern a -> Pattern a)
ordTransformations H (Pattern [Char] -> Pattern [Char])
-> Text -> H (Pattern [Char] -> Pattern [Char])
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected Pattern String -> Pattern String"

instance Parse (Pattern Int -> Pattern Int) where
  parser :: H (Pattern Int -> Pattern Int)
parser = H (Pattern Int -> Pattern Int)
forall a.
(Parse (Pattern a), Parse (Pattern a -> Pattern a),
 Parse (Pattern a -> Pattern a -> Pattern a),
 Parse ((Pattern a -> Pattern a) -> Pattern a -> Pattern a),
 Parse ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)) =>
H (Pattern a -> Pattern a)
genericTransformations H (Pattern Int -> Pattern Int)
-> H (Pattern Int -> Pattern Int) -> H (Pattern Int -> Pattern Int)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Int -> Pattern Int)
forall a. (Num a, Enum a, Real a) => H (Pattern a -> Pattern a)
numTransformations H (Pattern Int -> Pattern Int)
-> H (Pattern Int -> Pattern Int) -> H (Pattern Int -> Pattern Int)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Int -> Pattern Int)
forall a. Ord a => H (Pattern a -> Pattern a)
ordTransformations H (Pattern Int -> Pattern Int)
-> Text -> H (Pattern Int -> Pattern Int)
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected Pattern Int -> Pattern Int"

instance Parse (Pattern Integer -> Pattern Integer) where
  parser :: H (Pattern Integer -> Pattern Integer)
parser = H (Pattern Integer -> Pattern Integer)
forall a.
(Parse (Pattern a), Parse (Pattern a -> Pattern a),
 Parse (Pattern a -> Pattern a -> Pattern a),
 Parse ((Pattern a -> Pattern a) -> Pattern a -> Pattern a),
 Parse ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)) =>
H (Pattern a -> Pattern a)
genericTransformations H (Pattern Integer -> Pattern Integer)
-> H (Pattern Integer -> Pattern Integer)
-> H (Pattern Integer -> Pattern Integer)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Integer -> Pattern Integer)
forall a. (Num a, Enum a, Real a) => H (Pattern a -> Pattern a)
numTransformations H (Pattern Integer -> Pattern Integer)
-> H (Pattern Integer -> Pattern Integer)
-> H (Pattern Integer -> Pattern Integer)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Integer -> Pattern Integer)
forall a. Ord a => H (Pattern a -> Pattern a)
ordTransformations H (Pattern Integer -> Pattern Integer)
-> Text -> H (Pattern Integer -> Pattern Integer)
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected Pattern Integer -> Pattern Integer"

instance Parse (Pattern Time -> Pattern Time) where
  parser :: H (Pattern Time -> Pattern Time)
parser = H (Pattern Time -> Pattern Time)
forall a.
(Parse (Pattern a), Parse (Pattern a -> Pattern a),
 Parse (Pattern a -> Pattern a -> Pattern a),
 Parse ((Pattern a -> Pattern a) -> Pattern a -> Pattern a),
 Parse ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)) =>
H (Pattern a -> Pattern a)
genericTransformations H (Pattern Time -> Pattern Time)
-> H (Pattern Time -> Pattern Time)
-> H (Pattern Time -> Pattern Time)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Time -> Pattern Time)
forall a. (Num a, Enum a, Real a) => H (Pattern a -> Pattern a)
numTransformations H (Pattern Time -> Pattern Time)
-> H (Pattern Time -> Pattern Time)
-> H (Pattern Time -> Pattern Time)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Time -> Pattern Time)
forall a. Ord a => H (Pattern a -> Pattern a)
ordTransformations H (Pattern Time -> Pattern Time)
-> H (Pattern Time -> Pattern Time)
-> H (Pattern Time -> Pattern Time)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Time -> Pattern Time)
forall a. (RealFrac a, Parse a) => H (Pattern a -> Pattern a)
realFracTransformations H (Pattern Time -> Pattern Time)
-> Text -> H (Pattern Time -> Pattern Time)
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected Pattern Time -> Pattern Time"

instance Parse (Pattern Double -> Pattern Double) where
  parser :: H (Pattern Double -> Pattern Double)
parser =
    H (Pattern Double -> Pattern Double)
forall a.
(Parse (Pattern a), Parse (Pattern a -> Pattern a),
 Parse (Pattern a -> Pattern a -> Pattern a),
 Parse ((Pattern a -> Pattern a) -> Pattern a -> Pattern a),
 Parse ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)) =>
H (Pattern a -> Pattern a)
genericTransformations
      H (Pattern Double -> Pattern Double)
-> H (Pattern Double -> Pattern Double)
-> H (Pattern Double -> Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Double -> Pattern Double)
forall a. (Num a, Enum a, Real a) => H (Pattern a -> Pattern a)
numTransformations
      H (Pattern Double -> Pattern Double)
-> H (Pattern Double -> Pattern Double)
-> H (Pattern Double -> Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Double -> Pattern Double)
forall a.
(Floating a, Parse a, Parse (Pattern a)) =>
H (Pattern a -> Pattern a)
floatingTransformations
      H (Pattern Double -> Pattern Double)
-> H (Pattern Double -> Pattern Double)
-> H (Pattern Double -> Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Double -> Pattern Double)
forall a. Ord a => H (Pattern a -> Pattern a)
ordTransformations
      H (Pattern Double -> Pattern Double)
-> H (Pattern Double -> Pattern Double)
-> H (Pattern Double -> Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Double -> Pattern Double)
forall a. (RealFrac a, Parse a) => H (Pattern a -> Pattern a)
realFracTransformations
      H (Pattern Double -> Pattern Double)
-> H (Pattern Double -> Pattern Double)
-> H (Pattern Double -> Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "perlin2")
        H (Pattern Double -> Pattern Double)
-> Text -> H (Pattern Double -> Pattern Double)
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected Pattern Double -> Pattern Double"

instance Parse (Pattern Note -> Pattern Note) where
  parser :: H (Pattern Note -> Pattern Note)
parser = H (Pattern Note -> Pattern Note)
forall a.
(Parse (Pattern a), Parse (Pattern a -> Pattern a),
 Parse (Pattern a -> Pattern a -> Pattern a),
 Parse ((Pattern a -> Pattern a) -> Pattern a -> Pattern a),
 Parse ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)) =>
H (Pattern a -> Pattern a)
genericTransformations H (Pattern Note -> Pattern Note)
-> H (Pattern Note -> Pattern Note)
-> H (Pattern Note -> Pattern Note)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Note -> Pattern Note)
forall a. (Num a, Enum a, Real a) => H (Pattern a -> Pattern a)
numTransformations H (Pattern Note -> Pattern Note)
-> H (Pattern Note -> Pattern Note)
-> H (Pattern Note -> Pattern Note)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Note -> Pattern Note)
forall a.
(Floating a, Parse a, Parse (Pattern a)) =>
H (Pattern a -> Pattern a)
floatingTransformations H (Pattern Note -> Pattern Note)
-> H (Pattern Note -> Pattern Note)
-> H (Pattern Note -> Pattern Note)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Note -> Pattern Note)
forall a. Ord a => H (Pattern a -> Pattern a)
ordTransformations H (Pattern Note -> Pattern Note)
-> Text -> H (Pattern Note -> Pattern Note)
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected Pattern Note -> Pattern Note"

genericTransformations :: forall a. (Parse (Pattern a), Parse (Pattern a -> Pattern a), Parse (Pattern a -> Pattern a -> Pattern a), Parse ((Pattern a -> Pattern a) -> Pattern a -> Pattern a), Parse ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)) => H (Pattern a -> Pattern a)
genericTransformations :: forall a.
(Parse (Pattern a), Parse (Pattern a -> Pattern a),
 Parse (Pattern a -> Pattern a -> Pattern a),
 Parse ((Pattern a -> Pattern a) -> Pattern a -> Pattern a),
 Parse ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)) =>
H (Pattern a -> Pattern a)
genericTransformations =
  H (Pattern a -> Pattern a)
forall a. Parse (a -> a) => H (a -> a)
simpleComposition
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromHaskell "id")
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern a -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H (Pattern a -> Pattern a -> Pattern a)) H (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a) -> H (Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern a)
forall a. Parse a => H a
parser
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a) -> H (Pattern a -> Pattern a)
forall st a b c.
Haskellish st (a -> b -> c)
-> Haskellish st b -> Haskellish st (a -> c)
asRightSection (H (Pattern a -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H (Pattern a -> Pattern a -> Pattern a)) (Haskellish () (Pattern a) -> Haskellish () (Pattern a)
forall st a. Haskellish st a -> Haskellish st a
required Haskellish () (Pattern a)
forall a. Parse a => H a
parser)
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)) H ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H (Pattern a -> Pattern a)
forall a. Parse a => H a
parser
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "brak")
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "rev")
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "palindrome")
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "stretch")
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "loopFirst")
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "degrade")
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "arpeggiate")
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "trigger")
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "rolled")
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern a -> Pattern a -> Pattern a)
forall a b. H (a -> b -> a)
constParser H (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a) -> H (Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern a)
forall a. Parse a => H a
parser
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    -- more complex possibilities that would involve overlapped Parse instances if they were instances
    H (Pattern Time -> Pattern a -> Pattern a)
forall a. H (Pattern Time -> Pattern a -> Pattern a)
pTime_p_p H (Pattern Time -> Pattern a -> Pattern a)
-> H (Pattern Time) -> H (Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H (Pattern Time)
forall a. Parse a => H a
parser
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Int -> Pattern a -> Pattern a)
forall a. H (Pattern Int -> Pattern a -> Pattern a)
pInt_p_p H (Pattern Int -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Int) -> H (Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Int)
forall a. Parse a => H a
parser
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Double -> Pattern a -> Pattern a)
forall a. H (Pattern Double -> Pattern a -> Pattern a)
pDouble_p_p H (Pattern Double -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Double) -> H (Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Double)
forall a. Parse a => H a
parser
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Bool -> Pattern a -> Pattern a)
forall a. H (Pattern Bool -> Pattern a -> Pattern a)
pBool_p_p H (Pattern Bool -> Pattern a -> Pattern a)
-> H (Pattern Bool) -> H (Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H (Pattern Bool)
forall a. Parse a => H a
parser
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H ([Pattern Int] -> Pattern a -> Pattern a)
forall a. H ([Pattern Int] -> Pattern a -> Pattern a)
lpInt_p_p H ([Pattern Int] -> Pattern a -> Pattern a)
-> Haskellish () [Pattern Int] -> H (Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () [Pattern Int]
forall a. Parse a => H a
parser
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern [Char] -> Pattern a -> Pattern a)
forall a. H (Pattern [Char] -> Pattern a -> Pattern a)
pString_p_p H (Pattern [Char] -> Pattern a -> Pattern a)
-> Haskellish () (Pattern [Char]) -> H (Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern [Char])
forall a. Parse a => H a
parser
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    -- more complex possibilities that wouldn't involve overlapped Parse instances
    (H (Time -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H (Time -> Pattern a -> Pattern a)) H (Time -> Pattern a -> Pattern a)
-> H Time -> H (Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H Time
forall a. Parse a => H a
parser
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H ((Time, Time) -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H ((Time, Time) -> Pattern a -> Pattern a)) H ((Time, Time) -> Pattern a -> Pattern a)
-> Haskellish () (Time, Time) -> H (Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Time, Time)
forall a. Parse a => H a
parser
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H ([Time] -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H ([Time] -> Pattern a -> Pattern a)) H ([Time] -> Pattern a -> Pattern a)
-> H [Time] -> H (Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H [Time]
forall a. Parse a => H a
parser
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H ([Pattern Time] -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H ([Pattern Time] -> Pattern a -> Pattern a)) H ([Pattern Time] -> Pattern a -> Pattern a)
-> Haskellish () [Pattern Time] -> H (Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () [Pattern Time]
forall a. Parse a => H a
parser
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H ([Pattern Double] -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H ([Pattern Double] -> Pattern a -> Pattern a)) H ([Pattern Double] -> Pattern a -> Pattern a)
-> Haskellish () [Pattern Double] -> H (Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () [Pattern Double]
forall a. Parse a => H a
parser
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)) H ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)
-> Haskellish () [Pattern a -> Pattern a]
-> H (Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () [Pattern a -> Pattern a]
forall a. Parse a => H a
parser
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H ([Pattern a] -> Pattern a -> Pattern a)
forall a.
Parse (Pattern a -> Pattern a -> Pattern a) =>
H ([Pattern a] -> Pattern a -> Pattern a)
lp_p_p H ([Pattern a] -> Pattern a -> Pattern a)
-> Haskellish () [Pattern a] -> H (Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () [Pattern a]
forall a. Parse a => H a
parser
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern a -> Pattern a)
forall a b. Parse (a -> Pattern b) => H (a -> Pattern b)
a_patternB
    H (Pattern a -> Pattern a)
-> H (Pattern a -> Pattern a) -> H (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern a -> Pattern a)
forall a b.
Parse (Pattern a -> Pattern b) =>
H (Pattern a -> Pattern b)
pA_pB

-- this only matches the case where the functions being composed are both a -> a (with the same a)
-- nonetheless, this is an extremely common case with Tidal
simpleComposition :: forall a. (Parse (a -> a)) => H (a -> a)
simpleComposition :: forall a. Parse (a -> a) => H (a -> a)
simpleComposition = $(fromHaskell ".") Haskellish () ((a -> a) -> (a -> a) -> a -> a)
-> Haskellish () (a -> a) -> Haskellish () ((a -> a) -> a -> a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> (Haskellish () (a -> a)
forall a. Parse a => H a
parser :: H (a -> a)) Haskellish () ((a -> a) -> a -> a)
-> Haskellish () (a -> a) -> Haskellish () (a -> a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> (Haskellish () (a -> a)
forall a. Parse a => H a
parser :: H (a -> a))

numTransformations :: (Num a, Enum a, Real a) => H (Pattern a -> Pattern a)
numTransformations :: forall a. (Num a, Enum a, Real a) => H (Pattern a -> Pattern a)
numTransformations =
  $(fromTidal "run")

ordTransformations :: (Ord a) => H (Pattern a -> Pattern a)
ordTransformations :: forall a. Ord a => H (Pattern a -> Pattern a)
ordTransformations =
  H (Pattern Int -> Pattern a -> Pattern a)
forall a. Ord a => H (Pattern Int -> Pattern a -> Pattern a)
pInt_pOrd_pOrd H (Pattern Int -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Int)
-> Haskellish () (Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Int)
forall a. Parse a => H a
parser

floatingTransformations :: (Floating a, Parse a, Parse (Pattern a)) => H (Pattern a -> Pattern a)
floatingTransformations :: forall a.
(Floating a, Parse a, Parse (Pattern a)) =>
H (Pattern a -> Pattern a)
floatingTransformations =
  H (Pattern a -> Pattern a -> Pattern a)
forall a. Floating a => H (Pattern a -> Pattern a -> Pattern a)
floatingMergeOperator H (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a)
-> Haskellish () (Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern a)
forall a. Parse a => H a
parser
    Haskellish () (Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (a -> Pattern a -> Pattern a)
forall a. (Floating a, Parse a) => H (a -> Pattern a -> Pattern a)
floating_pFloating_pFloating H (a -> Pattern a -> Pattern a)
-> Haskellish () a -> Haskellish () (Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () a
forall a. Parse a => H a
parser

realFracTransformations :: (RealFrac a, Parse a) => H (Pattern a -> Pattern a)
realFracTransformations :: forall a. (RealFrac a, Parse a) => H (Pattern a -> Pattern a)
realFracTransformations = H (a -> Pattern a -> Pattern a)
forall a. RealFrac a => H (a -> Pattern a -> Pattern a)
realFrac_pRealFrac_pRealFrac H (a -> Pattern a -> Pattern a)
-> Haskellish () a -> Haskellish () (Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () a
forall a. Parse a => H a
parser

instance Parse ([a] -> Pattern a) where
  parser :: H ([a] -> Pattern a)
parser =
    $(fromTidal "listToPat")
      H ([a] -> Pattern a)
-> H ([a] -> Pattern a) -> H ([a] -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "choose")
      H ([a] -> Pattern a)
-> H ([a] -> Pattern a) -> H ([a] -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "cycleChoose")
      H ([a] -> Pattern a)
-> H ([a] -> Pattern a) -> H ([a] -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H ([a] -> Pattern a)
forall a b. Parse (a -> Pattern b) => H (a -> Pattern b)
a_patternB

instance Parse ([Pattern a] -> Pattern a) where
  parser :: H ([Pattern a] -> Pattern a)
parser =
    $(fromTidal "stack")
      H ([Pattern a] -> Pattern a)
-> H ([Pattern a] -> Pattern a) -> H ([Pattern a] -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "fastcat")
      H ([Pattern a] -> Pattern a)
-> H ([Pattern a] -> Pattern a) -> H ([Pattern a] -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "fastCat")
      H ([Pattern a] -> Pattern a)
-> H ([Pattern a] -> Pattern a) -> H ([Pattern a] -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "slowcat")
      H ([Pattern a] -> Pattern a)
-> H ([Pattern a] -> Pattern a) -> H ([Pattern a] -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "slowCat")
      H ([Pattern a] -> Pattern a)
-> H ([Pattern a] -> Pattern a) -> H ([Pattern a] -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "cat")
      H ([Pattern a] -> Pattern a)
-> H ([Pattern a] -> Pattern a) -> H ([Pattern a] -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "randcat")
      H ([Pattern a] -> Pattern a)
-> H ([Pattern a] -> Pattern a) -> H ([Pattern a] -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern Double -> [Pattern a] -> Pattern a)
forall a. Parse a => H a
parser :: H (Pattern Double -> [Pattern a] -> Pattern a)) H (Pattern Double -> [Pattern a] -> Pattern a)
-> Haskellish () (Pattern Double) -> H ([Pattern a] -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Double)
forall a. Parse a => H a
parser
      H ([Pattern a] -> Pattern a)
-> H ([Pattern a] -> Pattern a) -> H ([Pattern a] -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern Int -> [Pattern a] -> Pattern a)
forall a. Parse a => H a
parser :: H (Pattern Int -> [Pattern a] -> Pattern a)) H (Pattern Int -> [Pattern a] -> Pattern a)
-> Haskellish () (Pattern Int) -> H ([Pattern a] -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Int)
forall a. Parse a => H a
parser
      H ([Pattern a] -> Pattern a)
-> H ([Pattern a] -> Pattern a) -> H ([Pattern a] -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H ([Pattern a] -> Pattern a)
forall a b. Parse (a -> Pattern b) => H (a -> Pattern b)
a_patternB

instance Parse ([(Pattern a, Pattern Double)] -> Pattern a) where
  parser :: H ([(Pattern a, Pattern Double)] -> Pattern a)
parser =
    $(fromTidal "wrandcat")
      H ([(Pattern a, Pattern Double)] -> Pattern a)
-> H ([(Pattern a, Pattern Double)] -> Pattern a)
-> H ([(Pattern a, Pattern Double)] -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H ([(Pattern a, Pattern Double)] -> Pattern a)
forall a b. Parse (a -> Pattern b) => H (a -> Pattern b)
a_patternB

pInt_p :: (Parse [a]) => H (Pattern Int -> Pattern a)
pInt_p :: forall a. Parse [a] => H (Pattern Int -> Pattern a)
pInt_p =
  (H ([a] -> Pattern Int -> Pattern a)
forall {a}. H ([a] -> Pattern Int -> Pattern a)
forall a. Parse a => H a
parser :: H ([a] -> Pattern Int -> Pattern a)) H ([a] -> Pattern Int -> Pattern a)
-> Haskellish () [a] -> Haskellish () (Pattern Int -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () [a]
forall a. Parse a => H a
parser

-- ??? a_patternB -- also missing from all non-instance entries in this section
-- ??? pA_pB

instance Parse (Pattern String -> ControlPattern) where
  parser :: H (Pattern [Char] -> Pattern ValueMap)
parser =
    $(fromTidal "s")
      H (Pattern [Char] -> Pattern ValueMap)
-> H (Pattern [Char] -> Pattern ValueMap)
-> H (Pattern [Char] -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "sound")
      H (Pattern [Char] -> Pattern ValueMap)
-> H (Pattern [Char] -> Pattern ValueMap)
-> H (Pattern [Char] -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "vowel")
      H (Pattern [Char] -> Pattern ValueMap)
-> H (Pattern [Char] -> Pattern ValueMap)
-> H (Pattern [Char] -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H ([Char] -> Pattern [Char] -> Pattern ValueMap)
forall a. Parse a => H a
parser :: H (String -> Pattern String -> ControlPattern)) H ([Char] -> Pattern [Char] -> Pattern ValueMap)
-> H [Char] -> H (Pattern [Char] -> Pattern ValueMap)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H [Char]
forall a. Parse a => H a
parser
      H (Pattern [Char] -> Pattern ValueMap)
-> H (Pattern [Char] -> Pattern ValueMap)
-> H (Pattern [Char] -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern [Char] -> Pattern ValueMap)
forall a b.
Parse (Pattern a -> Pattern b) =>
H (Pattern a -> Pattern b)
pA_pB
      H (Pattern [Char] -> Pattern ValueMap)
-> H (Pattern [Char] -> Pattern ValueMap)
-> H (Pattern [Char] -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern [Char] -> Pattern ValueMap)
forall a b. Parse (a -> Pattern b) => H (a -> Pattern b)
a_patternB

instance Parse (Pattern Int -> ControlPattern) where
  parser :: H (Pattern Int -> Pattern ValueMap)
parser =
    $(fromTidal "cut")
      H (Pattern Int -> Pattern ValueMap)
-> H (Pattern Int -> Pattern ValueMap)
-> H (Pattern Int -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H ([Char] -> Pattern Int -> Pattern ValueMap)
forall a. Parse a => H a
parser :: H (String -> Pattern Int -> ControlPattern)) H ([Char] -> Pattern Int -> Pattern ValueMap)
-> H [Char] -> H (Pattern Int -> Pattern ValueMap)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H [Char]
forall a. Parse a => H a
parser
      H (Pattern Int -> Pattern ValueMap)
-> H (Pattern Int -> Pattern ValueMap)
-> H (Pattern Int -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Int -> Pattern ValueMap)
forall a b.
Parse (Pattern a -> Pattern b) =>
H (Pattern a -> Pattern b)
pA_pB
      H (Pattern Int -> Pattern ValueMap)
-> H (Pattern Int -> Pattern ValueMap)
-> H (Pattern Int -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Int -> Pattern ValueMap)
forall a b. Parse (a -> Pattern b) => H (a -> Pattern b)
a_patternB

instance Parse (Pattern String -> Pattern Bool) where
  parser :: H (Pattern [Char] -> Pattern Bool)
parser =
    $(fromTidal "ascii")
      H (Pattern [Char] -> Pattern Bool)
-> H (Pattern [Char] -> Pattern Bool)
-> H (Pattern [Char] -> Pattern Bool)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern [Char] -> Pattern Bool)
forall a b.
Parse (Pattern a -> Pattern b) =>
H (Pattern a -> Pattern b)
pA_pB
      H (Pattern [Char] -> Pattern Bool)
-> H (Pattern [Char] -> Pattern Bool)
-> H (Pattern [Char] -> Pattern Bool)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern [Char] -> Pattern Bool)
forall a b. Parse (a -> Pattern b) => H (a -> Pattern b)
a_patternB

instance Parse (Pattern Int -> Pattern Bool) where
  parser :: H (Pattern Int -> Pattern Bool)
parser =
    $(fromTidal "binary")
      H (Pattern Int -> Pattern Bool)
-> H (Pattern Int -> Pattern Bool)
-> H (Pattern Int -> Pattern Bool)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern Int -> Pattern Int -> Pattern Bool)
forall a. Parse a => H a
parser :: H (Pattern Int -> Pattern Int -> Pattern Bool)) H (Pattern Int -> Pattern Int -> Pattern Bool)
-> Haskellish () (Pattern Int) -> H (Pattern Int -> Pattern Bool)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Int)
forall a. Parse a => H a
parser
      H (Pattern Int -> Pattern Bool)
-> H (Pattern Int -> Pattern Bool)
-> H (Pattern Int -> Pattern Bool)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Int -> Pattern Bool)
forall a b.
Parse (Pattern a -> Pattern b) =>
H (Pattern a -> Pattern b)
pA_pB
      H (Pattern Int -> Pattern Bool)
-> H (Pattern Int -> Pattern Bool)
-> H (Pattern Int -> Pattern Bool)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Int -> Pattern Bool)
forall a b. Parse (a -> Pattern b) => H (a -> Pattern b)
a_patternB

instance Parse (Pattern Note -> ControlPattern) where
  parser :: H (Pattern Note -> Pattern ValueMap)
parser =
    $(fromTidal "up")
      H (Pattern Note -> Pattern ValueMap)
-> H (Pattern Note -> Pattern ValueMap)
-> H (Pattern Note -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "n")
      H (Pattern Note -> Pattern ValueMap)
-> H (Pattern Note -> Pattern ValueMap)
-> H (Pattern Note -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "note")
      H (Pattern Note -> Pattern ValueMap)
-> H (Pattern Note -> Pattern ValueMap)
-> H (Pattern Note -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H ([Char] -> Pattern Note -> Pattern ValueMap)
forall a. Parse a => H a
parser :: H (String -> Pattern Note -> ControlPattern)) H ([Char] -> Pattern Note -> Pattern ValueMap)
-> H [Char] -> H (Pattern Note -> Pattern ValueMap)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H [Char]
forall a. Parse a => H a
parser
      H (Pattern Note -> Pattern ValueMap)
-> H (Pattern Note -> Pattern ValueMap)
-> H (Pattern Note -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Note -> Pattern ValueMap)
forall a b.
Parse (Pattern a -> Pattern b) =>
H (Pattern a -> Pattern b)
pA_pB
      H (Pattern Note -> Pattern ValueMap)
-> H (Pattern Note -> Pattern ValueMap)
-> H (Pattern Note -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Note -> Pattern ValueMap)
forall a b. Parse (a -> Pattern b) => H (a -> Pattern b)
a_patternB

instance Parse (Pattern Double -> ControlPattern) where
  parser :: H (Pattern Double -> Pattern ValueMap)
parser =
    $(fromTidal "speed")
      H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "pan")
      H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "shape")
      H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "gain")
      H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "overgain")
      H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "overshape")
      H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "accelerate")
      H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "bandf")
      H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "bandq")
      H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "begin")
      H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "crush")
      H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "legato")
      H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "cutoff")
      H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "delayfeedback")
      H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "delaytime")
      H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "delay")
      H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "end")
      H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "hcutoff")
      H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "hresonance")
      H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "resonance")
      H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "loop")
      H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "coarse")
      H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "nudge")
      H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H ([Char] -> Pattern Double -> Pattern ValueMap)
forall a. Parse a => H a
parser :: H (String -> Pattern Double -> ControlPattern)) H ([Char] -> Pattern Double -> Pattern ValueMap)
-> H [Char] -> H (Pattern Double -> Pattern ValueMap)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H [Char]
forall a. Parse a => H a
parser
      H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Double -> Pattern ValueMap)
forall a b.
Parse (Pattern a -> Pattern b) =>
H (Pattern a -> Pattern b)
pA_pB
      H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Double -> Pattern ValueMap)
forall a b. Parse (a -> Pattern b) => H (a -> Pattern b)
a_patternB

instance Parse (Pattern Int -> Pattern String) where
  parser :: H (Pattern Int -> Pattern [Char])
parser =
    H (Pattern [Char] -> Pattern Int -> Pattern [Char])
pString_pInt_pString H (Pattern [Char] -> Pattern Int -> Pattern [Char])
-> Haskellish () (Pattern [Char])
-> H (Pattern Int -> Pattern [Char])
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern [Char])
forall a. Parse a => H a
parser
      H (Pattern Int -> Pattern [Char])
-> H (Pattern Int -> Pattern [Char])
-> H (Pattern Int -> Pattern [Char])
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Int -> Pattern [Char])
forall a b.
Parse (Pattern a -> Pattern b) =>
H (Pattern a -> Pattern b)
pA_pB
      H (Pattern Int -> Pattern [Char])
-> H (Pattern Int -> Pattern [Char])
-> H (Pattern Int -> Pattern [Char])
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Int -> Pattern [Char])
forall a b. Parse (a -> Pattern b) => H (a -> Pattern b)
a_patternB

instance Parse (String -> Pattern String) where
  parser :: H ([Char] -> Pattern [Char])
parser =
    (H ([Char] -> [Char] -> Pattern [Char])
forall a. Parse a => H a
parser :: H (String -> String -> Pattern String)) H ([Char] -> [Char] -> Pattern [Char])
-> H [Char] -> H ([Char] -> Pattern [Char])
forall a b.
Haskellish () (a -> b) -> Haskellish () a -> Haskellish () b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> H [Char]
forall a. Parse a => H a
parser
      H ([Char] -> Pattern [Char])
-> H ([Char] -> Pattern [Char]) -> H ([Char] -> Pattern [Char])
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H ([[Char]] -> [Char] -> Pattern [Char])
forall a. Parse a => H a
parser :: H ([String] -> String -> Pattern String)) H ([[Char]] -> [Char] -> Pattern [Char])
-> Haskellish () [[Char]] -> H ([Char] -> Pattern [Char])
forall a b.
Haskellish () (a -> b) -> Haskellish () a -> Haskellish () b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Haskellish () [[Char]]
forall a. Parse a => H a
parser

instance Parse ([(String, String)] -> Pattern String) where
  parser :: H ([([Char], [Char])] -> Pattern [Char])
parser = $(fromTidal "sseqs")

instance Parse (String -> String) where
  parser :: H ([Char] -> [Char])
parser = (H ([Char] -> [Char] -> [Char])
forall a. Parse a => H a
parser :: H (String -> String -> String)) H ([Char] -> [Char] -> [Char]) -> H [Char] -> H ([Char] -> [Char])
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H [Char]
forall a. Parse a => H a
parser

-- note: missing pA_pB and a_patternB pathways
pInt_pNumA :: (Num a, Parse [a]) => H (Pattern Int -> Pattern a)
pInt_pNumA :: forall a. (Num a, Parse [a]) => H (Pattern Int -> Pattern a)
pInt_pNumA = H ([a] -> Pattern Int -> Pattern a)
forall a. Num a => H ([a] -> Pattern Int -> Pattern a)
listNumA_pInt_pA H ([a] -> Pattern Int -> Pattern a)
-> Haskellish () [a] -> Haskellish () (Pattern Int -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () [a]
forall a. Parse a => H a
parser

-- note: missing pA_pB and a_patternB pathways
pInt_pFractionalA :: (Fractional a) => H (Pattern Int -> Pattern a)
pInt_pFractionalA :: forall a. Fractional a => H (Pattern Int -> Pattern a)
pInt_pFractionalA = (H (Pattern [Char] -> Pattern Int -> Pattern a)
forall {a}.
Fractional a =>
H (Pattern [Char] -> Pattern Int -> Pattern a)
forall a. Parse a => H a
parser :: (Fractional a) => H (Pattern String -> Pattern Int -> Pattern a)) H (Pattern [Char] -> Pattern Int -> Pattern a)
-> Haskellish () (Pattern [Char])
-> Haskellish () (Pattern Int -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern [Char])
forall a. Parse a => H a
parser

pDouble_pFractionalA :: (Fractional a) => H (Pattern Double -> Pattern a)
pDouble_pFractionalA :: forall a. Fractional a => H (Pattern Double -> Pattern a)
pDouble_pFractionalA = $(fromTidal "perlinWith")

-- note: mising a_patternB pathway
listCp_cp :: H ([ControlPattern] -> ControlPattern)
listCp_cp :: H ([Pattern ValueMap] -> Pattern ValueMap)
listCp_cp = (H (Pattern ValueMap -> [Pattern ValueMap] -> Pattern ValueMap)
forall a. Parse a => H a
parser :: H (ControlPattern -> [ControlPattern] -> ControlPattern)) H (Pattern ValueMap -> [Pattern ValueMap] -> Pattern ValueMap)
-> Haskellish () (Pattern ValueMap)
-> H ([Pattern ValueMap] -> Pattern ValueMap)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern ValueMap)
forall a. Parse a => H a
parser

instance (Parse (Pattern a)) => Parse ([Pattern a -> Pattern a] -> Pattern a) where
  parser :: H ([Pattern a -> Pattern a] -> Pattern a)
parser =
    (H (Pattern a -> [Pattern a -> Pattern a] -> Pattern a)
forall a. Parse a => H a
parser :: H (Pattern a -> [Pattern a -> Pattern a] -> Pattern a)) H (Pattern a -> [Pattern a -> Pattern a] -> Pattern a)
-> Haskellish () (Pattern a)
-> H ([Pattern a -> Pattern a] -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern a)
forall a. Parse a => H a
parser
      H ([Pattern a -> Pattern a] -> Pattern a)
-> H ([Pattern a -> Pattern a] -> Pattern a)
-> H ([Pattern a -> Pattern a] -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H ([Pattern a -> Pattern a] -> Pattern a)
forall a b. Parse (a -> Pattern b) => H (a -> Pattern b)
a_patternB

-- note: mising a_patternB pathway (? maybe not necessary here though ?)
pA_pB :: (Parse (Pattern a -> Pattern b)) => H (Pattern a -> Pattern b)
pA_pB :: forall a b.
Parse (Pattern a -> Pattern b) =>
H (Pattern a -> Pattern b)
pA_pB = H ((Pattern a -> Pattern b) -> Pattern a -> Pattern b)
forall a b. H ((Pattern a -> Pattern b) -> Pattern a -> Pattern b)
pAB_pA_pB H ((Pattern a -> Pattern b) -> Pattern a -> Pattern b)
-> Haskellish () (Pattern a -> Pattern b)
-> Haskellish () (Pattern a -> Pattern b)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern a -> Pattern b)
forall a. Parse a => H a
parser

fBool_fBool :: (Functor f) => H (f Bool -> f Bool)
fBool_fBool :: forall (f :: * -> *). Functor f => H (f Bool -> f Bool)
fBool_fBool = $(fromTidal "inv")

-- note: mising a_patternB pathway
list_p :: (Parse a) => H ([a] -> Pattern a)
list_p :: forall a. Parse a => H ([a] -> Pattern a)
list_p = H (Pattern Double -> [a] -> Pattern a)
forall a. Parse a => H (Pattern Double -> [a] -> Pattern a)
pDouble_list_p H (Pattern Double -> [a] -> Pattern a)
-> Haskellish () (Pattern Double)
-> Haskellish () ([a] -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Double)
forall a. Parse a => H a
parser

-- note: mising a_patternB pathway
tupleApDouble_p :: (Parse a) => H ([(a, Pattern Double)] -> Pattern a)
tupleApDouble_p :: forall a. Parse a => H ([(a, Pattern Double)] -> Pattern a)
tupleApDouble_p =
  $(fromTidal "wchoose")
    Haskellish () ([(a, Pattern Double)] -> Pattern a)
-> Haskellish () ([(a, Pattern Double)] -> Pattern a)
-> Haskellish () ([(a, Pattern Double)] -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Double -> [(a, Pattern Double)] -> Pattern a)
forall a.
Parse a =>
H (Pattern Double -> [(a, Pattern Double)] -> Pattern a)
pDouble_tupleApDouble_p H (Pattern Double -> [(a, Pattern Double)] -> Pattern a)
-> Haskellish () (Pattern Double)
-> Haskellish () ([(a, Pattern Double)] -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Double)
forall a. Parse a => H a
parser

instance Parse ([(Time, Pattern a)] -> Pattern a) where
  parser :: H ([(Time, Pattern a)] -> Pattern a)
parser = $(fromTidal "timeCat") H ([(Time, Pattern a)] -> Pattern a)
-> H ([(Time, Pattern a)] -> Pattern a)
-> H ([(Time, Pattern a)] -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "timecat")

instance Parse (String -> Pattern Double) where
  parser :: H ([Char] -> Pattern Double)
parser =
    $(fromTidal "cF_")
      H ([Char] -> Pattern Double)
-> H ([Char] -> Pattern Double) -> H ([Char] -> Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "cF0")
      H ([Char] -> Pattern Double)
-> H ([Char] -> Pattern Double) -> H ([Char] -> Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Double -> [Char] -> Pattern Double)
forall a. Parse a => H a
parser :: H (Double -> String -> Pattern Double)) H (Double -> [Char] -> Pattern Double)
-> H Double -> H ([Char] -> Pattern Double)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H Double
forall a. Parse a => H a
parser

-- * -> * -> *

instance Parse (Pattern Bool -> Pattern Bool -> Pattern Bool) where
  parser :: H (Pattern Bool -> Pattern Bool -> Pattern Bool)
parser = H (Pattern Bool -> Pattern Bool -> Pattern Bool)
forall a. Unionable a => H (Pattern a -> Pattern a -> Pattern a)
genericBinaryPatternFunctions H (Pattern Bool -> Pattern Bool -> Pattern Bool)
-> Text -> H (Pattern Bool -> Pattern Bool -> Pattern Bool)
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected Pattern Bool -> Pattern Bool -> Pattern Bool"

instance Parse (Pattern String -> Pattern String -> Pattern String) where
  parser :: H (Pattern [Char] -> Pattern [Char] -> Pattern [Char])
parser =
    H (Pattern [Char] -> Pattern [Char] -> Pattern [Char])
forall a. Unionable a => H (Pattern a -> Pattern a -> Pattern a)
genericBinaryPatternFunctions H (Pattern [Char] -> Pattern [Char] -> Pattern [Char])
-> Text -> H (Pattern [Char] -> Pattern [Char] -> Pattern [Char])
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected Pattern String -> Pattern String -> Pattern String"

instance Parse (Pattern Int -> Pattern Int -> Pattern Int) where
  parser :: H (Pattern Int -> Pattern Int -> Pattern Int)
parser =
    H (Pattern Int -> Pattern Int -> Pattern Int)
forall a. Unionable a => H (Pattern a -> Pattern a -> Pattern a)
genericBinaryPatternFunctions
      H (Pattern Int -> Pattern Int -> Pattern Int)
-> H (Pattern Int -> Pattern Int -> Pattern Int)
-> H (Pattern Int -> Pattern Int -> Pattern Int)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Int -> Pattern Int -> Pattern Int)
forall a.
(Num a, Parse (Pattern a)) =>
H (Pattern a -> Pattern a -> Pattern a)
numMergeOperator
      H (Pattern Int -> Pattern Int -> Pattern Int)
-> H (Pattern Int -> Pattern Int -> Pattern Int)
-> H (Pattern Int -> Pattern Int -> Pattern Int)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Int -> Pattern Int -> Pattern Int)
forall a. H (Pattern Int -> Pattern a -> Pattern a)
pInt_p_p
        H (Pattern Int -> Pattern Int -> Pattern Int)
-> Text -> H (Pattern Int -> Pattern Int -> Pattern Int)
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected Pattern Int -> Pattern Int -> Pattern Int"

instance Parse (Pattern Integer -> Pattern Integer -> Pattern Integer) where
  parser :: H (Pattern Integer -> Pattern Integer -> Pattern Integer)
parser =
    H (Pattern Integer -> Pattern Integer -> Pattern Integer)
forall a. Unionable a => H (Pattern a -> Pattern a -> Pattern a)
genericBinaryPatternFunctions
      H (Pattern Integer -> Pattern Integer -> Pattern Integer)
-> H (Pattern Integer -> Pattern Integer -> Pattern Integer)
-> H (Pattern Integer -> Pattern Integer -> Pattern Integer)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Integer -> Pattern Integer -> Pattern Integer)
forall a.
(Num a, Parse (Pattern a)) =>
H (Pattern a -> Pattern a -> Pattern a)
numMergeOperator
        H (Pattern Integer -> Pattern Integer -> Pattern Integer)
-> Text
-> H (Pattern Integer -> Pattern Integer -> Pattern Integer)
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected Pattern Integer -> Pattern Integer -> Pattern Integer"

instance Parse (Pattern Time -> Pattern Time -> Pattern Time) where
  parser :: H (Pattern Time -> Pattern Time -> Pattern Time)
parser =
    H (Pattern Time -> Pattern Time -> Pattern Time)
forall a. Unionable a => H (Pattern a -> Pattern a -> Pattern a)
genericBinaryPatternFunctions
      H (Pattern Time -> Pattern Time -> Pattern Time)
-> H (Pattern Time -> Pattern Time -> Pattern Time)
-> H (Pattern Time -> Pattern Time -> Pattern Time)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Time -> Pattern Time -> Pattern Time)
forall a.
(Num a, Parse (Pattern a)) =>
H (Pattern a -> Pattern a -> Pattern a)
numMergeOperator
      H (Pattern Time -> Pattern Time -> Pattern Time)
-> H (Pattern Time -> Pattern Time -> Pattern Time)
-> H (Pattern Time -> Pattern Time -> Pattern Time)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Time -> Pattern Time -> Pattern Time)
forall a. Moddable a => H (Pattern a -> Pattern a -> Pattern a)
realMergeOperator
      H (Pattern Time -> Pattern Time -> Pattern Time)
-> H (Pattern Time -> Pattern Time -> Pattern Time)
-> H (Pattern Time -> Pattern Time -> Pattern Time)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Time -> Pattern Time -> Pattern Time)
forall a. Fractional a => H (Pattern a -> Pattern a -> Pattern a)
fractionalMergeOperator
      H (Pattern Time -> Pattern Time -> Pattern Time)
-> H (Pattern Time -> Pattern Time -> Pattern Time)
-> H (Pattern Time -> Pattern Time -> Pattern Time)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Time -> Pattern Time -> Pattern Time)
forall a. H (Pattern Time -> Pattern a -> Pattern a)
pTime_p_p
        H (Pattern Time -> Pattern Time -> Pattern Time)
-> Text -> H (Pattern Time -> Pattern Time -> Pattern Time)
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected Pattern Time -> Pattern Time -> Pattern Time"

instance Parse (Pattern Double -> Pattern Double -> Pattern Double) where
  parser :: H (Pattern Double -> Pattern Double -> Pattern Double)
parser =
    H (Pattern Double -> Pattern Double -> Pattern Double)
forall a. Unionable a => H (Pattern a -> Pattern a -> Pattern a)
genericBinaryPatternFunctions
      H (Pattern Double -> Pattern Double -> Pattern Double)
-> H (Pattern Double -> Pattern Double -> Pattern Double)
-> H (Pattern Double -> Pattern Double -> Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Double -> Pattern Double -> Pattern Double)
forall a.
(Num a, Parse (Pattern a)) =>
H (Pattern a -> Pattern a -> Pattern a)
numMergeOperator
      H (Pattern Double -> Pattern Double -> Pattern Double)
-> H (Pattern Double -> Pattern Double -> Pattern Double)
-> H (Pattern Double -> Pattern Double -> Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Double -> Pattern Double -> Pattern Double)
forall a. Moddable a => H (Pattern a -> Pattern a -> Pattern a)
realMergeOperator
      H (Pattern Double -> Pattern Double -> Pattern Double)
-> H (Pattern Double -> Pattern Double -> Pattern Double)
-> H (Pattern Double -> Pattern Double -> Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Double -> Pattern Double -> Pattern Double)
forall a. Fractional a => H (Pattern a -> Pattern a -> Pattern a)
fractionalMergeOperator
      H (Pattern Double -> Pattern Double -> Pattern Double)
-> H (Pattern Double -> Pattern Double -> Pattern Double)
-> H (Pattern Double -> Pattern Double -> Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "perlin2With")
      H (Pattern Double -> Pattern Double -> Pattern Double)
-> H (Pattern Double -> Pattern Double -> Pattern Double)
-> H (Pattern Double -> Pattern Double -> Pattern Double)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Double -> Pattern Double -> Pattern Double)
forall a. H (Pattern Double -> Pattern a -> Pattern a)
pDouble_p_p
        H (Pattern Double -> Pattern Double -> Pattern Double)
-> Text -> H (Pattern Double -> Pattern Double -> Pattern Double)
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected Pattern Double -> Pattern Double -> Pattern Double"

instance Parse (Pattern Note -> Pattern Note -> Pattern Note) where
  parser :: H (Pattern Note -> Pattern Note -> Pattern Note)
parser =
    H (Pattern Note -> Pattern Note -> Pattern Note)
forall a. Unionable a => H (Pattern a -> Pattern a -> Pattern a)
genericBinaryPatternFunctions
      H (Pattern Note -> Pattern Note -> Pattern Note)
-> H (Pattern Note -> Pattern Note -> Pattern Note)
-> H (Pattern Note -> Pattern Note -> Pattern Note)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Note -> Pattern Note -> Pattern Note)
forall a.
(Num a, Parse (Pattern a)) =>
H (Pattern a -> Pattern a -> Pattern a)
numMergeOperator
      H (Pattern Note -> Pattern Note -> Pattern Note)
-> H (Pattern Note -> Pattern Note -> Pattern Note)
-> H (Pattern Note -> Pattern Note -> Pattern Note)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Note -> Pattern Note -> Pattern Note)
forall a. Moddable a => H (Pattern a -> Pattern a -> Pattern a)
realMergeOperator
      H (Pattern Note -> Pattern Note -> Pattern Note)
-> H (Pattern Note -> Pattern Note -> Pattern Note)
-> H (Pattern Note -> Pattern Note -> Pattern Note)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Note -> Pattern Note -> Pattern Note)
forall a. Fractional a => H (Pattern a -> Pattern a -> Pattern a)
fractionalMergeOperator
        H (Pattern Note -> Pattern Note -> Pattern Note)
-> Text -> H (Pattern Note -> Pattern Note -> Pattern Note)
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected Pattern Note -> Pattern Note -> Pattern Note"

instance Parse (ControlPattern -> ControlPattern -> ControlPattern) where
  parser :: H (Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
parser =
    H (Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
forall a. Unionable a => H (Pattern a -> Pattern a -> Pattern a)
genericBinaryPatternFunctions
      H (Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
forall a.
(Num a, Parse (Pattern a)) =>
H (Pattern a -> Pattern a -> Pattern a)
numMergeOperator
      H (Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
forall a. Fractional a => H (Pattern a -> Pattern a -> Pattern a)
fractionalMergeOperator
      H (Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "interlace")
      H (Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H ((Pattern ValueMap -> Pattern ValueMap)
   -> Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
forall a. Parse a => H a
parser :: H ((ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern))
        H ((Pattern ValueMap -> Pattern ValueMap)
   -> Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H (Pattern ValueMap -> Pattern ValueMap)
forall a. Parse a => H a
parser
        H (Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
-> Text
-> H (Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected ControlPattern -> ControlPattern -> ControlPattern"

genericBinaryPatternFunctions :: (Unionable a) => H (Pattern a -> Pattern a -> Pattern a)
genericBinaryPatternFunctions :: forall a. Unionable a => H (Pattern a -> Pattern a -> Pattern a)
genericBinaryPatternFunctions =
  $(fromTidal "overlay")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "append")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "slowAppend")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "slowappend")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "fastAppend")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "fastappend")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Unionable a => H (Pattern a -> Pattern a -> Pattern a)
unionableMergeOperator
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Int -> Pattern a -> Pattern a -> Pattern a)
forall a. H (Pattern Int -> Pattern a -> Pattern a -> Pattern a)
pInt_p_p_p H (Pattern Int -> Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Int)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Int)
forall a. Parse a => H a
parser
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Bool -> Pattern a -> Pattern a -> Pattern a)
forall a. H (Pattern Bool -> Pattern a -> Pattern a -> Pattern a)
pBool_p_p_p H (Pattern Bool -> Pattern a -> Pattern a -> Pattern a)
-> H (Pattern Bool)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H (Pattern Bool)
forall a. Parse a => H a
parser
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Time -> Pattern a -> Pattern a -> Pattern a)
forall a. H (Pattern Time -> Pattern a -> Pattern a -> Pattern a)
pTime_p_p_p H (Pattern Time -> Pattern a -> Pattern a -> Pattern a)
-> H (Pattern Time)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H (Pattern Time)
forall a. Parse a => H a
parser
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern Bool -> Pattern a -> Pattern a -> Pattern a)
forall a. H (Pattern Bool -> Pattern a -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H (Pattern Bool -> Pattern a -> Pattern a -> Pattern a)) H (Pattern Bool -> Pattern a -> Pattern a -> Pattern a)
-> H (Pattern Bool)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H (Pattern Bool)
forall a. Parse a => H a
parser
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a b. H (a -> b -> a)
constParser

unionableMergeOperator :: (Unionable a) => H (Pattern a -> Pattern a -> Pattern a)
unionableMergeOperator :: forall a. Unionable a => H (Pattern a -> Pattern a -> Pattern a)
unionableMergeOperator =
  $(fromTidal "#")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "|>|")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "|>")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal ">|")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "|<|")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "|<")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "<|")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromHaskell "<>")

numMergeOperator :: (Num a, Parse (Pattern a)) => H (Pattern a -> Pattern a -> Pattern a)
numMergeOperator :: forall a.
(Num a, Parse (Pattern a)) =>
H (Pattern a -> Pattern a -> Pattern a)
numMergeOperator =
  H (Pattern a -> Pattern a -> Pattern a -> Pattern a)
forall a.
Num a =>
H (Pattern a -> Pattern a -> Pattern a -> Pattern a)
numTernaryTransformations H (Pattern a -> Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern a)
forall a. Parse a => H a
parser
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "|+|")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "|+")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "+|")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "|-|")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "|-")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "-|")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "|*|")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "|*")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "*|")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromHaskell "+")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromHaskell "*")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromHaskell "-")

realMergeOperator :: (Moddable a) => H (Pattern a -> Pattern a -> Pattern a)
realMergeOperator :: forall a. Moddable a => H (Pattern a -> Pattern a -> Pattern a)
realMergeOperator =
  $(fromTidal "|%|")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "|%")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "%|")

fractionalMergeOperator :: (Fractional a) => H (Pattern a -> Pattern a -> Pattern a)
fractionalMergeOperator :: forall a. Fractional a => H (Pattern a -> Pattern a -> Pattern a)
fractionalMergeOperator =
  $(fromTidal "|/|")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "|/")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "/|")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromHaskell "/")

floatingMergeOperator :: (Floating a) => H (Pattern a -> Pattern a -> Pattern a)
floatingMergeOperator :: forall a. Floating a => H (Pattern a -> Pattern a -> Pattern a)
floatingMergeOperator =
  $(fromTidal "|**")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "**|")
    Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "|**|")

constParser :: H (a -> b -> a)
constParser :: forall a b. H (a -> b -> a)
constParser = $(fromHaskell "const")

instance Parse (Time -> Pattern a -> Pattern a) where
  parser :: H (Time -> Pattern a -> Pattern a)
parser =
    $(fromTidal "rotL")
      H (Time -> Pattern a -> Pattern a)
-> H (Time -> Pattern a -> Pattern a)
-> H (Time -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "rotR")
      H (Time -> Pattern a -> Pattern a)
-> H (Time -> Pattern a -> Pattern a)
-> H (Time -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Time -> Time -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H (Time -> Time -> Pattern a -> Pattern a)) H (Time -> Time -> Pattern a -> Pattern a)
-> H Time -> H (Time -> Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H Time
forall a. Parse a => H a
parser
      H (Time -> Pattern a -> Pattern a)
-> H (Time -> Pattern a -> Pattern a)
-> H (Time -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Int -> Time -> Pattern a -> Pattern a)
forall i a. Integral i => H (i -> Time -> Pattern a -> Pattern a)
integral_time_pA_pA H (Int -> Time -> Pattern a -> Pattern a)
-> H Int -> H (Time -> Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> (H Int
forall a. Parse a => H a
parser :: H Int) -- we over-specialized this to Int since don't know of case where this wouldn't suffice

instance Parse (Pattern Int -> Pattern Int -> Pattern Bool) where
  parser :: H (Pattern Int -> Pattern Int -> Pattern Bool)
parser = $(fromTidal "binaryN")

instance Parse ((Time, Time) -> Pattern a -> Pattern a) where
  parser :: H ((Time, Time) -> Pattern a -> Pattern a)
parser =
    $(fromTidal "compress")
      H ((Time, Time) -> Pattern a -> Pattern a)
-> H ((Time, Time) -> Pattern a -> Pattern a)
-> H ((Time, Time) -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "zoom")
      H ((Time, Time) -> Pattern a -> Pattern a)
-> H ((Time, Time) -> Pattern a -> Pattern a)
-> H ((Time, Time) -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "compressTo")

pString_pInt_pString :: H (Pattern String -> Pattern Int -> Pattern String)
pString_pInt_pString :: H (Pattern [Char] -> Pattern Int -> Pattern [Char])
pString_pInt_pString = $(fromTidal "samples")

pTime_p_p :: H (Pattern Time -> Pattern a -> Pattern a)
pTime_p_p :: forall a. H (Pattern Time -> Pattern a -> Pattern a)
pTime_p_p =
  $(fromTidal "fast")
    Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "fastGap")
    Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "density")
    Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "slow")
    Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "trunc")
    Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "densityGap")
    Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "sparsity")
    Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "linger")
    Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "segment")
    Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "discretise")
    Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "timeLoop")
    Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "swing")
    Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "<~")
    Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "~>")
    Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "ply")
    Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern Time -> Pattern Time -> Pattern a -> Pattern a)
forall {a}.
H (Pattern Time -> Pattern Time -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H (Pattern Time -> Pattern Time -> Pattern a -> Pattern a)) H (Pattern Time -> Pattern Time -> Pattern a -> Pattern a)
-> H (Pattern Time)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H (Pattern Time)
forall a. Parse a => H a
parser

pInt_p_p :: H (Pattern Int -> Pattern a -> Pattern a)
pInt_p_p :: forall a. H (Pattern Int -> Pattern a -> Pattern a)
pInt_p_p =
  $(fromTidal "iter")
    Haskellish () (Pattern Int -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Int -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Int -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "iter'")
    Haskellish () (Pattern Int -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Int -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Int -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "substruct'")
    Haskellish () (Pattern Int -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Int -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Int -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "slowstripe")
    Haskellish () (Pattern Int -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Int -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Int -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "shuffle")
    Haskellish () (Pattern Int -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Int -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Int -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "scramble")
    Haskellish () (Pattern Int -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Int -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Int -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "repeatCycles")
    Haskellish () (Pattern Int -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Int -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Int -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "stripe")
    Haskellish () (Pattern Int -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Int -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Int -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Int -> Pattern Int -> Pattern a -> Pattern a)
forall a. H (Pattern Int -> Pattern Int -> Pattern a -> Pattern a)
pInt_pInt_p_p H (Pattern Int -> Pattern Int -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Int)
-> Haskellish () (Pattern Int -> Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Int)
forall a. Parse a => H a
parser

pInt_pOrd_pOrd :: (Ord a) => H (Pattern Int -> Pattern a -> Pattern a)
pInt_pOrd_pOrd :: forall a. Ord a => H (Pattern Int -> Pattern a -> Pattern a)
pInt_pOrd_pOrd = $(fromTidal "rot")

pDouble_p_p :: H (Pattern Double -> Pattern a -> Pattern a)
pDouble_p_p :: forall a. H (Pattern Double -> Pattern a -> Pattern a)
pDouble_p_p =
  $(fromTidal "degradeBy")
    Haskellish () (Pattern Double -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Double -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Double -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "unDegradeBy")
    Haskellish () (Pattern Double -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Double -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Double -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Int -> Pattern Double -> Pattern a -> Pattern a)
forall {a}. H (Int -> Pattern Double -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H (Int -> Pattern Double -> Pattern a -> Pattern a)) H (Int -> Pattern Double -> Pattern a -> Pattern a)
-> H Int
-> Haskellish () (Pattern Double -> Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H Int
forall a. Parse a => H a
parser

pBool_p_p :: H (Pattern Bool -> Pattern a -> Pattern a)
pBool_p_p :: forall a. H (Pattern Bool -> Pattern a -> Pattern a)
pBool_p_p =
  $(fromTidal "mask")
    Haskellish () (Pattern Bool -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Bool -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Bool -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "struct")
    Haskellish () (Pattern Bool -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Bool -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Bool -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "substruct")

instance Parse ([ControlPattern -> ControlPattern] -> ControlPattern -> ControlPattern) where
  parser :: H ([Pattern ValueMap -> Pattern ValueMap]
   -> Pattern ValueMap -> Pattern ValueMap)
parser =
    $(fromTidal "jux'")
      H ([Pattern ValueMap -> Pattern ValueMap]
   -> Pattern ValueMap -> Pattern ValueMap)
-> H ([Pattern ValueMap -> Pattern ValueMap]
      -> Pattern ValueMap -> Pattern ValueMap)
-> H ([Pattern ValueMap -> Pattern ValueMap]
      -> Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "juxcut'")
      H ([Pattern ValueMap -> Pattern ValueMap]
   -> Pattern ValueMap -> Pattern ValueMap)
-> H ([Pattern ValueMap -> Pattern ValueMap]
      -> Pattern ValueMap -> Pattern ValueMap)
-> H ([Pattern ValueMap -> Pattern ValueMap]
      -> Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H ([Pattern ValueMap -> Pattern ValueMap]
   -> Pattern ValueMap -> Pattern ValueMap)
forall a.
Parse ((Pattern a -> Pattern a) -> Pattern a -> Pattern a) =>
H ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)
lPatApatA_patA_patA

-- *** pathway leading to spread(etc) should be incorporated above

instance {-# OVERLAPPABLE #-} (Parse ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)) => Parse ([Pattern a -> Pattern a] -> Pattern a -> Pattern a) where
  parser :: H ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)
parser = H ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)
forall a.
Parse ((Pattern a -> Pattern a) -> Pattern a -> Pattern a) =>
H ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)
lPatApatA_patA_patA

lPatApatA_patA_patA :: (Parse ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)) => H ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)
lPatApatA_patA_patA :: forall a.
Parse ((Pattern a -> Pattern a) -> Pattern a -> Pattern a) =>
H ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)
lPatApatA_patA_patA =
  (H (((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
   -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a)
forall {a}.
H (((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
   -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H (((Pattern a -> Pattern a) -> Pattern a -> Pattern a) -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a)) H (((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
   -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)
forall a b.
Haskellish () (a -> b) -> Haskellish () a -> Haskellish () b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Haskellish () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser
    Haskellish () ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)
-> Haskellish
     () ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)
-> Haskellish
     () ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern Int
   -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a)
forall {a}.
H (Pattern Int
   -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H (Pattern Int -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a)) H (Pattern Int
   -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Int)
-> Haskellish
     () ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)
forall a b.
Haskellish () (a -> b) -> Haskellish () a -> Haskellish () b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Haskellish () (Pattern Int)
forall a. Parse a => H a
parser
    Haskellish () ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)
-> Haskellish
     () ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)
-> Haskellish
     () ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern Double
   -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a)
forall {a}.
H (Pattern Double
   -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H (Pattern Double -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a)) H (Pattern Double
   -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Double)
-> Haskellish
     () ([Pattern a -> Pattern a] -> Pattern a -> Pattern a)
forall a b.
Haskellish () (a -> b) -> Haskellish () a -> Haskellish () b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Haskellish () (Pattern Double)
forall a. Parse a => H a
parser

lp_p_p :: (Parse (Pattern a -> Pattern a -> Pattern a)) => H ([Pattern a] -> Pattern a -> Pattern a)
lp_p_p :: forall a.
Parse (Pattern a -> Pattern a -> Pattern a) =>
H ([Pattern a] -> Pattern a -> Pattern a)
lp_p_p = (H ((Pattern a -> Pattern a -> Pattern a)
   -> [Pattern a] -> Pattern a -> Pattern a)
forall {a}.
H ((Pattern a -> Pattern a -> Pattern a)
   -> [Pattern a] -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H ((Pattern a -> Pattern a -> Pattern a) -> [Pattern a] -> Pattern a -> Pattern a)) H ((Pattern a -> Pattern a -> Pattern a)
   -> [Pattern a] -> Pattern a -> Pattern a)
-> Haskellish () (Pattern a -> Pattern a -> Pattern a)
-> Haskellish () ([Pattern a] -> Pattern a -> Pattern a)
forall a b.
Haskellish () (a -> b) -> Haskellish () a -> Haskellish () b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Haskellish () (Pattern a -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser

instance Parse ([Pattern Double] -> Pattern a -> Pattern a) where
  parser :: H ([Pattern Double] -> Pattern a -> Pattern a)
parser = (H ((Pattern Double -> Pattern a -> Pattern a)
   -> [Pattern Double] -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H ((Pattern Double -> Pattern a -> Pattern a) -> [Pattern Double] -> Pattern a -> Pattern a)) H ((Pattern Double -> Pattern a -> Pattern a)
   -> [Pattern Double] -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Double -> Pattern a -> Pattern a)
-> H ([Pattern Double] -> Pattern a -> Pattern a)
forall a b.
Haskellish () (a -> b) -> Haskellish () a -> Haskellish () b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Haskellish () (Pattern Double -> Pattern a -> Pattern a)
forall a. H (Pattern Double -> Pattern a -> Pattern a)
pDouble_p_p

instance Parse ([Pattern Time] -> Pattern a -> Pattern a) where
  parser :: H ([Pattern Time] -> Pattern a -> Pattern a)
parser = (H ((Pattern Time -> Pattern a -> Pattern a)
   -> [Pattern Time] -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H ((Pattern Time -> Pattern a -> Pattern a) -> [Pattern Time] -> Pattern a -> Pattern a)) H ((Pattern Time -> Pattern a -> Pattern a)
   -> [Pattern Time] -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
-> H ([Pattern Time] -> Pattern a -> Pattern a)
forall a b.
Haskellish () (a -> b) -> Haskellish () a -> Haskellish () b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Haskellish () (Pattern Time -> Pattern a -> Pattern a)
forall a. H (Pattern Time -> Pattern a -> Pattern a)
pTime_p_p

lpInt_p_p :: H ([Pattern Int] -> Pattern a -> Pattern a)
lpInt_p_p :: forall a. H ([Pattern Int] -> Pattern a -> Pattern a)
lpInt_p_p =
  $(fromTidal "distrib")
    Haskellish () ([Pattern Int] -> Pattern a -> Pattern a)
-> Haskellish () ([Pattern Int] -> Pattern a -> Pattern a)
-> Haskellish () ([Pattern Int] -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H ((Pattern Int -> Pattern a -> Pattern a)
   -> [Pattern Int] -> Pattern a -> Pattern a)
forall {a}.
H ((Pattern Int -> Pattern a -> Pattern a)
   -> [Pattern Int] -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H ((Pattern Int -> Pattern a -> Pattern a) -> [Pattern Int] -> Pattern a -> Pattern a)) H ((Pattern Int -> Pattern a -> Pattern a)
   -> [Pattern Int] -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Int -> Pattern a -> Pattern a)
-> Haskellish () ([Pattern Int] -> Pattern a -> Pattern a)
forall a b.
Haskellish () (a -> b) -> Haskellish () a -> Haskellish () b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Haskellish () (Pattern Int -> Pattern a -> Pattern a)
forall a. H (Pattern Int -> Pattern a -> Pattern a)
pInt_p_p

instance Parse ([Time] -> Pattern a -> Pattern a) where
  parser :: H ([Time] -> Pattern a -> Pattern a)
parser = $(fromTidal "spaceOut")

-- pathway leading to spread(etc) should be incorporated here

instance Parse (Pattern Int -> ControlPattern -> ControlPattern) where
  parser :: H (Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
parser =
    $(fromTidal "chop")
      H (Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "striate")
      H (Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "gap")
      H (Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "randslice")
      H (Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "spin")
      H (Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern Int
   -> Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
forall a. Parse a => H a
parser :: H (Pattern Int -> Pattern Int -> ControlPattern -> ControlPattern)) H (Pattern Int
   -> Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
-> Haskellish () (Pattern Int)
-> H (Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Int)
forall a. Parse a => H a
parser

instance Parse (Pattern Double -> ControlPattern -> ControlPattern) where
  parser :: H (Pattern Double -> Pattern ValueMap -> Pattern ValueMap)
parser =
    (H (Pattern Int
   -> Pattern Double -> Pattern ValueMap -> Pattern ValueMap)
forall a. Parse a => H a
parser :: H (Pattern Int -> Pattern Double -> ControlPattern -> ControlPattern)) H (Pattern Int
   -> Pattern Double -> Pattern ValueMap -> Pattern ValueMap)
-> Haskellish () (Pattern Int)
-> H (Pattern Double -> Pattern ValueMap -> Pattern ValueMap)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Int)
forall a. Parse a => H a
parser
      H (Pattern Double -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Double -> Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern Time
   -> Pattern Double -> Pattern ValueMap -> Pattern ValueMap)
forall a. Parse a => H a
parser :: H (Pattern Rational -> Pattern Double -> ControlPattern -> ControlPattern)) H (Pattern Time
   -> Pattern Double -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Time)
-> H (Pattern Double -> Pattern ValueMap -> Pattern ValueMap)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H (Pattern Time)
forall a. Parse a => H a
parser

instance Parse (Pattern Time -> ControlPattern -> ControlPattern) where
  parser :: H (Pattern Time -> Pattern ValueMap -> Pattern ValueMap)
parser =
    $(fromTidal "hurry")
      H (Pattern Time -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Time -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Time -> Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "loopAt")
      H (Pattern Time -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Time -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Time -> Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "rolledBy")
      H (Pattern Time -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Time -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Time -> Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern Double
   -> Pattern Time -> Pattern ValueMap -> Pattern ValueMap)
forall a. Parse a => H a
parser :: H (Pattern Double -> Pattern Time -> ControlPattern -> ControlPattern)) H (Pattern Double
   -> Pattern Time -> Pattern ValueMap -> Pattern ValueMap)
-> Haskellish () (Pattern Double)
-> H (Pattern Time -> Pattern ValueMap -> Pattern ValueMap)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Double)
forall a. Parse a => H a
parser

instance Parse ((ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern) where
  parser :: H ((Pattern ValueMap -> Pattern ValueMap)
   -> Pattern ValueMap -> Pattern ValueMap)
parser =
    H ((Pattern ValueMap -> Pattern ValueMap)
   -> Pattern ValueMap -> Pattern ValueMap)
forall a. H ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
genericAppliedTransformations
      H ((Pattern ValueMap -> Pattern ValueMap)
   -> Pattern ValueMap -> Pattern ValueMap)
-> H ((Pattern ValueMap -> Pattern ValueMap)
      -> Pattern ValueMap -> Pattern ValueMap)
-> H ((Pattern ValueMap -> Pattern ValueMap)
      -> Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "jux")
      H ((Pattern ValueMap -> Pattern ValueMap)
   -> Pattern ValueMap -> Pattern ValueMap)
-> H ((Pattern ValueMap -> Pattern ValueMap)
      -> Pattern ValueMap -> Pattern ValueMap)
-> H ((Pattern ValueMap -> Pattern ValueMap)
      -> Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "juxcut")
      H ((Pattern ValueMap -> Pattern ValueMap)
   -> Pattern ValueMap -> Pattern ValueMap)
-> H ((Pattern ValueMap -> Pattern ValueMap)
      -> Pattern ValueMap -> Pattern ValueMap)
-> H ((Pattern ValueMap -> Pattern ValueMap)
      -> Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "jux4")
      H ((Pattern ValueMap -> Pattern ValueMap)
   -> Pattern ValueMap -> Pattern ValueMap)
-> H ((Pattern ValueMap -> Pattern ValueMap)
      -> Pattern ValueMap -> Pattern ValueMap)
-> H ((Pattern ValueMap -> Pattern ValueMap)
      -> Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> H (Pattern Double
   -> (Pattern ValueMap -> Pattern ValueMap)
   -> Pattern ValueMap
   -> Pattern ValueMap)
pDouble_controlMapToValueMap_controlMap_controlMap H (Pattern Double
   -> (Pattern ValueMap -> Pattern ValueMap)
   -> Pattern ValueMap
   -> Pattern ValueMap)
-> Haskellish () (Pattern Double)
-> H ((Pattern ValueMap -> Pattern ValueMap)
      -> Pattern ValueMap -> Pattern ValueMap)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Double)
forall a. Parse a => H a
parser

instance Parse ((Pattern Bool -> Pattern Bool) -> Pattern Bool -> Pattern Bool) where
  parser :: H ((Pattern Bool -> Pattern Bool) -> Pattern Bool -> Pattern Bool)
parser = H ((Pattern Bool -> Pattern Bool) -> Pattern Bool -> Pattern Bool)
forall a. H ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
genericAppliedTransformations

instance Parse ((Pattern String -> Pattern String) -> Pattern String -> Pattern String) where
  parser :: H ((Pattern [Char] -> Pattern [Char])
   -> Pattern [Char] -> Pattern [Char])
parser = H ((Pattern [Char] -> Pattern [Char])
   -> Pattern [Char] -> Pattern [Char])
forall a. H ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
genericAppliedTransformations

instance Parse ((Pattern Int -> Pattern Int) -> Pattern Int -> Pattern Int) where
  parser :: H ((Pattern Int -> Pattern Int) -> Pattern Int -> Pattern Int)
parser = H ((Pattern Int -> Pattern Int) -> Pattern Int -> Pattern Int)
forall a. H ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
genericAppliedTransformations

instance Parse ((Pattern Integer -> Pattern Integer) -> Pattern Integer -> Pattern Integer) where
  parser :: H ((Pattern Integer -> Pattern Integer)
   -> Pattern Integer -> Pattern Integer)
parser = H ((Pattern Integer -> Pattern Integer)
   -> Pattern Integer -> Pattern Integer)
forall a. H ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
genericAppliedTransformations

instance Parse ((Pattern Time -> Pattern Time) -> Pattern Time -> Pattern Time) where
  parser :: H ((Pattern Time -> Pattern Time) -> Pattern Time -> Pattern Time)
parser = H ((Pattern Time -> Pattern Time) -> Pattern Time -> Pattern Time)
forall a. H ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
genericAppliedTransformations

instance Parse ((Pattern Double -> Pattern Double) -> Pattern Double -> Pattern Double) where
  parser :: H ((Pattern Double -> Pattern Double)
   -> Pattern Double -> Pattern Double)
parser = H ((Pattern Double -> Pattern Double)
   -> Pattern Double -> Pattern Double)
forall a. H ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
genericAppliedTransformations

instance Parse ((Pattern Note -> Pattern Note) -> Pattern Note -> Pattern Note) where
  parser :: H ((Pattern Note -> Pattern Note) -> Pattern Note -> Pattern Note)
parser = H ((Pattern Note -> Pattern Note) -> Pattern Note -> Pattern Note)
forall a. H ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
genericAppliedTransformations

genericAppliedTransformations :: H ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
genericAppliedTransformations :: forall a. H ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
genericAppliedTransformations =
  $(fromHaskell "$")
    Haskellish () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "sometimes")
    Haskellish () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "often")
    Haskellish () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "rarely")
    Haskellish () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "almostNever")
    Haskellish () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "almostAlways")
    Haskellish () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "never")
    Haskellish () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "always")
    Haskellish () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "superimpose")
    Haskellish () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "someCycles")
    Haskellish () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern Time
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall {a}.
H (Pattern Time
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H (Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)) H (Pattern Time
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> H (Pattern Time)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H (Pattern Time)
forall a. Parse a => H a
parser
    Haskellish () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern Int
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall {a}.
H (Pattern Int
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H (Pattern Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)) H (Pattern Int
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Int)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Int)
forall a. Parse a => H a
parser
    Haskellish () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern Double
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall {a}.
H (Pattern Double
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H (Pattern Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)) H (Pattern Double
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Double)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Double)
forall a. Parse a => H a
parser
    Haskellish () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H ([Int] -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall {a}.
H ([Int] -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H ([Int] -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)) H ([Int] -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> H [Int]
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H [Int]
forall a. Parse a => H a
parser
    Haskellish () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H ((Time, Time)
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall {a}.
H ((Time, Time)
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H ((Time, Time) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)) H ((Time, Time)
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish () (Time, Time)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Time, Time)
forall a. Parse a => H a
parser
    Haskellish () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern Bool
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall {a}.
H (Pattern Bool
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H (Pattern Bool -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)) H (Pattern Bool
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> H (Pattern Bool)
-> Haskellish
     () ((Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H (Pattern Bool)
forall a. Parse a => H a
parser

instance Parse ([a] -> Pattern Int -> Pattern a) where
  parser :: H ([a] -> Pattern Int -> Pattern a)
parser = (H (Pattern Int -> [a] -> Pattern Int -> Pattern a)
forall a. Parse a => H a
parser :: H (Pattern Int -> [a] -> Pattern Int -> Pattern a)) H (Pattern Int -> [a] -> Pattern Int -> Pattern a)
-> Haskellish () (Pattern Int)
-> H ([a] -> Pattern Int -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Int)
forall a. Parse a => H a
parser

-- pathway leading to spread(etc) should be incorporated here

instance Parse (String -> Pattern Double -> ControlPattern) where
  parser :: H ([Char] -> Pattern Double -> Pattern ValueMap)
parser = $(fromTidal "pF")

instance Parse (String -> Pattern Note -> ControlPattern) where
  parser :: H ([Char] -> Pattern Note -> Pattern ValueMap)
parser = $(fromTidal "pN")

instance Parse (String -> Pattern Int -> ControlPattern) where
  parser :: H ([Char] -> Pattern Int -> Pattern ValueMap)
parser = $(fromTidal "pI")

instance Parse (String -> Pattern String -> ControlPattern) where
  parser :: H ([Char] -> Pattern [Char] -> Pattern ValueMap)
parser = $(fromTidal "pS")

instance Parse (Pattern Double -> [Pattern a] -> Pattern a) where
  parser :: H (Pattern Double -> [Pattern a] -> Pattern a)
parser = $(fromTidal "select")

instance Parse (Pattern Int -> [Pattern a] -> Pattern a) where
  parser :: H (Pattern Int -> [Pattern a] -> Pattern a)
parser = $(fromTidal "squeeze")

instance (Fractional a) => Parse (Pattern String -> Pattern Int -> Pattern a) where
  parser :: H (Pattern [Char] -> Pattern Int -> Pattern a)
parser = $(fromTidal "scale")

listNumA_pInt_pA :: (Num a) => H ([a] -> Pattern Int -> Pattern a)
listNumA_pInt_pA :: forall a. Num a => H ([a] -> Pattern Int -> Pattern a)
listNumA_pInt_pA = $(fromTidal "toScale")

-- *** pathway leading to spread(etc) should be incorporated here

pString_p_p :: H (Pattern String -> Pattern a -> Pattern a)
pString_p_p :: forall a. H (Pattern [Char] -> Pattern a -> Pattern a)
pString_p_p = $(fromTidal "arp")

instance Parse (ControlPattern -> [ControlPattern] -> ControlPattern) where
  parser :: H (Pattern ValueMap -> [Pattern ValueMap] -> Pattern ValueMap)
parser = (H (Time
   -> Pattern ValueMap -> [Pattern ValueMap] -> Pattern ValueMap)
forall a. Parse a => H a
parser :: H (Time -> ControlPattern -> [ControlPattern] -> ControlPattern)) H (Time
   -> Pattern ValueMap -> [Pattern ValueMap] -> Pattern ValueMap)
-> H Time
-> H (Pattern ValueMap -> [Pattern ValueMap] -> Pattern ValueMap)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H Time
forall a. Parse a => H a
parser

instance Parse (Pattern a -> [Pattern a -> Pattern a] -> Pattern a) where
  parser :: H (Pattern a -> [Pattern a -> Pattern a] -> Pattern a)
parser = (H (Time -> Pattern a -> [Pattern a -> Pattern a] -> Pattern a)
forall a. Parse a => H a
parser :: H (Time -> Pattern a -> [Pattern a -> Pattern a] -> Pattern a)) H (Time -> Pattern a -> [Pattern a -> Pattern a] -> Pattern a)
-> H Time -> H (Pattern a -> [Pattern a -> Pattern a] -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H Time
forall a. Parse a => H a
parser

pAB_pA_pB :: H ((Pattern a -> Pattern b) -> Pattern a -> Pattern b)
pAB_pA_pB :: forall a b. H ((Pattern a -> Pattern b) -> Pattern a -> Pattern b)
pAB_pA_pB = H (Pattern Time
   -> (Pattern a -> Pattern b) -> Pattern a -> Pattern b)
forall a b.
H (Pattern Time
   -> (Pattern a -> Pattern b) -> Pattern a -> Pattern b)
pTime_pAB_pA_pB H (Pattern Time
   -> (Pattern a -> Pattern b) -> Pattern a -> Pattern b)
-> H (Pattern Time)
-> Haskellish
     () ((Pattern a -> Pattern b) -> Pattern a -> Pattern b)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H (Pattern Time)
forall a. Parse a => H a
parser

pDouble_list_p :: (Parse a) => H (Pattern Double -> [a] -> Pattern a)
pDouble_list_p :: forall a. Parse a => H (Pattern Double -> [a] -> Pattern a)
pDouble_list_p = $(fromTidal "chooseBy")

pDouble_tupleApDouble_p :: (Parse a) => H (Pattern Double -> [(a, Pattern Double)] -> Pattern a)
pDouble_tupleApDouble_p :: forall a.
Parse a =>
H (Pattern Double -> [(a, Pattern Double)] -> Pattern a)
pDouble_tupleApDouble_p = $(fromTidal "wchooseBy")

instance Parse (String -> String -> Pattern String) where
  parser :: H ([Char] -> [Char] -> Pattern [Char])
parser = $(fromTidal "sseq")

instance Parse ([String] -> String -> Pattern String) where
  parser :: H ([[Char]] -> [Char] -> Pattern [Char])
parser = $(fromTidal "sseq'")

instance Parse (String -> String -> String) where
  parser :: H ([Char] -> [Char] -> [Char])
parser = (H (Int -> [Char] -> [Char] -> [Char])
forall a. Parse a => H a
parser :: H (Int -> String -> String -> String)) H (Int -> [Char] -> [Char] -> [Char])
-> H Int -> H ([Char] -> [Char] -> [Char])
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H Int
forall a. Parse a => H a
parser

floating_pFloating_pFloating :: (Floating a, Parse a) => H (a -> Pattern a -> Pattern a)
floating_pFloating_pFloating :: forall a. (Floating a, Parse a) => H (a -> Pattern a -> Pattern a)
floating_pFloating_pFloating = H (a -> a -> Pattern a -> Pattern a)
forall a. Floating a => H (a -> a -> Pattern a -> Pattern a)
floating_floating_pFloating_pFloating H (a -> a -> Pattern a -> Pattern a)
-> Haskellish () a -> Haskellish () (a -> Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () a
forall a. Parse a => H a
parser

realFrac_pRealFrac_pRealFrac :: (RealFrac a) => H (a -> Pattern a -> Pattern a)
realFrac_pRealFrac_pRealFrac :: forall a. RealFrac a => H (a -> Pattern a -> Pattern a)
realFrac_pRealFrac_pRealFrac = $(fromTidal "quantise")

instance Parse (Double -> String -> Pattern Double) where
  parser :: H (Double -> [Char] -> Pattern Double)
parser = $(fromTidal "cF")

-- * -> * -> * -> *

numTernaryTransformations :: (Num a) => H (Pattern a -> Pattern a -> Pattern a -> Pattern a)
numTernaryTransformations :: forall a.
Num a =>
H (Pattern a -> Pattern a -> Pattern a -> Pattern a)
numTernaryTransformations = $(fromTidal "range")

instance Parse (Pattern Int -> Pattern Int -> ControlPattern -> ControlPattern) where
  parser :: H (Pattern Int
   -> Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
parser =
    $(fromTidal "slice")
      H (Pattern Int
   -> Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Int
      -> Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Int
      -> Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "splice")
      H (Pattern Int
   -> Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Int
      -> Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Int
      -> Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "chew")
      H (Pattern Int
   -> Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Int
      -> Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Int
      -> Pattern Int -> Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "bite")

instance Parse (Time -> Time -> Pattern a -> Pattern a) where
  parser :: H (Time -> Time -> Pattern a -> Pattern a)
parser = $(fromTidal "playFor")

instance Parse (Pattern Time -> Pattern Time -> Pattern a -> Pattern a) where
  parser :: H (Pattern Time -> Pattern Time -> Pattern a -> Pattern a)
parser = $(fromTidal "swingBy")

pTime_p_p_p :: H (Pattern Time -> Pattern a -> Pattern a -> Pattern a)
pTime_p_p_p :: forall a. H (Pattern Time -> Pattern a -> Pattern a -> Pattern a)
pTime_p_p_p = $(fromTidal "wedge")

instance Parse (Pattern Bool -> Pattern a -> Pattern a -> Pattern a) where
  parser :: H (Pattern Bool -> Pattern a -> Pattern a -> Pattern a)
parser = $(fromTidal "sew")

instance Parse (Pattern Bool -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a) where
  parser :: H (Pattern Bool
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
parser = $(fromTidal "while")

pInt_pInt_p_p :: H (Pattern Int -> Pattern Int -> Pattern a -> Pattern a)
pInt_pInt_p_p :: forall a. H (Pattern Int -> Pattern Int -> Pattern a -> Pattern a)
pInt_pInt_p_p =
  $(fromTidal "euclid")
    Haskellish
  () (Pattern Int -> Pattern Int -> Pattern a -> Pattern a)
-> Haskellish
     () (Pattern Int -> Pattern Int -> Pattern a -> Pattern a)
-> Haskellish
     () (Pattern Int -> Pattern Int -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "euclidInv")
    Haskellish
  () (Pattern Int -> Pattern Int -> Pattern a -> Pattern a)
-> Haskellish
     () (Pattern Int -> Pattern Int -> Pattern a -> Pattern a)
-> Haskellish
     () (Pattern Int -> Pattern Int -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a)
forall {a}.
H (Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H (Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a)) H (Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a)
-> H Int
-> Haskellish
     () (Pattern Int -> Pattern Int -> Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H Int
forall a. Parse a => H a
parser

instance Parse (Int -> Pattern Double -> Pattern a -> Pattern a) where
  parser :: H (Int -> Pattern Double -> Pattern a -> Pattern a)
parser = $(fromTidal "degradeOverBy")

instance Parse ((a -> b -> Pattern c) -> [a] -> b -> Pattern c) where
  parser :: H ((a -> b -> Pattern c) -> [a] -> b -> Pattern c)
parser =
    $(fromTidal "spread")
      H ((a -> b -> Pattern c) -> [a] -> b -> Pattern c)
-> H ((a -> b -> Pattern c) -> [a] -> b -> Pattern c)
-> H ((a -> b -> Pattern c) -> [a] -> b -> Pattern c)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "slowspread")
      H ((a -> b -> Pattern c) -> [a] -> b -> Pattern c)
-> H ((a -> b -> Pattern c) -> [a] -> b -> Pattern c)
-> H ((a -> b -> Pattern c) -> [a] -> b -> Pattern c)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "fastspread")
      H ((a -> b -> Pattern c) -> [a] -> b -> Pattern c)
-> H ((a -> b -> Pattern c) -> [a] -> b -> Pattern c)
-> H ((a -> b -> Pattern c) -> [a] -> b -> Pattern c)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "spreadChoose")
      H ((a -> b -> Pattern c) -> [a] -> b -> Pattern c)
-> H ((a -> b -> Pattern c) -> [a] -> b -> Pattern c)
-> H ((a -> b -> Pattern c) -> [a] -> b -> Pattern c)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "spreadr")

pInt_p_p_p :: H (Pattern Int -> Pattern a -> Pattern a -> Pattern a)
pInt_p_p_p :: forall a. H (Pattern Int -> Pattern a -> Pattern a -> Pattern a)
pInt_p_p_p = (H (Pattern Int
   -> Pattern Int -> Pattern a -> Pattern a -> Pattern a)
forall {a}.
H (Pattern Int
   -> Pattern Int -> Pattern a -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H (Pattern Int -> Pattern Int -> Pattern a -> Pattern a -> Pattern a)) H (Pattern Int
   -> Pattern Int -> Pattern a -> Pattern a -> Pattern a)
-> Haskellish () (Pattern Int)
-> Haskellish
     () (Pattern Int -> Pattern a -> Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Int)
forall a. Parse a => H a
parser

pBool_p_p_p :: H (Pattern Bool -> Pattern a -> Pattern a -> Pattern a)
pBool_p_p_p :: forall a. H (Pattern Bool -> Pattern a -> Pattern a -> Pattern a)
pBool_p_p_p = $(fromTidal "stitch")

instance Parse (Pattern Int -> Pattern Double -> ControlPattern -> ControlPattern) where
  parser :: H (Pattern Int
   -> Pattern Double -> Pattern ValueMap -> Pattern ValueMap)
parser = $(fromTidal "striate'") H (Pattern Int
   -> Pattern Double -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Int
      -> Pattern Double -> Pattern ValueMap -> Pattern ValueMap)
-> H (Pattern Int
      -> Pattern Double -> Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "striateBy")

instance Parse (Pattern Double -> Pattern Time -> ControlPattern -> ControlPattern) where
  parser :: H (Pattern Double
   -> Pattern Time -> Pattern ValueMap -> Pattern ValueMap)
parser = (H (Pattern Integer
   -> Pattern Double
   -> Pattern Time
   -> Pattern ValueMap
   -> Pattern ValueMap)
forall a. Parse a => H a
parser :: H (Pattern Integer -> Pattern Double -> Pattern Time -> ControlPattern -> ControlPattern)) H (Pattern Integer
   -> Pattern Double
   -> Pattern Time
   -> Pattern ValueMap
   -> Pattern ValueMap)
-> H (Pattern Integer)
-> H (Pattern Double
      -> Pattern Time -> Pattern ValueMap -> Pattern ValueMap)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H (Pattern Integer)
forall a. Parse a => H a
parser

instance Parse (Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a) where
  parser :: H (Pattern Time
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
parser =
    $(fromTidal "off")
      H (Pattern Time
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> H (Pattern Time
      -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> H (Pattern Time
      -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "plyWith")
      H (Pattern Time
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> H (Pattern Time
      -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> H (Pattern Time
      -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern Time
   -> Pattern Time
   -> (Pattern a -> Pattern a)
   -> Pattern a
   -> Pattern a)
forall a. Parse a => H a
parser :: H (Pattern Time -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)) H (Pattern Time
   -> Pattern Time
   -> (Pattern a -> Pattern a)
   -> Pattern a
   -> Pattern a)
-> H (Pattern Time)
-> H (Pattern Time
      -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H (Pattern Time)
forall a. Parse a => H a
parser
      H (Pattern Time
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> H (Pattern Time
      -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> H (Pattern Time
      -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern Int
   -> Pattern Time
   -> (Pattern a -> Pattern a)
   -> Pattern a
   -> Pattern a)
forall a. Parse a => H a
parser :: H (Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)) H (Pattern Int
   -> Pattern Time
   -> (Pattern a -> Pattern a)
   -> Pattern a
   -> Pattern a)
-> Haskellish () (Pattern Int)
-> H (Pattern Time
      -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Int)
forall a. Parse a => H a
parser

pTime_pAB_pA_pB :: H (Pattern Time -> (Pattern a -> Pattern b) -> Pattern a -> Pattern b)
pTime_pAB_pA_pB :: forall a b.
H (Pattern Time
   -> (Pattern a -> Pattern b) -> Pattern a -> Pattern b)
pTime_pAB_pA_pB =
  $(fromTidal "inside")
    Haskellish
  ()
  (Pattern Time
   -> (Pattern a -> Pattern b) -> Pattern a -> Pattern b)
-> Haskellish
     ()
     (Pattern Time
      -> (Pattern a -> Pattern b) -> Pattern a -> Pattern b)
-> Haskellish
     ()
     (Pattern Time
      -> (Pattern a -> Pattern b) -> Pattern a -> Pattern b)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "outside")

instance Parse (Pattern Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a) where
  parser :: H (Pattern Int
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
parser =
    $(fromTidal "every")
      H (Pattern Int
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> H (Pattern Int
      -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> H (Pattern Int
      -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "plyWith")
      H (Pattern Int
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> H (Pattern Int
      -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> H (Pattern Int
      -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "chunk")
      H (Pattern Int
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> H (Pattern Int
      -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> H (Pattern Int
      -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "chunk'")
      H (Pattern Int
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> H (Pattern Int
      -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> H (Pattern Int
      -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern Int
   -> Pattern Int
   -> (Pattern a -> Pattern a)
   -> Pattern a
   -> Pattern a)
forall a. Parse a => H a
parser :: H (Pattern Int -> Pattern Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)) H (Pattern Int
   -> Pattern Int
   -> (Pattern a -> Pattern a)
   -> Pattern a
   -> Pattern a)
-> Haskellish () (Pattern Int)
-> H (Pattern Int
      -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> Haskellish () (Pattern Int)
forall a. Parse a => H a
parser -- note: chunk' is actually generalized to Integral, but not clear what non-Int cases would be

instance Parse (Pattern Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a) where
  parser :: H (Pattern Double
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
parser =
    $(fromTidal "sometimesBy")
      H (Pattern Double
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> H (Pattern Double
      -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> H (Pattern Double
      -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "someCyclesBy")
      H (Pattern Double
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> H (Pattern Double
      -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
-> H (Pattern Double
      -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "plyWith")

pDouble_controlMapToValueMap_controlMap_controlMap :: H (Pattern Double -> (Pattern ValueMap -> Pattern ValueMap) -> Pattern ValueMap -> Pattern ValueMap)
pDouble_controlMapToValueMap_controlMap_controlMap :: H (Pattern Double
   -> (Pattern ValueMap -> Pattern ValueMap)
   -> Pattern ValueMap
   -> Pattern ValueMap)
pDouble_controlMapToValueMap_controlMap_controlMap =
  $(fromTidal "juxBy")
    H (Pattern Double
   -> (Pattern ValueMap -> Pattern ValueMap)
   -> Pattern ValueMap
   -> Pattern ValueMap)
-> H (Pattern Double
      -> (Pattern ValueMap -> Pattern ValueMap)
      -> Pattern ValueMap
      -> Pattern ValueMap)
-> H (Pattern Double
      -> (Pattern ValueMap -> Pattern ValueMap)
      -> Pattern ValueMap
      -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H (Pattern Double
   -> (Pattern ValueMap -> Pattern ValueMap)
   -> Pattern ValueMap
   -> Pattern ValueMap)
forall a. Parse a => H a
parser :: H (Pattern Double -> (Pattern ValueMap -> Pattern ValueMap) -> Pattern ValueMap -> Pattern ValueMap))

instance Parse ((ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern) where
  parser :: H ((Pattern ValueMap -> Pattern ValueMap)
   -> Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
parser =
    $(fromTidal "fix")
      H ((Pattern ValueMap -> Pattern ValueMap)
   -> Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
-> H ((Pattern ValueMap -> Pattern ValueMap)
      -> Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
-> H ((Pattern ValueMap -> Pattern ValueMap)
      -> Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "unfix")
      H ((Pattern ValueMap -> Pattern ValueMap)
   -> Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
-> H ((Pattern ValueMap -> Pattern ValueMap)
      -> Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
-> H ((Pattern ValueMap -> Pattern ValueMap)
      -> Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (H ((Pattern ValueMap -> Pattern ValueMap)
   -> (Pattern ValueMap -> Pattern ValueMap)
   -> Pattern ValueMap
   -> Pattern ValueMap
   -> Pattern ValueMap)
forall a. Parse a => H a
parser :: H ((ControlPattern -> ControlPattern) -> (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern))
        H ((Pattern ValueMap -> Pattern ValueMap)
   -> (Pattern ValueMap -> Pattern ValueMap)
   -> Pattern ValueMap
   -> Pattern ValueMap
   -> Pattern ValueMap)
-> H (Pattern ValueMap -> Pattern ValueMap)
-> H ((Pattern ValueMap -> Pattern ValueMap)
      -> Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H (Pattern ValueMap -> Pattern ValueMap)
forall a. Parse a => H a
parser
        H ((Pattern ValueMap -> Pattern ValueMap)
   -> Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
-> Text
-> H ((Pattern ValueMap -> Pattern ValueMap)
      -> Pattern ValueMap -> Pattern ValueMap -> Pattern ValueMap)
forall st a. Haskellish st a -> Text -> Haskellish st a
<?> Text
"expected (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern"

instance Parse ([Int] -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a) where
  parser :: H ([Int] -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
parser = $(fromTidal "foldEvery")

instance Parse ((Time, Time) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a) where
  parser :: H ((Time, Time)
   -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a)
parser = $(fromTidal "within")

instance Parse (Pattern Int -> [a] -> Pattern Int -> Pattern a) where
  parser :: H (Pattern Int -> [a] -> Pattern Int -> Pattern a)
parser = $(fromTidal "fit")

instance Parse (Pattern Int -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a) where
  parser :: H (Pattern Int
   -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a)
parser = $(fromTidal "pickF")

instance Parse (Time -> ControlPattern -> [ControlPattern] -> ControlPattern) where
  parser :: H (Time
   -> Pattern ValueMap -> [Pattern ValueMap] -> Pattern ValueMap)
parser = $(fromTidal "weave")

instance Parse (Time -> Pattern a -> [Pattern a -> Pattern a] -> Pattern a) where
  parser :: H (Time -> Pattern a -> [Pattern a -> Pattern a] -> Pattern a)
parser = $(fromTidal "weaveWith")

instance Parse (Pattern Double -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a) where
  parser :: H (Pattern Double
   -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a)
parser = $(fromTidal "selectF")

instance Parse (Int -> String -> String -> String) where
  parser :: H (Int -> [Char] -> [Char] -> [Char])
parser = $(fromTidal "lindenmayer")

floating_floating_pFloating_pFloating :: (Floating a) => H (a -> a -> Pattern a -> Pattern a)
floating_floating_pFloating_pFloating :: forall a. Floating a => H (a -> a -> Pattern a -> Pattern a)
floating_floating_pFloating_pFloating = $(fromTidal "rangex")

-- note: rangex actually generalized to Functor a rather than Pattern a, so we are over-specializing

integral_time_pA_pA :: (Integral i) => H (i -> Time -> Pattern a -> Pattern a)
integral_time_pA_pA :: forall i a. Integral i => H (i -> Time -> Pattern a -> Pattern a)
integral_time_pA_pA = $(fromTidal "stutter")

instance Parse (Pattern Rational -> Pattern Double -> ControlPattern -> ControlPattern) where
  parser :: H (Pattern Time
   -> Pattern Double -> Pattern ValueMap -> Pattern ValueMap)
parser = (H (Pattern Integer
   -> Pattern Time
   -> Pattern Double
   -> Pattern ValueMap
   -> Pattern ValueMap)
forall a. Parse a => H a
parser :: H (Pattern Integer -> Pattern Rational -> Pattern Double -> ControlPattern -> ControlPattern)) H (Pattern Integer
   -> Pattern Time
   -> Pattern Double
   -> Pattern ValueMap
   -> Pattern ValueMap)
-> H (Pattern Integer)
-> H (Pattern Time
      -> Pattern Double -> Pattern ValueMap -> Pattern ValueMap)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H (Pattern Integer)
forall a. Parse a => H a
parser

-- * -> * -> * -> * -> *

instance Parse (Pattern Int -> Pattern Int -> Pattern a -> Pattern a -> Pattern a) where
  parser :: H (Pattern Int
   -> Pattern Int -> Pattern a -> Pattern a -> Pattern a)
parser = $(fromTidal "euclidFull")

instance Parse (Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a) where
  parser :: H (Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a)
parser = (H (Pattern Time
   -> Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a)
forall a. Parse a => H a
parser :: H (Pattern Time -> Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a)) H (Pattern Time
   -> Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a)
-> H (Pattern Time)
-> H (Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a)
forall st a b.
Haskellish st (a -> b) -> Haskellish st a -> Haskellish st b
<*!> H (Pattern Time)
forall a. Parse a => H a
parser

instance Parse (Pattern Integer -> Pattern Double -> Pattern Time -> ControlPattern -> ControlPattern) where
  parser :: H (Pattern Integer
   -> Pattern Double
   -> Pattern Time
   -> Pattern ValueMap
   -> Pattern ValueMap)
parser = $(fromTidal "stut")

instance Parse (Pattern Integer -> Pattern Rational -> Pattern Double -> ControlPattern -> ControlPattern) where
  parser :: H (Pattern Integer
   -> Pattern Time
   -> Pattern Double
   -> Pattern ValueMap
   -> Pattern ValueMap)
parser = $(fromTidal "echo")

instance Parse (Pattern Int -> Pattern Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a) where
  parser :: H (Pattern Int
   -> Pattern Int
   -> (Pattern a -> Pattern a)
   -> Pattern a
   -> Pattern a)
parser = $(fromTidal "every'")

instance Parse (Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a) where
  parser :: H (Pattern Int
   -> Pattern Time
   -> (Pattern a -> Pattern a)
   -> Pattern a
   -> Pattern a)
parser =
    $(fromTidal "stutWith")
      H (Pattern Int
   -> Pattern Time
   -> (Pattern a -> Pattern a)
   -> Pattern a
   -> Pattern a)
-> H (Pattern Int
      -> Pattern Time
      -> (Pattern a -> Pattern a)
      -> Pattern a
      -> Pattern a)
-> H (Pattern Int
      -> Pattern Time
      -> (Pattern a -> Pattern a)
      -> Pattern a
      -> Pattern a)
forall a. Haskellish () a -> Haskellish () a -> Haskellish () a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> $(fromTidal "echoWith")

instance Parse (Pattern Time -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a) where
  parser :: H (Pattern Time
   -> Pattern Time
   -> (Pattern a -> Pattern a)
   -> Pattern a
   -> Pattern a)
parser = $(fromTidal "whenmod")

instance Parse ((ControlPattern -> ControlPattern) -> (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern) where
  parser :: H ((Pattern ValueMap -> Pattern ValueMap)
   -> (Pattern ValueMap -> Pattern ValueMap)
   -> Pattern ValueMap
   -> Pattern ValueMap
   -> Pattern ValueMap)
parser = $(fromTidal "contrast")

-- * -> * -> * -> * -> * -> *

instance Parse (Pattern Time -> Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a) where
  parser :: H (Pattern Time
   -> Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a)
parser = $(fromTidal "fit'")