What is Alt f => [a -> f b] -> a -> f b called?

[ammut]

We are using this combinator (named altAllF, F for Function, for lack of a better name):

const altAllF = <F>(F: Alternative<F>) => <A, B>(...fs: NonEmptyArray<(a: A) => HKT<F, B>>) => (a: A) =>
  fs.reduce((mb, f) => F.alt(mb, () => f(a)), F.zero());

It's kind of similar to altAll, but somehow also does the opposite:

• altAll is better suited for the case where you have a single function and an array of inputs and want to stop as soon as one of the inputs produces a "Some".
• altAllF is better suited for the case where you have a single input and several functions and you want to stop as soon as one of the functions produces a "Some".

I'm looking for a name and wondering if this would be a useful function to have in the library itself.

Or is there a simple way of expressing this via altAll?

[ammut]

I thought about it some more and I am pretty confident that there is no simple way of expressing this with altAll without applying a beforehand.
I could do something like a => pipe([fn1, fn2], array.map(f => () => f(a)), alt.altAll(F.Alt)(F.Alt.zero()), but that feels a bit too awkward.
Also F here would be some sort of Alt<IO<A>>.
OptionT and others have alt<M>(M: Monad<M>), but that returns an alt(fa: Option, that: Lazy<Option>) instead of an Alt instance