Feature requests for tidal-parse

[yaxu]

An issue for collecting requests for missing functions, operators and syntax for tidal-parse (formerly known as minitidal)

[yaxu]

Functions:

• [x] mask
• [x] struct

Desirable syntax:

• [ ] Function composition e.g. jux (fast 2 . rev) ...

Potentially useful syntax:

• [ ] Lambda e.g. \x -> fast 2 $ rev x

[yaxu]

This doesn't work, but only because id is missing from tidal-parse:

spread ($) [id, rev, fast 2]

I could add it to genericTransformations, but that isn't generic enough, as id is a -> a, not Pattern a -> Pattern a. So @dktr0 the question is, how low do we want to go?

[dktr0]

I would just add it to genericTransformations for now, since I don't think there are currently any other places (in tidal-parse) where a -> a would be used. And later rework.

[yaxu]

@dktr0 Ok, I suppose there are not many non-patterned parameters left, so a -> a is pretty much out of scope anyway

[yaxu]

One liner to get a list of functions currently supported by tidal-parse:

perl -e 'undef $/; $all = <>; while ($all =~ /fromTidal\s*"([^"]+)"/og) {print "$1\n"}' Parse.hs |sort > current.txt

Hacky one liner to get a list of functions in a module with type:

echo ":browse Sound.Tidal.UI" | ghci |perl -e 'undef $/; $_ = <>; s/^GHC.*?\n//g; s/Prelude> //g; s/\n +/ /go; s/(?:\n|^)(\()Sound\.Tidal\.\w+?\./\n$1/sg; s/\nLeaving.*//; s/^\n//; print'|egrep -v '^_' > ui.txt

Another hack to make a list of missing functions:

perl -e '@ui = `cat ui.txt`; chomp @ui; @current = `cat current.txt`; chomp @current; foreach $type (@ui) {$type =~ s/Sound\.Tidal\.\w+\.//g; $type =~ /^(\S+) (.*)/; $func = $1; $type = $2; if (not (grep {$func eq $_} @current)) {print "- [ ] **$func** `$type`\n"}}'

[yaxu]

Here's a version of the above (now deleted) lists combined, with most internal functions removed, and sorted by type, not name

