(Seq|List).fold produces incorrect output when state is a function with arity > 1

[felixschorer]

Description

Seq.fold and List.fold produce incorrect output when state is a function with arity greater than 1.

List.fold
val fold : folder:('State -> 'T -> 'State) -> state:'State -> list:'T list -> 'State

Repro code

let folder state value x y = value :: state x y
let state x y = [x; y]
let d = Seq.fold folder state [0..3]
printfn "%A" (d 42 42)

Repl link

Expected and actual results

Expected output: [3; 2; 1; 0; 42; 42]
Actual output: [3]
The tail of the resulting List is a function instead of an other List.

Related information

• Fable version: 2.8.2
• Operating system: Windows 10 Pro 1903

[felixschorer]

I stepped through the generated JS. The problem seems to be here:

export function folder(state$$1, value, x, y) {
  return new List(value, state$$1(x, y));
}

state$$1 is a curried function, but is called as an uncurried function.

---

This works:

export function folder(state$$1, value, x, y) {
  return new List(value, state$$1(x)(y));
}

[ncave]

Yes, the problem seems to be that the F# compiler wraps the state parameter in a curried lambda wrapper, which is not uncurried by Fable.
Here it is in a different form:

let inline folder st value x y = value :: st x y
let state x y = [x; y]
let d = List.fold folder state [0;1;2;3]
System.Console.WriteLine(List.length (d 42 42))

compiles to:

import { length, fold, ofArray } from "fable-library/List.js";
import { List } from "fable-library/Types.js";
export function state(x, y) {
  return ofArray([x, y]);
}
export const d = fold(function (st, value) {
  return function (x$$1) {
    return function (y$$1) {
      return new List(value, st(x$$1, y$$1));
    };
  };
}, function (x$$3) {
  return function (y$$3) {
    return state(x$$3, y$$3);
  };
}, ofArray([0, 1, 2, 3]));
console.log(length(d(42)(42)));