alternative JSON representation of patterns

[felixroos]

It just struck me that strudel patterns could be expressed as JSON without much change.. Take this pattern:

stack(
    s("bd <sd cp>")
    .delay(.5)
    .delaytime(.33)
    .delayfeedback(.6),
    s("hh*2")
    .delay(.8)
    .delaytime(.08)
    .delayfeedback(.7)
    .orbit(2)
  ).sometimes(x=>x.speed("-1"))

... translated to JSON:

{
  "stack": [
    {
      "s": "bd <sd cp>",
      "delay": 0.5,
      "delaytime": 0.33,
      "delayfeedback": 0.6
    },
    {
      "s": "hh*2",
      "delay": 0.8,
      "delaytime": 0.08,
      "delayfeedback": 0.7,
      "orbit": 2
    }
  ],
  "sometimes": {
    "speed": "-1",
    "crush": 5
  }
}

This assumes the x=>x. problem is solved, but generally it looks pretty doable.

Because JSON is a much simpler language, it is much easier to analyze / validate / cast with tools like zod. A JSON schema could define the set of possible property and type combinations, enabling strudel to detect an invalid pattern before runtime, which is kind of an alternative for type inference.

With a defined format, it would also be possible to translate back and forth between JS and JSON for serialization.

I have not really tried other patterns, so I could have missed some syntax that cannot be translated that easily.

[felixroos]

it could also be interesting to actually write patterns in a more human friendly JSON sibling like https://yaml.org/

[yaxu]

It'd be also be easy enough to go from that to haskell tidal..

[felixroos]

@roipoussiere made yaml -> strudel ! https://roipoussiere.frama.io/tidaml/#ws1_multi-lines src: https://framagit.org/roipoussiere/tidaml

[njourdane]

... translated to JSON:

{
 "stack": [
   {
     "s": "bd <sd cp>",
     "delay": 0.5,
     "delaytime": 0.33,
     "delayfeedback": 0.6
   },

This can't actually work as is. In my prototype I had to capitalize the first term to prevent this problem:

cat(
    sound('bd sd')
      .crush('6 8 10'),
    crush('6 8 10')
      .sound('bd sd')
)

[felixroos]

why not just take the first element?

[njourdane]

why not just take the first element?

Dictionaries are not ordered.

[felixroos]

yeah but json/yaml text is ordered, and afaik JSON.parse will always parse it the same order.. Object.entries(x) will then also give the same order

[njourdane]

Yes but it could act differently according to the yaml parser you use.
Not really recommended to define a syntax.

Suppose I want to implement a "Tidaml" (as I named it) parser in an other language, that could not work.

[njourdane]

I also need to find a syntax for this:

stack(
    n("<0 [2 4] <3 5> [~ <4 1>]>*2".add("<0 [0,2,4]>/4")) // problem here
      .add("<0 <1 -1>>")
      .scale("C5:minor"),
    n("0 1 [2 3] 2")
      .sound("jazz")
      .jux(rev) // and here
).sometimes(x=>x.speed("-1")) // and here, as you mentioned

I plan to write it like this:

Stack:
- N: <0 [2 4] <3 5> [~ <4 1>]>*2
  ^:
    add: <0 [0,2,4]>/4
  add: <0 <1 -1>>
  scale: C5:minor
- N: 0 1 [2 3] 2
  sound: jazz
  jux:
      rev:
sometimes:
  speed: -1

edit: or maybe like this

- N:
    M: <0 [2 4] <3 5> [~ <4 1>]>*2 # 'M' stands for Mini-notation
    add: <0 [0,2,4]>/4
  add: <0 <1 -1>>
  scale: C5:minor

[yaxu]

I'd say supporting patterns of functions is an important feature. It's a bit of a can of worms! There was an attempt here that was a dead end:
#368

I think it's doable but patterns would need to record the types of their values somehow.

[njourdane]

Thanks for the link to the PR, interesting.

From merged PR #390 (comment) I read that you:

made unary functions composable, including controls. So e.g. s("bd sd").every(3,fast(2).iter(4).n(4)) works the same as s("bd sd").every(3,x => x.fast(2).iter(4).n(4))

So why .sometimes(x=>x.speed("-1")) could not be written as .sometimes(speed("-1"))?

[njourdane]

Should I write it like this .sometimes(set.speed(-1))?

[yaxu]

So why .sometimes(x=>x.speed("-1")) could not be written as .sometimes(speed("-1"))?

IIRC, sometimes expects a function, or a pattern of functions. If you give it a different kind of pattern, it can't tell in time to change its behaviour.

Should I write it like this .sometimes(set.speed(-1))?

Yep!

We could continue discussion on this issue: #463

[felixroos]

@roipoussiere Did you find a solution for that "duplicate key problem" ? How would you write that in jaffle:

freq("1 2")
.mul(freq("<2 3>"))
.mul(freq(55))

coming from: #615 (comment)

maybe you have some solutions for those kinds of problems?