# [plt-scheme] implementation of foldl

Hi all,
I am wondering whether the order in which foldl applies the "init"
argument and the "car" argument to the given combining function is to
be regarded as specified or as an implementation detail (such that you
should not rely on it).
Just as an exercise, I was writing reverse with foldl and foldr, and
noticed that with "my own" _foldr, defined as
(define _foldl
(lambda (proc initial lst)
(if (null? lst)
initial
(_foldl proc (proc initial (car lst)) (cdr lst)))))
it worked as
(define reverse-fl-1
(lambda (lst)
(_foldl (lambda (x y) (cons y x)) '() lst)))
whereas for the PLT version of foldl I need
(define reverse-fl-2
(lambda (lst)
(foldl (lambda (x y) (cons x y)) '() lst)))
The documentation for foldl says
"The proc is initially invoked with the first item of each list, and
the final argument is init."
so the order seems to be specified for PLT scheme (also one example in
the docs is relying on this); on the other hand I see that in Haskell
it's the other way round. So now I'm wondering a bit how foldl is to
be considered, somehow it seems less "universal" than foldr as it
makes a big difference how it's implemented in a programming language.
(I was also starting/trying to read "A tutorial on the universality
and expressiveness of fold" by Graham Hutton, which by fold
automatically seems to mean foldr.)
I hope my question is not too unclear or chaotic :-)
Thanks for any information,
Sigrid