[racket] question about foldl implementation

For a presentation I'm working on I've been implementing various higher
order functions in javascript.

When trying to work out the proper foldl implementation I came across
something interesting in Racket

> (foldl cons '() '(1 2 3 4))
(4 3 2 1)

> (foldl - 0 '(1 2 3 4))
2

However when I looked into various other implementations of foldl I came
across very different behavior
Haskell's foldl seems to be implemented like this:
;;haskell-like definition
(define (foldl-haskell func accum lst)
  (if (null? lst)
      accum
      (foldl-haskell func (func accum (car lst)) (cdr lst))))

and yields these results:
> (foldl-haskell cons '() '(1 2 3 4))
((((() . 1) . 2) . 3) . 4)
> (foldl-haskell - 0 '(1 2 3 4))
-10
>

Unsure which was correct I broke out SICP which uses this definition:
;;sicp version
(define (fold-left op initial sequence)
  (define (iter result rest)
    (if (null? rest)
        result
        (iter (op result (car rest))
              (cdr rest))))
  (iter initial sequence))

with these results (same as the haskell-like version):
> (fold-left cons '() '(1 2 3 4))
((((() . 1) . 2) . 3) . 4)
> (fold-left - 0 '(1 2 3 4))
-10
>

So which of these is the canonical implementation of a left fold? Why the
difference in Racket?
For pure aesthetics I like the behavior of Racket in the case of cons, but
for '-' the others seems to make more sense.

Any insight into this is greatly appreciated!

Thanks!
--Will Kurt
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.racket-lang.org/users/archive/attachments/20100812/f21e0eeb/attachment.html>