Composing transforms

[mattvague]

Not totally sure if this is a question or a feature request yet, but I'll start with it as a question. What is the cleanest way to combine multiple subsequent transforms together for a given node?

For example, let's say I have 2 transforms that I want to apply one after the other:

const transform1 = (node) => ...
const transform2 = (node) => ...

I know I can do this:

someNode.transform((node) => transform1(transform2(node)))

But that doesn't feel very elegant nor will it be scaleable with a lot of fns. Functional libraries often have some kind of compose function that work like this

someNode.transform(compose(transform1, transform2))

But I can't seem to find this or any examples like this in mathjs. So, I guess that's my question: is there some kind of equivalent function I don't know about, or is there another way to do this?

If not, would you accept a PR to do either of the following?

1. Add a compose function like I've described
2. Possibly change transform to accept multiple transform fns like

someNode.transform(transform1, transform2)

Thanks!

[josdejong]

Interesting idea to make the transforms composable. Right now the transform solution is quite hard-coded. It basically takes the original function and creates a new "wrapper" function that invokes the original function.

It would be interesting to investigate what would be needed to make the transforms composable.

[mattvague]

I was able to write my own function that makes transforms composable like so:

import { MathNode } from 'mathjs'

export function composeTransforms<TArg extends MathNode>(...fns: ((...args: TArg[]) => TArg)[]) {
  return function(node: TArg, ...args) {
    return fns.reduce((m, c) => c(m, ...args), node)
  }
}

Which is used like so

myNode
  .transform(composeTransforms(
    transform1,
    transform2
  ))
  .toTex()

Could we not just add something like this inside of Node.prototype.transform if multiple callbacks/transforms are passed? Seems simple to me but maybe there's something I'm missing

[josdejong]

o wow 😂 I see I totally misunderstood your first question. I thought your where talking about the transforms that are there between the expression parser (1-based indices) and the JavaScript functions (0-based indices). But you're tralking about the transform() method
that is there on Nodes of a parsed expression.

What you can do too right now (looking elegant too, though not really scalable):

myNode
  .transform(transform1)
  .transform(transform2)
  .toTex()

Your composeTransforms helper function or extending the .transform() method to accept multiple callbacks sounds good to me and is indeed straightforward.

[mattvague]

Hmmm, somehow I guess I forgot you could just chain your transform calls hahaha. I still think having transform accept multiple callbacks would be nice in case you have sets of transforms you wanted to apply. Will make a task and hopefully tackle soon

[josdejong]

😂 you're the chain master now I think with all the TypeScript improvements 😅 . Yes agree, it would be a useful improvement.

For reference: #2568