• [x] (|**|) :: (Applicative a, Floating b) => a b -> a b -> a b
• [x] (|/|) :: (Applicative a, Fractional b) => a b -> a b -> a b
• [x] *(||)** :: (Applicative a, Num b) => a b -> a b -> a b
• [x] (|+|) :: (Applicative a, Num b) => a b -> a b -> a b
• [x] (|-|) :: (Applicative a, Num b) => a b -> a b -> a b
• [x] (|%|) :: (Applicative a, Real b) => a b -> a b -> a b
• [x] (|<|) :: (Applicative a, Unionable b) => a b -> a b -> a b
• [x] (|>|) :: (Applicative a, Unionable b) => a b -> a b -> a b
• [ ] contrast :: (ControlPattern -> ControlPattern) -> (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern
• [ ] fix :: (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern
• [ ] unfix :: (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern
• [ ] fixRange :: (ControlPattern -> Pattern ControlMap) -> Pattern (Data.Map.Internal.Map String (Value, Value)) -> ControlPattern -> Pattern ControlMap
• [ ] unfixRange :: (ControlPattern -> Pattern ControlMap) -> Pattern (Data.Map.Internal.Map String (Value, Value)) -> ControlPattern -> Pattern ControlMap
• [ ] contrastRange :: (ControlPattern -> Pattern a) -> (ControlPattern -> Pattern a) -> Pattern (Data.Map.Internal.Map String (Value, Value)) -> ControlPattern -> Pattern a
• [x] scan :: (Enum a, Num a) => Pattern a -> Pattern a
• [ ] cP :: (Enumerable a, Parseable a) => String -> Pattern a
• [ ] rangex :: (Functor f, Floating b) => b -> b -> f b -> f b
• [ ] quantise :: (Functor f, RealFrac b) => b -> f b -> f b
• [ ] ifp :: (Int -> Bool) -> (Pattern a -> Pattern a) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
• [ ] when :: (Int -> Bool) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
• [ ] jux4 :: (Pattern ControlMap -> Pattern ControlMap) -> Pattern ControlMap -> Pattern ControlMap
• [ ] juxcut :: (Pattern ControlMap -> Pattern ControlMap) -> Pattern ControlMap -> Pattern ControlMap
• [x] somecycles :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
• [ ] whenT :: (Time -> Bool) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
• [ ] sig :: (Time -> a) -> Pattern a
• [ ] within' :: (Time, Time) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
• [ ] revArc :: (Time, Time) -> Pattern a -> Pattern a
• [ ] arpWith :: ([EventF (ArcF Time) a] -> [EventF (ArcF Time) b]) -> Pattern a -> Pattern b
• [ ] contrastBy :: (a -> Value -> Bool) -> (ControlPattern -> Pattern b) -> (ControlPattern -> Pattern b) -> Pattern (Data.Map.Internal.Map String a) -> Pattern (Data.Map.Internal.Map String Value) -> Pattern b
• [ ] spreadChoose :: (t -> t1 -> Pattern b) -> [t] -> t1 -> Pattern b
• [ ] spreadr :: (t -> t1 -> Pattern b) -> [t] -> t1 -> Pattern b
• [ ] (|++|) :: Applicative a => a String -> a String -> a String
• [ ] samples' :: Applicative f => f String -> f Int -> f String
• [ ] withinArc :: Arc -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
• [ ] zoomArc :: Arc -> Pattern a -> Pattern a
• [ ] cB :: Bool -> String -> Pattern Bool
• [ ] interlace :: ControlPattern -> ControlPattern -> ControlPattern
• [ ] somecyclesBy :: Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
• [ ] cF :: Double -> String -> Pattern Double
• [ ] swap :: Eq a => [(a, b)] -> Pattern a -> Pattern b
• [x] (**|) :: Floating a => Pattern a -> Pattern a -> Pattern a
• [x] (**) :: Floating a => Pattern a -> Pattern a -> Pattern a
• [x] (/|) :: Fractional a => Pattern a -> Pattern a -> Pattern a
• [x] (|/) :: Fractional a => Pattern a -> Pattern a -> Pattern a
• [ ] msec :: Fractional a => Pattern a -> Pattern a
• [ ] sec :: Fractional a => Pattern a -> Pattern a
• [ ] smooth :: Fractional a => Pattern a -> Pattern a
• [ ] inv :: Functor f => f Bool -> f Bool
• [ ] snowball :: Int -> (Pattern a -> Pattern a -> Pattern a) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
• [ ] soak :: Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
• [ ] runWith :: Int -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b
• [ ] splice :: Int -> Pattern Int -> ControlPattern -> Pattern (Data.Map.Internal.Map String Value)
• [ ] bite :: Int -> Pattern Int -> Pattern a -> Pattern a
• [ ] randStruct :: Int -> Pattern Int
• [ ] randrun :: Int -> Pattern Int
• [ ] deconstruct :: Int -> Pattern String -> String
• [ ] randArcs :: Int -> Pattern [Arc]
• [ ] tabby :: Int -> Pattern a -> Pattern a -> Pattern a
• [ ] fastRepeatCycles :: Int -> Pattern a -> Pattern a
• [ ] cI :: Int -> String -> Pattern Int
• [ ] lindenmayer :: Int -> String -> String -> String
• [ ] smash' :: Int -> [Pattern Time] -> ControlPattern -> Pattern ControlMap
• [ ] runMarkov :: Int -> [[Double]] -> Int -> Time -> [Int]
• [ ] chunk' :: Integral a => a -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b
• [ ] runWith' :: Integral a => a -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b
• [ ] stutter :: Integral i => i -> Time -> Pattern a -> Pattern a
• [ ] spread' :: Monad m => (a -> b -> m c) -> m a -> b -> m c
• [ ] toScale' :: Num a => Int -> [a] -> Pattern Int -> Pattern a
• [ ] offadd :: Num a => Pattern Time -> Pattern a -> Pattern a -> Pattern a
• [x] *(|)** :: Num a => Pattern a -> Pattern a -> Pattern a
• [x] (+|) :: Num a => Pattern a -> Pattern a -> Pattern a
• [x] (-|) :: Num a => Pattern a -> Pattern a -> Pattern a
• [x] *(|)** :: Num a => Pattern a -> Pattern a -> Pattern a
• [x] (|+) :: Num a => Pattern a -> Pattern a -> Pattern a
• [x] (|-) :: Num a => Pattern a -> Pattern a -> Pattern a
• [ ] toScale :: Num a => [a] -> Pattern Int -> Pattern a
• [ ] lindenmayerI :: Num b => Int -> String -> String -> [b]
• [x] rot :: Ord a => Pattern Int -> Pattern a -> Pattern a
• [ ] *(>)** :: Pattern (a -> b) -> Pattern a -> Pattern b
• [ ] *(<)** :: Pattern (a -> b) -> Pattern a -> Pattern b
• [x] stitch :: Pattern Bool -> Pattern a -> Pattern a -> Pattern a
• [ ] ghost :: Pattern ControlMap -> Pattern ControlMap
• [ ] squeezeJoinUp :: Pattern ControlPattern -> ControlPattern
• [ ] juxBy :: Pattern Double -> (Pattern ControlMap -> Pattern ControlMap) -> Pattern ControlMap -> Pattern ControlMap
• [ ] perlin2With :: Pattern Double -> Pattern Double -> Pattern Double
• [ ] perlin2 :: Pattern Double -> Pattern Double
• [ ] perlinWith :: Pattern Double -> Pattern Double
• [ ] wchooseBy :: Pattern Double -> [(a, Double)] -> Pattern a
• [ ] selectF :: Pattern Double -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a
• [ ] select :: Pattern Double -> [Pattern a] -> Pattern a
• [ ] chooseBy :: Pattern Double -> [a] -> Pattern a
• [x] envEq :: Pattern Double
• [x] envEqR :: Pattern Double
• [x] envL :: Pattern Double
• [x] envLR :: Pattern Double
• [x] perlin :: Pattern Double
• [ ] in0 :: Pattern Double (and friends)
• [x] gap :: Pattern Int -> ControlPattern -> ControlPattern
• [x] randslice :: Pattern Int -> ControlPattern -> ControlPattern
• [x] spin :: Pattern Int -> ControlPattern -> ControlPattern
• [ ] striateBy :: Pattern Int -> Pattern Double -> ControlPattern -> ControlPattern
• [x] slice :: Pattern Int -> Pattern Int -> ControlPattern -> ControlPattern
• [ ] euclidOffBool :: Pattern Int -> Pattern Int -> Pattern Int -> Pattern Bool -> Pattern Bool
• [ ] eoff :: Pattern Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a
• [ ] euclidOff :: Pattern Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a
• [ ] markovPat :: Pattern Int -> Pattern Int -> [[Double]] -> Pattern Int
• [ ] stut' :: Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
• [ ] stutWith :: Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
• [ ] stripe :: Pattern Int -> Pattern a -> Pattern a
• [ ] smash :: Pattern Int -> [Pattern Time] -> ControlPattern -> Pattern ControlMap
• [ ] pickF :: Pattern Int -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a
• [ ] squeeze :: Pattern Int -> [Pattern a] -> Pattern a
• [ ] (++|) :: Pattern String -> Pattern String -> Pattern String
• [ ] (|++) :: Pattern String -> Pattern String -> Pattern String
• [ ] arp :: Pattern String -> Pattern a -> Pattern a
• [ ] inside :: Pattern Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a
• [ ] outside :: Pattern Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a
• [ ] loopAt :: Pattern Time -> ControlPattern -> ControlPattern
• [x] (<~) :: Pattern Time -> Pattern a -> Pattern a
• [x] (~>) :: Pattern Time -> Pattern a -> Pattern a
• [ ] fastSqueeze :: Pattern Time -> Pattern a -> Pattern a
• [ ] slowSqueeze :: Pattern Time -> Pattern a -> Pattern a
• [ ] flatpat :: Pattern [a] -> Pattern a
• [ ] (<>) :: Pattern a -> Pattern a -> Pattern a
• [ ] arpeggiate :: Pattern a -> Pattern a
• [ ] arpg :: Pattern a -> Pattern a
• [ ] mono :: Pattern a -> Pattern a
• [ ] cR :: Rational -> String -> Pattern Rational
• [x] (%|) :: Real a => Pattern a -> Pattern a -> Pattern a
• [x] (|%) :: Real a => Pattern a -> Pattern a -> Pattern a
• [ ] index :: Real b => b -> Pattern b -> Pattern c -> Pattern c
• [ ] permstep :: RealFrac b => Int -> [a] -> Pattern b -> Pattern a
• [ ] qt :: Show a => a -> Pattern b -> Pattern b
• [ ] qtrigger :: Show a => a -> Pattern b -> Pattern b
• [ ] reset :: Show a => a -> Pattern b -> Pattern b
• [ ] trigger :: Show a => a -> Pattern b -> Pattern b
• [ ] pick :: String -> Int -> String
• [ ] cB0 :: String -> Pattern Bool
• [ ] cB_ :: String -> Pattern Bool
• [ ] cF0 :: String -> Pattern Double
• [ ] cF_ :: String -> Pattern Double
• [ ] cI0 :: String -> Pattern Int
• [ ] cI_ :: String -> Pattern Int
• [ ] cR0 :: String -> Pattern Rational
• [ ] cR_ :: String -> Pattern Rational
• [ ] cS0 :: String -> Pattern String
• [ ] cS_ :: String -> Pattern String
• [ ] cT0 :: String -> Pattern Time
• [ ] cT_ :: String -> Pattern Time
• [ ] cS :: String -> String -> Pattern String
• [ ] step :: String -> String -> Pattern String
• [ ] parseLMRule' :: String -> [(Char, String)]
• [ ] parseLMRule :: String -> [(String, String)]
• [ ] ghost'' :: Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
• [ ] weave :: Time -> ControlPattern -> [ControlPattern] -> ControlPattern
• [ ] ghost' :: Time -> Pattern ControlMap -> Pattern ControlMap
• [ ] ur :: Time -> Pattern String -> [(String, Pattern a)] -> [(String, Pattern a -> Pattern a)] -> Pattern a
• [ ] wedge :: Time -> Pattern a -> Pattern a -> Pattern a
• [ ] double :: Time -> Pattern a -> Pattern a
• [ ] echo :: Time -> Pattern a -> Pattern a
• [ ] fadeIn :: Time -> Pattern a -> Pattern a
• [ ] fadeOut :: Time -> Pattern a -> Pattern a
• [ ] quad :: Time -> Pattern a -> Pattern a
• [ ] triple :: Time -> Pattern a -> Pattern a
• [ ] weave' :: Time -> Pattern a -> [Pattern a -> Pattern a] -> Pattern a
• [ ] weaveWith :: Time -> Pattern a -> [Pattern a -> Pattern a] -> Pattern a
• [ ] cT :: Time -> String -> Pattern Time
• [ ] fadeInFrom :: Time -> Time -> Pattern a -> Pattern a
• [ ] fadeOutFrom :: Time -> Time -> Pattern a -> Pattern a
• [x] (<|) :: Unionable a => Pattern a -> Pattern a -> Pattern a
• [x] (>|) :: Unionable a => Pattern a -> Pattern a -> Pattern a
• [x] (|<) :: Unionable a => Pattern a -> Pattern a -> Pattern a
• [x] (|>) :: Unionable a => Pattern a -> Pattern a -> Pattern a
• [ ] stackwith :: Unionable a => Pattern a -> [Pattern a] -> Pattern a
• [x] (#) :: Unionable b => Pattern b -> Pattern b -> Pattern b
• [ ] inhabit :: [(String, Pattern a)] -> Pattern String -> Pattern a
• [ ] steps :: [(String, String)] -> Pattern String
• [ ] timeCat :: [(Time, Pattern a)] -> Pattern a
• [ ] seqP :: [(Time, Time, Pattern a)] -> Pattern a
• [ ] seqPLoop :: [(Time, Time, Pattern a)] -> Pattern a
• [ ] wchoose :: [(a, Double)] -> Pattern a
• [ ] enclosingArc :: [Arc] -> Arc
• [ ] fromMaybes :: [Maybe a] -> Pattern a
• [x] fastCat :: [Pattern a] -> Pattern a
• [x] slowCat :: [Pattern a] -> Pattern a
• [ ] step' :: [String] -> String -> Pattern String
• [ ] layer :: [a -> Pattern b] -> a -> Pattern b
• [ ] spreadf :: [a -> Pattern b] -> a -> Pattern b
• [ ] fastFromList :: [a] -> Pattern a
• [ ] fromList :: [a] -> Pattern a
• [ ] jux' :: [t -> Pattern ControlMap] -> t -> Pattern ControlMap
• [ ] juxcut' :: [t -> Pattern ControlMap] -> t -> Pattern ControlMap

Made with

perl -e '@foo = `cat list.txt`; chomp @foo; @bar = map {$_ =~ /(::.*)/; [$_,$1]} @foo; @qux = sort {$a->[1] cmp $b->[1] || $a->[0] cmp $b->[0]} @bar; @final = map {$_->[0]} @qux; foreach $line (@qux) {print "$line->[0]\n"}'

[dktr0]

Well that's post-modern (using Perl to analyze Haskell projects)!

[dktr0]

Not to be nitpicky but it does seem to identify some things as missing that are not missing, especially operators like |/|

[yaxu]

It's entirely possible that my crufty regex approach wasn't 100% accurate!

[dktr0]

Might just be something to do with difference between <| and (<|)?

[yaxu]

Yes probably, I've ticked them off for now

[dktr0]

Now I understand what the tick boxes are for! :)

[dktr0]

This is all super useful - will be easy to fill all this in in the next little while

[yaxu]

Good! Out of interest, are you able to tick the boxes by clicking on them in my comment?

[dktr0]

I just checked the last one spuriously - is it checked for you? I guess I kind of doubt it...

[dktr0]

(juxcut')

[yaxu]

Yes that worked, I unchecked it again

[yaxu]

I've been doing a couple more of these (pr soon), but can you summarise the reason for not generating all this straight from the types @dktr0 ? Is there some pragmatism about how the currying works?

[dktr0]

Just haven't got that far with the TH and prefer something that works right now and which gives workshop experiences with Tidal to hundreds of students at a time over abstraction and automation for the sake of abstraction and automation...

[dktr0]

I know I can debug and maintain this. I do not know that for the fully automatic one.

[dktr0]

Still, I think the automatic thing will probably be the right step eventually...

[dktr0]

Basically I think that's a big and complicated refactor, with uncertain ultimate costs, and not a huge payoff in terms of what it makes available to the audiences I care about. If someone else is able to pull it off, great I guess (although I worry a bit about not being able to follow/debug it from that point on...).

[yaxu]

I meant auto-generating the code (e.g. using more shonky perl code) rather than doing funky stuff with TH.

[yaxu]

If it's doable, I'd be happy to do the job! Just need to understand what's going on and what the gotchas are..

[yaxu]

Having problems working out how to add the Ord constraint in rot :: Ord a => Pattern Int -> Pattern a -> Pattern a

In this case I think I can just remove that constraint from the function itself though..

[yaxu]

Hm I can only get it to rot :: Eq a => Pattern Int -> Pattern a -> Pattern a, as some comparison of values has to happen.

[dktr0]

These kind of questions are part of why I am reluctant to automate further than already - it sounds nice but there are lots of little wrinkles that IMHO are easier to think through at a lower level of abstraction. Obviously your mileage may vary. Not super in favour of doing things in Perl as it will further limit my ability to continue contributing to this work (I don't have time and energy to spend on Perl, sorry).

[dktr0]

I'll add rot now and add it to the pull request already in the queue for clip and vol.

[dktr0]

I do think the higher abstraction TH route is viable - just takes some careful thought and very careful documentation...

[dktr0]

Ok rot is there in the pull request with vol and clip now.

[dktr0]

also added the fastCat/slowCat synonyms

[dktr0]

Basically adding something like rot that has a type (ie. with the constraints) we don't already have is about adding a new instance or definition for that type, then taking off the first argument and repeating the process (adding new instances or definitions as appropriate) until you get to the * instances, where you make sure the new pathway is reflected in every one of them that is possible.

[dktr0]

Can I propose that we start conceptual work that lays the groundwork for the more-abstract-TH route without (yet) doing away with the current approach? It will be more robust and hopefully we will both be able to follow and continue to contribute to the result.

[yaxu]

Thanks for the rot! I don't intend to make Perl a dev dependency for anything.. Just trying to work out whether we can just generate these definitions as a one-off. It seems that we're just describing a type in code, which seems to be a data munging rather than manual task.. But I think I'm missing something, and so was asking what that missing thing was.

[dktr0]

I've gotten as far as making some TH to take a list of Tidal functions and get the info about their type as a Map from their names to that info. Here's it in action:

*Sound.Tidal.Parse> $(reifyTidals ["s","n"] >>= (stringE . show)) "fromList [(\"n\",VarI Sound.Tidal.Params.n (AppT (AppT ArrowT (AppT (ConT Sound.Tidal.Pattern.Pattern) (ConT GHC.Types.Double))) (ConT Sound.Tidal.Pattern.ControlPattern)) Nothing),(\"s\",VarI Sound.Tidal.Params.s (AppT (AppT ArrowT (AppT (ConT Sound.Tidal.Pattern.Pattern) (ConT GHC.Base.String))) (ConT Sound.Tidal.Pattern.ControlPattern)) Nothing)]"

[dktr0]

Have pushed that to a branch called th-parse on my fork for now

[yaxu]

Is this issue still useful @dktr0 ?

[dktr0]

@yaxu Nah, not really, I'll close it!