How best to call multiple functions on one value?

[edalex-ian]

Hi Again,

I'm trying to understand what is the correct way to call multiple functions against one value in a pointfree fashion.

But let me try and provide a somewhat abstract example:

pipe(
  aNullableValue,
  O.fromNullable,
  O.map(flow(
    // Assume all these following functions are single arity and want to operate on that value
    // - and yes, in one case I'm thinking they're really all IO tasks
    f1,
    f2,
    ...,
    fn
  )
);

But I'd prefer if that list of functions were in an array. To do that I've ended up with something like:

const actions: ReadonlyArray<
  (_: string) => void
> = [setUser, callOnChange];

const doActions: (s: string) => void =
  flow(RA.of, RA.ap, apply(actions));

pipe(
  aNullableString,
  O.fromNullable,
  O.map(doActions)
);

However the X.of, X.ap and apply makes me wonder if there's not a better way. (Especially when in reverse - if I had an array of values and then a single function I've done things like A.traverse(IO.Applicative) etc.)

Thanks for reading, I appreciate any guidance you can offer. 😁

[samhh]

If they're all endomorphisms (a -> a) then this helper has come in handy for me (mostly in the implementation of other abstractions):

const applyEvery = <A>(fs: Array<Endomorphism<A>>): Endomorphism<A> => (x) =>
  pipe(
    fs,
    A.reduce(x, (y, f) => f(y)),
  )

pipe(x, applyEvery([f, g, h])) == pipe(x, f, g, h)

[mlegenhausen]

As alternative you could use the Monoid or Semigroup from Endomorphism please note that the order of executing is reversed in this case.

import * as M from 'fp-ts/Monoid'
import * as Endo from 'fp-ts/Endomorphism'

const applyEvery: <A>(fs: ReadonlyArray<Endomorphism<A>>) => Endomorphism<A> = M.concatAll(Endo.getMonoid<A>())(fs)

The Endomorphism Monoid or Semigroup has the advantage to be usable in more scenarios like foldMap. I use it often when building reducer logic.

[edalex-ian]

I like where both of these are going. But one question, is there an existing combinator that would produce an endomorphism from an effectual function?

As the main places I'm find this is when I want to call a series of UI handlers being calling alongside React setters from useState.

As a rough example for such a combinator, is there something that'd be like this:

// given a function: onChange: (a: string) => void
const endoOnChange: (a: string) => a = endo(onChange)

[samhh]

Is this the signature you want, assuming the side effect isn't faithfully captured by IO? (a -> void) -> a -> a

[edalex-ian]

Heya @samhh ,

Correct, I'm being (potentially) lazy and not utilising IO here. So your and @mlegenhausen mentions of Endomorphisms has got me thinking my context becomes easier if there was an existing combinator (say, called endo) with the signature of:

(a -> any) -> a -> a

Otherwise I obviously could write my own, but it got me wondering.... 🤔

Any such pre-existing combinator?

[imcotton]

However the X.of, X.ap and apply makes me wonder if there's not a better way.

Based on your example, could try flap here:

pipe(
  aNullableString,
  O.fromNullable,
  O.map(A.flap),
  O.flap(actions),
);

[edalex-ian]

Thanks for this, but unfortunately I'm unfamiliar with flap. I've often seen it in the doco on the various type classes but have yet to found documentation for them.

Could you please explain to me what flap is?

[imcotton]

Take a look at these alignment:

flap :: Functor f => f (a -> b) ->   a -> f b

 map :: Functor f =>   (a -> b) -> f a -> f b

  ap ::   Apply f => f (a -> b) -> f a -> f b

As in Array of TypeScript:

flap: (a -> b)[] => a   => b[]

 map: (a -> b)   => a[] => b[]

  ap: (a -> b)[] => a[] => b[]

---

edit: changed ap from Monad to Apply