Writing Fold in terms of Map or MapThread?

Question

Consider

Fold[f,z,{a,b,c}]
==> f[f[f[z,a],b,c]]

I'm looking for a way to write this (in general) using Map or MapThread (and perhaps Flatten[#,1]&, thinking of monadic bind a-la Haskell), and not using mutable variables. In other words, the following is too easy:

Module[{result = z},
  Map[v \[Function]
    result = f[result, v],
   {a, b, c}]] // Last

and the following is not even wrong:

MapThread[f, {{z, f[z, a], f[f[z, a], b]}, {a, b, c}}] // Last

and the following is even more not even wrong (invoking Haskell's state monad); although it could be written recursively to be more general, the recursive form would just be a simulacrum of Fold with more functional garbage around the binding functions:

return[v_] := s \[Function] {v, s};
bind[m_, fv2m_] := s \[Function]
  With[{vs0 = m[s]},
    With[{
     v0 = vs0[[1]],
     s0 = vs0[[2]]},
    fv2m[v0][s0]]]

bind[
  bind[
    bind[
     return[z],
     v \[Function] return[f[v, a]]],
    v \[Function] return[f[v, b]]],
   v \[Function] return[f[v, c]]][z] // First

I'm beginning to think that Fold is its own critter, kind of a state-monad-in-disguise, inherently recursive, and not representable by Map and friends, which are inherently iterative. But I haven't yet been able to prove that it's not possible, even though I haven't found a solution.

Anyone happen to know?

EDIT: the reason I'm looking for this is so I can build a reactive version around the Observable/Observer pattern, which is formally dual to the Iterable/Iterator pattern, and replaces Map with Subscribe, sort-of. I do not know a reactive partner to Fold, and that's the ultimate objective.

Answer 1

If you accept to use function composition, you might use something like this:

g = Composition @@ (Function /@ MapThread[f, {{#, #, #}, Reverse@{a, b, c}}]);
g[z]

which is equal to Fold[f, z, {a, b, c}].

Answer 2

I've discovered a few more things about this, so I am putting my response at top level so that it doesn't get ignored in comments, even though @user8074 absolutely gave me the ice-breaking idea. I now believe that

(Composition @@ Function[v, Function[x, f[v, x]]] /@ {a, b, c})@z

that is,

Apply[Composition, Map[Function[v, Function[x, f[v, x]]], {a, b, c}]][z]

is exactly

FoldRight[f, z, {a, b, c}]

where

FoldRight[f_, z_, l_List] := Fold[Flip@f, z, Reverse@l]

and

Flip[f_] := Function[{x, y}, f[y, x]]

Note also that

Fold[f, z, l] === FoldRight[Flip@f, z, Reverse@l]

for any particular l, so FoldRight and Fold are symmetric, and Fold could be called FoldLeft.

I checked with some people and I think that it was thought to be impossible to express Fold in terms of Map, although this combination of Map, Composition, and Apply may be novel. I will continue to post here as I learn more from colleagues.