List traverse runs from right to left

Description

It looks like List.traverse runs from right to left, it should be from left to right according to the document.

Repro steps

Below code could reproduce this problem

let mapper (v: int) =
    Console.WriteLine(sprintf "mapping: %d" v)
    Result.Ok v

let test v =
     List.traverse mapper v |> Result.map List.last
   
 test [1; 2; 3]

Expected behavior

It should prints

mapping: 1 mapping: 2 mapping: 3

Actual behavior

It prints in the reverse order

mapping: 3 mapping: 2 mapping: 1

Related information

The code runs with FSharpPlus 1.1.6

[3Rafal]

I guess we can even do it in 2 passes with this version:

let traverseList' f lst =
    let rec loop acc = function
        | [] -> acc
        | x::xs -> let v = f x
                   let consed = List.cons <!> v <*> acc
                   if v |> IsLeftZero.Invoke |> not 
                   then loop consed xs 
                   else consed 
    loop (result []) lst 
    |> Map.Invoke List.rev

What do you think @gusty ?

EDIT: I’ve ran simple performance tests:

#time

let ok_f v = Ok v : Result<int,string>
let oldOne = List.traverse ok_f [1..5000000];; 
let newOne = traverseList' ok_f [1..5000000];;

and the results show that this implementation seems to have similar performance

> let newOne = traverseList' ok_f [1..5000000];;;;
Real: 00:00:03.790, CPU: 00:00:03.765, GC gen0: 180, gen1: 53, gen2: 2
> let oldOne = List.traverse ok_f [1..5000000];; ;;
Real: 00:00:05.454, CPU: 00:00:05.875, GC gen0: 220, gen1: 63, gen2: 3

[gusty]

Sure, but note that it’s not a good practice, even in F#, to include sideeffects in let’s say a map function call, it’s always better and more readable (and less surprising) to use a dedicated iter to perform side-effects. The same applies for traverse.

Anyway, let’s try to come up with a solution that fixes the order without compromising performance too much.