fix(js/ts/python/dart/rust/beam): break min and max ties like FSharp.Core

src/Fable.Transforms/Rust/Replacements.fs

@@ -1253,6 +1253,7 @@ let operators (com: ICompiler) (ctx: Context) r t (i: CallInfo) (thisArg: Expr o
     | "Clamp", _ -> math r t args i.SignatureArgTypes i.CompiledName |> Some
     | ("Min" | "Max") as meth, _ ->
         match args.Head.Type with
+        | Number(Decimal, _) -> libCall com r t "Decimal" (Naming.lowerFirst meth) args |> Some
         | Boolean
         | Char
         | String

src/fable-library-beam/Seq.fs

@@ -1166,15 +1166,24 @@ let sum (xs: seq<'T>) ([<Inject>] adder: IGenericAdder<'T>) : 'T =
 let sumBy (f: 'T -> 'U) (xs: seq<'T>) ([<Inject>] adder: IGenericAdder<'U>) : 'U =
     fold (fun acc x -> adder.Add(acc, f x)) (adder.GetZero()) xs
 
-let maxBy (projection: 'T -> 'U) xs ([<Inject>] comparer: System.Collections.Generic.IComparer<'U>) : 'T =
-    reduce
-        (fun x y ->
-            if comparer.Compare(projection y, projection x) > 0 then
-                y
-            else
-                x
-        )
-        xs
+let maxBy (projection: 'T -> 'U) (xs: seq<'T>) ([<Inject>] comparer: System.Collections.Generic.IComparer<'U>) : 'T =
+    use e = ofSeq xs
+
+    if not (e.MoveNext()) then
+        invalidArg "source" SR.inputSequenceEmpty
+
+    let mutable acc = e.Current
+    let mutable accv = projection acc
+
+    while e.MoveNext() do
+        let x = e.Current
+        let v = projection x
+
+        if comparer.Compare(v, accv) > 0 then
+            acc <- x
+            accv <- v
+
+    acc
 
 let max xs ([<Inject>] comparer: System.Collections.Generic.IComparer<'T>) : 'T =
     reduce
@@ -1186,23 +1195,32 @@ let max xs ([<Inject>] comparer: System.Collections.Generic.IComparer<'T>) : 'T
         )
         xs
 
-let minBy (projection: 'T -> 'U) xs ([<Inject>] comparer: System.Collections.Generic.IComparer<'U>) : 'T =
-    reduce
-        (fun x y ->
-            if comparer.Compare(projection y, projection x) > 0 then
-                x
-            else
-                y
-        )
-        xs
+let minBy (projection: 'T -> 'U) (xs: seq<'T>) ([<Inject>] comparer: System.Collections.Generic.IComparer<'U>) : 'T =
+    use e = ofSeq xs
+
+    if not (e.MoveNext()) then
+        invalidArg "source" SR.inputSequenceEmpty
+
+    let mutable acc = e.Current
+    let mutable accv = projection acc
+
+    while e.MoveNext() do
+        let x = e.Current
+        let v = projection x
+
+        if comparer.Compare(v, accv) < 0 then
+            acc <- x
+            accv <- v
+
+    acc
 
 let min (xs: seq<'T>) ([<Inject>] comparer: System.Collections.Generic.IComparer<'T>) : 'T =
     reduce
         (fun x y ->
-            if comparer.Compare(y, x) > 0 then
-                x
-            else
+            if comparer.Compare(y, x) < 0 then
                 y
+            else
+                x
         )
         xs
 

src/fable-library-beam/fable_list.erl

@@ -286,8 +286,19 @@ collect(Fn, List) ->
 sum_by(Fn, List) ->
     lists:sum(lists:map(Fn, List)).
 
-min_by(Fn, List) ->
-    element(2, lists:min(lists:map(fun(E) -> {Fn(E), E} end, List))).
+min_by(Fn, [Head | Tail]) ->
+    {_, Result} = lists:foldl(
+        fun(Item, {BestKey, Best}) ->
+            ItemKey = Fn(Item),
+            case ItemKey < BestKey of
+                true -> {ItemKey, Item};
+                false -> {BestKey, Best}
+            end
+        end,
+        {Fn(Head), Head},
+        Tail
+    ),
+    Result.
 
 min_by(Fn, Comparer, [Head | Tail]) ->
     {_, Result} = lists:foldl(
@@ -303,8 +314,19 @@ min_by(Fn, Comparer, [Head | Tail]) ->
     ),
     Result.
 
-max_by(Fn, List) ->
-    element(2, lists:max(lists:map(fun(E) -> {Fn(E), E} end, List))).
+max_by(Fn, [Head | Tail]) ->
+    {_, Result} = lists:foldl(
+        fun(Item, {BestKey, Best}) ->
+            ItemKey = Fn(Item),
+            case ItemKey > BestKey of
+                true -> {ItemKey, Item};
+                false -> {BestKey, Best}
+            end
+        end,
+        {Fn(Head), Head},
+        Tail
+    ),
+    Result.
 
 max_by(Fn, Comparer, [Head | Tail]) ->
     {_, Result} = lists:foldl(

src/fable-library-dart/Array.fs

@@ -958,14 +958,21 @@ let sumBy (projection: 'T -> 'T2) (array: 'T[]) ([<Inject>] adder: IGenericAdder
     acc
 
 let maxBy (projection: 'a -> 'b) (xs: 'a[]) ([<Inject>] comparer: IComparer<'b>) : 'a =
-    reduce
-        (fun x y ->
-            if comparer.Compare(projection y, projection x) > 0 then
-                y
-            else
-                x
-        )
-        xs
+    if Array.isEmpty xs then
+        invalidArg "array" LanguagePrimitives.ErrorStrings.InputArrayEmptyString
+
+    let mutable acc = xs[0]
+    let mutable accv = projection acc
+
+    for i = 1 to xs.Length - 1 do
+        let x = xs[i]
+        let v = projection x
+
+        if comparer.Compare(v, accv) > 0 then
+            acc <- x
+            accv <- v
+
+    acc
 
 let max (xs: 'a[]) ([<Inject>] comparer: IComparer<'a>) : 'a =
     reduce
@@ -978,22 +985,29 @@ let max (xs: 'a[]) ([<Inject>] comparer: IComparer<'a>) : 'a =
         xs
 
 let minBy (projection: 'a -> 'b) (xs: 'a[]) ([<Inject>] comparer: IComparer<'b>) : 'a =
-    reduce
-        (fun x y ->
-            if comparer.Compare(projection y, projection x) > 0 then
-                x
-            else
-                y
-        )
-        xs
+    if Array.isEmpty xs then
+        invalidArg "array" LanguagePrimitives.ErrorStrings.InputArrayEmptyString
+
+    let mutable acc = xs[0]
+    let mutable accv = projection acc
+
+    for i = 1 to xs.Length - 1 do
+        let x = xs[i]
+        let v = projection x
+
+        if comparer.Compare(v, accv) < 0 then
+            acc <- x
+            accv <- v
+
+    acc
 
 let min (xs: 'a[]) ([<Inject>] comparer: IComparer<'a>) : 'a =
     reduce
         (fun x y ->
-            if comparer.Compare(y, x) > 0 then
-                x
-            else
+            if comparer.Compare(y, x) < 0 then
                 y
+            else
+                x
         )
         xs
 

src/fable-library-dart/List.fs

@@ -640,15 +640,22 @@ let sum (xs: 'T list) ([<Inject>] adder: IGenericAdder<'T>) : 'T =
 let sumBy (f: 'T -> 'U) (xs: 'T list) ([<Inject>] adder: IGenericAdder<'U>) : 'U =
     fold (fun acc x -> adder.Add(acc, f x)) (adder.GetZero()) xs
 
-let maxBy (projection: 'T -> 'U) xs ([<Inject>] comparer: IComparer<'U>) : 'T =
-    reduce
-        (fun x y ->
-            if comparer.Compare(projection y, projection x) > 0 then
-                y
-            else
-                x
-        )
-        xs
+let maxBy (projection: 'T -> 'U) (xs: 'T list) ([<Inject>] comparer: IComparer<'U>) : 'T =
+    let mutable acc = head xs
+    let mutable accv = projection acc
+    let mutable xs = tail xs
+
+    while not xs.IsEmpty do
+        let x = xs.Head
+        let v = projection x
+
+        if comparer.Compare(v, accv) > 0 then
+            acc <- x
+            accv <- v
+
+        xs <- xs.Tail
+
+    acc
 
 let max xs ([<Inject>] comparer: IComparer<'T>) : 'T =
     reduce
@@ -660,23 +667,30 @@ let max xs ([<Inject>] comparer: IComparer<'T>) : 'T =
         )
         xs
 
-let minBy (projection: 'T -> 'U) xs ([<Inject>] comparer: IComparer<'U>) : 'T =
-    reduce
-        (fun x y ->
-            if comparer.Compare(projection y, projection x) > 0 then
-                x
-            else
-                y
-        )
-        xs
+let minBy (projection: 'T -> 'U) (xs: 'T list) ([<Inject>] comparer: IComparer<'U>) : 'T =
+    let mutable acc = head xs
+    let mutable accv = projection acc
+    let mutable xs = tail xs
+
+    while not xs.IsEmpty do
+        let x = xs.Head
+        let v = projection x
+
+        if comparer.Compare(v, accv) < 0 then
+            acc <- x
+            accv <- v
+
+        xs <- xs.Tail
+
+    acc
 
 let min (xs: 'T list) ([<Inject>] comparer: IComparer<'T>) : 'T =
     reduce
         (fun x y ->
-            if comparer.Compare(y, x) > 0 then
-                x
-            else
+            if comparer.Compare(y, x) < 0 then
                 y
+            else
+                x
         )
         xs
 

src/fable-library-dart/Seq.fs

@@ -1114,15 +1114,24 @@ let sum (xs: seq<'T>) ([<Inject>] adder: IGenericAdder<'T>) : 'T =
 let sumBy (f: 'T -> 'U) (xs: seq<'T>) ([<Inject>] adder: IGenericAdder<'U>) : 'U =
     fold (fun acc x -> adder.Add(acc, f x)) (adder.GetZero()) xs
 
-let maxBy (projection: 'T -> 'U) xs ([<Inject>] comparer: IComparer<'U>) : 'T =
-    reduce
-        (fun x y ->
-            if comparer.Compare(projection y, projection x) > 0 then
-                y
-            else
-                x
-        )
-        xs
+let maxBy (projection: 'T -> 'U) (xs: seq<'T>) ([<Inject>] comparer: IComparer<'U>) : 'T =
+    use e = ofSeq xs
+
+    if not (e.MoveNext()) then
+        invalidArg "source" SR.inputSequenceEmpty
+
+    let mutable acc = e.Current
+    let mutable accv = projection acc
+
+    while e.MoveNext() do
+        let x = e.Current
+        let v = projection x
+
+        if comparer.Compare(v, accv) > 0 then
+            acc <- x
+            accv <- v
+
+    acc
 
 let max xs ([<Inject>] comparer: IComparer<'T>) : 'T =
     reduce
@@ -1134,23 +1143,32 @@ let max xs ([<Inject>] comparer: IComparer<'T>) : 'T =
         )
         xs
 
-let minBy (projection: 'T -> 'U) xs ([<Inject>] comparer: IComparer<'U>) : 'T =
-    reduce
-        (fun x y ->
-            if comparer.Compare(projection y, projection x) > 0 then
-                x
-            else
-                y
-        )
-        xs
+let minBy (projection: 'T -> 'U) (xs: seq<'T>) ([<Inject>] comparer: IComparer<'U>) : 'T =
+    use e = ofSeq xs
+
+    if not (e.MoveNext()) then
+        invalidArg "source" SR.inputSequenceEmpty
+
+    let mutable acc = e.Current
+    let mutable accv = projection acc
+
+    while e.MoveNext() do
+        let x = e.Current
+        let v = projection x
+
+        if comparer.Compare(v, accv) < 0 then
+            acc <- x
+            accv <- v
+
+    acc
 
 let min (xs: seq<'T>) ([<Inject>] comparer: IComparer<'T>) : 'T =
     reduce
         (fun x y ->
-            if comparer.Compare(y, x) > 0 then
-                x
-            else
+            if comparer.Compare(y, x) < 0 then
                 y
+            else
+                x
         )
         xs
 

src/fable-library-dart/Util.dart

@@ -997,7 +997,7 @@ T min<T>(int Function(T, T) comparer, T x, T y) {
 }
 
 T max<T>(int Function(T, T) comparer, T x, T y) {
-  return comparer(x, y) > 0 ? x : y;
+  return comparer(x, y) < 0 ? y : x;
 }
 
 T clamp<T>(int Function(T, T) comparer, T value, T min, T max) {