Support custom Math operators

single-operand only: log, exp and trigonometric functions

src/Fable.Transforms/Replacements.fs

@@ -2143,7 +2143,13 @@ let operators
             |> Some
         | _ -> math r t args i.SignatureArgTypes i.CompiledName |> Some
     | ("Acos" | "Asin" | "Atan" | "Atan2" | "Cos" | "Cosh" | "Exp" | "Log" | "Log2" | "Log10" | "Sin" | "Sinh" | "Sqrt" | "Tan" | "Tanh"),
-      _ -> math r t args i.SignatureArgTypes i.CompiledName |> Some
+      _ ->
+        let argTypes = args |> List.map (fun a -> a.Type)
+
+        match argTypes with
+        | Number(_, _) :: _ ->
+            math r t args i.SignatureArgTypes i.CompiledName |> Some
+        | _ -> applyOp com ctx r t i.CompiledName args |> Some
     | "Round", _ ->
         match args with
         | ExprType(Number(Decimal, _)) :: _ ->

tests/Dart/src/CustomOperatorTests.fs

@@ -15,6 +15,7 @@ type MyRecord =
     { value: int }
     static member (+) (x: MyRecord, y: int) = { value = x.value + y }
     static member (+) (x: int, y: MyRecord) = x + y.value + 2
+    static member Exp (x: MyRecord) = { value = x.value + 1}
 
 type CustomPow =
     { Ok: bool }
@@ -41,6 +42,10 @@ let typeOperators() =
         let x = { Ok = false }
         x ** 2 |> equal { Ok = true }
 
+    testCase "Custom Exp works" <| fun () ->
+        let x = { value = 0 }
+        x |> exp |> equal { value = 1 }
+
 let (+) (x: int) (y: int) = x * y
 
 let (-) (x: int) (y: int) = x / y

tests/Js/Main/CustomOperatorsTests.fs

@@ -16,6 +16,8 @@ type MyRecord =
     static member (+) (x: MyRecord, y: int) = { value = x.value + y }
     static member (+) (x: int, y: MyRecord) = x + y.value + 2
 
+    static member Exp (x: MyRecord) = { value = x.value + 1}
+
 type CustomPow =
     { Ok: bool }
     static member Pow(x: CustomPow, n: int) = { Ok = true }
@@ -40,6 +42,14 @@ let typeOperators = [
     testCase "Custom Pow works" <| fun () -> // See #2496
         let x = { Ok = false }
         x ** 2 |> equal { Ok = true }
+
+    testCase "Custom Exp works" <| fun () ->
+        let x = { value=10 }
+        exp x |> equal { value= 11 }
+
+    testCase "Float Exp works" <| fun () ->
+        let x = 0.0
+        exp x |> equal 1.
 ]
 
 let (+) (x: int) (y: int) = x * y

tests/Python/TestCustomOperators.fs

@@ -15,6 +15,7 @@ type MyRecord =
     { value: int }
     static member (+) (x: MyRecord, y: int) = { value = x.value + y }
     static member (+) (x: int, y: MyRecord) = x + y.value + 2
+    static member Exp (x: MyRecord) = { value = x.value + 1}
 
 [<Fact>]
 let ``test Custom operators with types work`` () =
@@ -35,6 +36,11 @@ let ``test Custom operator overloads work`` () =
     x + 2 |> equal { value = 7 }
     3 + x |> equal 10
 
+[<Fact>]
+let ``test Custom operator Exp works`` () =
+    let x = { value = 0 }
+    x |> exp |> equal { value = 1 }
+
 let (+) (x: int) (y: int) = x * y
 
 let (-) (x: int) (y: int) = x / y

tests/Rust/tests/src/CustomOperatorTests.fs

@@ -19,6 +19,8 @@ type MyStruct =
     static member (<<<) (x: MyStruct, n: int) = { value = pown x.value n }
     static member (~-) (x: MyStruct) = { value = -x.value }
 
+    static member Exp (x: MyStruct) = { value = exp x.value}
+
 type MyRecord =
     { value: int }
     static member (+) (x: MyRecord, y: int) = { value = x.value + y }
@@ -60,6 +62,11 @@ let ``Custom Pow works`` () = // See #2496
     let x = { Ok = false }
     x ** 2 |> equal { Ok = true }
 
+[<Fact>]
+let ``Custom Exp works`` () =
+    let x = { MyStruct.value = 0. }
+    x |> exp |> equal { MyStruct.value = 1.0 }
+
 let (+) (x: int) (y: int) = x * y
 let (-) (x: int) (y: int) = x / y
 let (||||) x y = x + y