fix: [Rust] Fix curried application

Author: ncave

src/Fable.Transforms/Rust/Fable2Rust.fs

@@ -3041,18 +3041,52 @@ module Util =
     let transformCurry (com: IRustCompiler) (ctx: Context) arity (expr: Fable.Expr) : Rust.Expr =
         com.TransformExpr(ctx, Replacements.Api.curryExprAtRuntime com arity expr)
 
+    let tryGetCurriedApplyArgAndReturnTypes typ =
+        match typ with
+        | Fable.LambdaType(argType, returnType) -> Some(argType, returnType)
+        | Fable.DelegateType([ argType ], returnType) -> Some(argType, returnType)
+        | _ -> None
+
+    let isErasedUnitClosureType typ =
+        match typ with
+        | Fable.LambdaType(Fable.Unit, _)
+        | Fable.DelegateType([ Fable.Unit ], _) -> true
+        | _ -> false
+
     let transformCurriedApply (com: IRustCompiler) ctx r typ calleeExpr args =
         match ctx.TailCallOpportunity with
         | Some tc when tc.IsRecursiveRef(calleeExpr) && List.length tc.Args = List.length args ->
             optimizeTailCall com ctx r tc args
         | _ ->
             let callee = transformCallee com ctx calleeExpr
 
-            (callee, args)
-            ||> List.fold (fun expr arg ->
-                let args = FSharp2Fable.Util.dropUnitCallArg com [ arg ] [] None
-                callFunction com ctx r expr args
+            ((callee, Some calleeExpr, calleeExpr.Type), args)
+            ||> List.fold (fun (expr, currentExpr, currentType) arg ->
+                let expectedArgType, nextType =
+                    match tryGetCurriedApplyArgAndReturnTypes currentType with
+                    | Some(argType, returnType) -> argType, returnType
+                    | None -> arg.Type, typ
+
+                if arg.Type = Fable.Unit then
+                    let appliedExpr =
+                        match currentExpr with
+                        | Some(Fable.IdentExpr ident) when isFuncScoped ctx ident.Name -> mkCallExpr expr []
+                        | _ -> makeLibCall com ctx None "Native" "applyUnit" [ expr |> makeClone ]
+
+                    appliedExpr, None, nextType
+                else
+                    let argExpr =
+                        transformCallArgs com ctx [ arg ] [ expectedArgType ] [] |> List.exactlyOne
+
+                    let argExpr =
+                        if isErasedUnitClosureType expectedArgType then
+                            makeLibCall com ctx None "Native" "eraseUnitArg" [ argExpr |> makeClone ]
+                        else
+                            argExpr
+
+                    mkCallExpr expr [ argExpr ], None, nextType
             )
+            |> fun (expr, _, _) -> expr
 
     let makeUnionCasePat unionCaseName fields =
         if List.isEmpty fields then

src/fable-library-rust/src/Native.rs

@@ -319,6 +319,56 @@ pub mod Native_ {
         }
     }
 
+    // -----------------------------------------------------------
+    // Unit arg curried applications
+    // -----------------------------------------------------------
+
+    pub trait ApplyUnit<R> {
+        fn apply_unit(self) -> R;
+    }
+
+    pub trait EraseUnitArg<R> {
+        fn erase_unit_arg(self) -> Func0<R>;
+    }
+
+    impl<R: 'static> ApplyUnit<R> for Func0<R> {
+        #[inline]
+        fn apply_unit(self) -> R {
+            self()
+        }
+    }
+
+    impl<R: 'static> ApplyUnit<R> for Func1<(), R> {
+        #[inline]
+        fn apply_unit(self) -> R {
+            self(())
+        }
+    }
+
+    impl<R: 'static> EraseUnitArg<R> for Func0<R> {
+        #[inline]
+        fn erase_unit_arg(self) -> Func0<R> {
+            self
+        }
+    }
+
+    impl<R: 'static> EraseUnitArg<R> for Func1<(), R> {
+        #[inline]
+        fn erase_unit_arg(self) -> Func0<R> {
+            Func0::new(move || self(()))
+        }
+    }
+
+    #[inline]
+    pub fn applyUnit<R, F: ApplyUnit<R>>(f: F) -> R {
+        f.apply_unit()
+    }
+
+    #[inline]
+    pub fn eraseUnitArg<R, F: EraseUnitArg<R>>(f: F) -> Func0<R> {
+        f.erase_unit_arg()
+    }
+
     // -----------------------------------------------------------
     // Fixed-point combinators
     // -----------------------------------------------------------

tests/Rust/tests/src/ApplicativeTests.fs

@@ -1116,12 +1116,12 @@ let ``SRTP with ActivePattern works`` () =
 //     equal (1,5) baz
 //     equal (1,5) baz2
 
-// [<Fact>]
-// let ``Applying to a function returned by a local function works`` () =
-//     let foo a b c d = a , b + c d
-//     let bar a = foo 1 a
-//     let baz = bar 2 (fun _ -> 3) ()
-//     equal (1,5) baz
+[<Fact>]
+let ``Applying to a function returned by a local function works`` () =
+    let foo a b c d = a , b + c d
+    let bar a = foo 1 a
+    let baz = bar 2 (fun _ -> 3) ()
+    equal (1,5) baz
 
 [<Fact>]
 let ``Partially applied functions don't duplicate side effects`` () = // See #1156