diff --git a/src/Fable.Transforms/Dart/Replacements.fs b/src/Fable.Transforms/Dart/Replacements.fs
index da7b605590..90718e7e7d 100644
--- a/src/Fable.Transforms/Dart/Replacements.fs
+++ b/src/Fable.Transforms/Dart/Replacements.fs
@@ -42,7 +42,7 @@ let coreModFor =
     | BclTimeSpan -> "TimeSpan"
     | FSharpSet _ -> "Set"
     | FSharpMap _ -> "Map"
-    | FSharpResult _ -> "Choice"
+    | FSharpResult _ -> "Result"
     | FSharpChoice _ -> "Choice"
     | FSharpReference _ -> "Types"
     | BclHashSet _ -> "MutableSet"
@@ -768,7 +768,7 @@ let tryReplacedEntityRef (com: Compiler) entFullName =
     | BuiltinDefinition BclTimeSpan -> makeIdentExpr "Duration" |> Some
     | BuiltinDefinition BclTimer -> makeImportLib com MetaType "default" "Timer" |> Some
     | BuiltinDefinition(FSharpReference _) -> makeImportLib com MetaType "FSharpRef" "Types" |> Some
-    | BuiltinDefinition(FSharpResult _) -> makeImportLib com MetaType "FSharpResult$2" "Choice" |> Some
+    | BuiltinDefinition(FSharpResult _) -> makeImportLib com MetaType "FSharpResult$2" "Result" |> Some
     | BuiltinDefinition(FSharpChoice genArgs) ->
         let membName = $"FSharpChoice${List.length genArgs}"
         makeImportLib com MetaType membName "Choice" |> Some
@@ -2365,7 +2365,7 @@ let results (com: ICompiler) (ctx: Context) r (t: Type) (i: CallInfo) (_: Expr o
     | "ToValueOption" as meth -> Some("Result_" + meth)
     | _ -> None
     |> Option.map (fun meth ->
-        Helper.LibCall(com, "Choice", meth, t, args, i.SignatureArgTypes, genArgs = i.GenericArgs, ?loc = r)
+        Helper.LibCall(com, "Result", meth, t, args, i.SignatureArgTypes, genArgs = i.GenericArgs, ?loc = r)
     )
 
 let nullables (com: ICompiler) (_: Context) r (t: Type) (i: CallInfo) (thisArg: Expr option) (args: Expr list) =
diff --git a/src/Fable.Transforms/Fable2Babel.fs b/src/Fable.Transforms/Fable2Babel.fs
index 468bc47efb..ed92cb7fbc 100644
--- a/src/Fable.Transforms/Fable2Babel.fs
+++ b/src/Fable.Transforms/Fable2Babel.fs
@@ -800,7 +800,7 @@ module Annotation =
                     ok
                     err
                 ]
-                "Choice"
+                "Result"
         | Replacements.Util.FSharpChoice genArgs ->
             $"FSharpChoice${List.length genArgs}{Util.UnionHelpers.UNION_SUFFIX}"
             |> makeFableLibImportTypeAnnotation com ctx genArgs "Choice"
diff --git a/src/Fable.Transforms/Python/Fable2Python.fs b/src/Fable.Transforms/Python/Fable2Python.fs
index 02f8e48612..e10d846e8e 100644
--- a/src/Fable.Transforms/Python/Fable2Python.fs
+++ b/src/Fable.Transforms/Python/Fable2Python.fs
@@ -914,7 +914,7 @@ module Annotation =
         | Types.result, _ ->
             let resolved, stmts = resolveGenerics com ctx genArgs repeatedGenerics
 
-            fableModuleAnnotation com ctx "choice" "FSharpResult_2" resolved, stmts
+            fableModuleAnnotation com ctx "result" "FSharpResult_2" resolved, stmts
         | Replacements.Util.BuiltinEntity _kind -> stdlibModuleTypeHint com ctx "typing" "Any" []
         (*
             | Replacements.Util.BclGuid
@@ -1080,7 +1080,7 @@ module Annotation =
                     ]
                     repeatedGenerics
 
-            fableModuleAnnotation com ctx "choice" "FSharpResult_2" resolved, stmts
+            fableModuleAnnotation com ctx "result" "FSharpResult_2" resolved, stmts
         | _ -> stdlibModuleTypeHint com ctx "typing" "Any" []
 
     let transformFunctionWithAnnotations (com: IPythonCompiler) ctx name (args: Fable.Ident list) (body: Fable.Expr) =
diff --git a/src/Fable.Transforms/Python/Replacements.fs b/src/Fable.Transforms/Python/Replacements.fs
index 8f648299a5..d891896d66 100644
--- a/src/Fable.Transforms/Python/Replacements.fs
+++ b/src/Fable.Transforms/Python/Replacements.fs
@@ -56,7 +56,7 @@ let coreModFor =
     | BclTimeSpan -> "time_span"
     | FSharpSet _ -> "set"
     | FSharpMap _ -> "map"
-    | FSharpResult _ -> "choice"
+    | FSharpResult _ -> "result"
     | FSharpChoice _ -> "choice"
     | FSharpReference _ -> "types"
     | BclHashSet _ -> "mutable_set"
@@ -1166,7 +1166,7 @@ let tryEntityIdent (com: Compiler) entFullName =
     | BuiltinDefinition BclDateTimeOffset -> makeIdentExpr "Date" |> Some
     | BuiltinDefinition BclTimer -> makeImportLib com Any "default" "Timer" |> Some
     | BuiltinDefinition(FSharpReference _) -> makeImportLib com Any "FSharpRef" "Types" |> Some
-    | BuiltinDefinition(FSharpResult _) -> makeImportLib com Any "FSharpResult_2" "Choice" |> Some
+    | BuiltinDefinition(FSharpResult _) -> makeImportLib com Any "FSharpResult_2" "Result" |> Some
     | BuiltinDefinition(FSharpChoice genArgs) ->
         let membName = $"FSharpChoice_{List.length genArgs}"
         makeImportLib com Any membName "Choice" |> Some
@@ -2608,7 +2608,7 @@ let results (com: ICompiler) (ctx: Context) r (t: Type) (i: CallInfo) (_: Expr o
     | "ToOption"
     | "ToValueOption" as meth -> Some("Result_" + meth)
     | _ -> None
-    |> Option.map (fun meth -> Helper.LibCall(com, "choice", meth, t, args, i.SignatureArgTypes, ?loc = r))
+    |> Option.map (fun meth -> Helper.LibCall(com, "result", meth, t, args, i.SignatureArgTypes, ?loc = r))
 
 let nullables (com: ICompiler) (_: Context) r (t: Type) (i: CallInfo) (thisArg: Expr option) (args: Expr list) =
     match i.CompiledName, thisArg with
diff --git a/src/Fable.Transforms/Replacements.Util.fs b/src/Fable.Transforms/Replacements.Util.fs
index 62cb4036f0..610872fab8 100644
--- a/src/Fable.Transforms/Replacements.Util.fs
+++ b/src/Fable.Transforms/Replacements.Util.fs
@@ -309,8 +309,8 @@ type BuiltinType =
     | BclKeyValuePair of key: Type * value: Type
     | FSharpSet of Type
     | FSharpMap of key: Type * value: Type
-    | FSharpChoice of Type list
-    | FSharpResult of arg1: Type * arg2: Type
+    | FSharpChoice of genArgs: Type list
+    | FSharpResult of ok: Type * err: Type
     | FSharpReference of Type
 
 let (|BuiltinDefinition|_|) =
diff --git a/src/Fable.Transforms/Replacements.fs b/src/Fable.Transforms/Replacements.fs
index 4fd569e0f3..a6af1edad7 100644
--- a/src/Fable.Transforms/Replacements.fs
+++ b/src/Fable.Transforms/Replacements.fs
@@ -84,7 +84,7 @@ let coreModFor =
     | BclTimeSpan -> "TimeSpan"
     | FSharpSet _ -> "Set"
     | FSharpMap _ -> "Map"
-    | FSharpResult _ -> "Choice"
+    | FSharpResult _ -> "Result"
     | FSharpChoice _ -> "Choice"
     | FSharpReference _ -> "Types"
     | BclHashSet _ -> "MutableSet"
@@ -1127,7 +1127,7 @@ let tryEntityIdent (com: Compiler) entFullName =
     | BuiltinDefinition BclDateTimeOffset -> makeIdentExpr "Date" |> Some
     | BuiltinDefinition BclTimer -> makeImportLib com Any "default" "Timer" |> Some
     | BuiltinDefinition(FSharpReference _) -> makeImportLib com Any "FSharpRef" "Types" |> Some
-    | BuiltinDefinition(FSharpResult _) -> makeImportLib com Any "FSharpResult$2" "Choice" |> Some
+    | BuiltinDefinition(FSharpResult _) -> makeImportLib com Any "FSharpResult$2" "Result" |> Some
     | BuiltinDefinition(FSharpChoice genArgs) ->
         let membName = $"FSharpChoice${List.length genArgs}"
         makeImportLib com Any membName "Choice" |> Some
@@ -2733,7 +2733,7 @@ let results (com: ICompiler) (ctx: Context) r (t: Type) (i: CallInfo) (_: Expr o
     | "ToValueOption" as meth -> Some("Result_" + meth)
     | _ -> None
     |> Option.map (fun meth ->
-        Helper.LibCall(com, "Choice", meth, t, args, i.SignatureArgTypes, genArgs = i.GenericArgs, ?loc = r)
+        Helper.LibCall(com, "Result", meth, t, args, i.SignatureArgTypes, genArgs = i.GenericArgs, ?loc = r)
     )
 
 let nullables (com: ICompiler) (_: Context) r (t: Type) (i: CallInfo) (thisArg: Expr option) (args: Expr list) =
diff --git a/src/fable-library-dart/Choice.fs b/src/fable-library-dart/Choice.fs
index 3d0b8b1a62..e9398edd97 100644
--- a/src/fable-library-dart/Choice.fs
+++ b/src/fable-library-dart/Choice.fs
@@ -1,119 +1,5 @@
 namespace FSharp.Core
 
-[<CompiledName("FSharpResult`2")>]
-type Result<'T, 'TError> =
-    | Ok of ResultValue: 'T
-    | Error of ErrorValue: 'TError
-
-module Result =
-    [<CompiledName("Map")>]
-    let map mapping result =
-        match result with
-        | Error e -> Error e
-        | Ok x -> Ok(mapping x)
-
-    [<CompiledName("MapError")>]
-    let mapError mapping result =
-        match result with
-        | Error e -> Error(mapping e)
-        | Ok x -> Ok x
-
-    [<CompiledName("Bind")>]
-    let bind binder result =
-        match result with
-        | Error e -> Error e
-        | Ok x -> binder x
-
-    [<CompiledName("IsOk")>]
-    let isOk (result: Result<'a, 'b>) : bool =
-        match result with
-        | Error _ -> false
-        | Ok _ -> true
-
-    [<CompiledName("IsError")>]
-    let isError (result: Result<'a, 'b>) : bool =
-        match result with
-        | Error _ -> true
-        | Ok _ -> false
-
-    [<CompiledName("Contains")>]
-    let contains (value: 'a) (result: Result<'a, 'b>) : bool =
-        match result with
-        | Error _ -> false
-        | Ok x -> x = value
-
-    [<CompiledName("Count")>]
-    let count (result: Result<'a, 'b>) : int =
-        match result with
-        | Error _ -> 0
-        | Ok _ -> 1
-
-    [<CompiledName("DefaultValue")>]
-    let defaultValue (defaultValue: 'a) (result: Result<'a, 'b>) : 'a =
-        match result with
-        | Error _ -> defaultValue
-        | Ok x -> x
-
-    [<CompiledName("DefaultWith")>]
-    let defaultWith (defThunk: 'b -> 'a) (result: Result<'a, 'b>) : 'a =
-        match result with
-        | Error e -> defThunk e
-        | Ok x -> x
-
-    [<CompiledName("Exists")>]
-    let exists (predicate: 'a -> bool) (result: Result<'a, 'b>) : bool =
-        match result with
-        | Error _ -> false
-        | Ok x -> predicate x
-
-    [<CompiledName("Fold")>]
-    let fold<'a, 'b, 's> (folder: 's -> 'a -> 's) (state: 's) (result: Result<'a, 'b>) : 's =
-        match result with
-        | Error _ -> state
-        | Ok x -> folder state x
-
-    [<CompiledName("FoldBack")>]
-    let foldBack<'a, 'b, 's> (folder: 'a -> 's -> 's) (result: Result<'a, 'b>) (state: 's) : 's =
-        match result with
-        | Error _ -> state
-        | Ok x -> folder x state
-
-    [<CompiledName("ForAll")>]
-    let forall (predicate: 'a -> bool) (result: Result<'a, 'b>) : bool =
-        match result with
-        | Error _ -> true
-        | Ok x -> predicate x
-
-    [<CompiledName("Iterate")>]
-    let iterate (action: 'a -> unit) (result: Result<'a, 'b>) : unit =
-        match result with
-        | Error _ -> ()
-        | Ok x -> action x
-
-    [<CompiledName("ToArray")>]
-    let toArray (result: Result<'a, 'b>) : 'a[] =
-        match result with
-        | Error _ -> [||]
-        | Ok x -> [| x |]
-
-    [<CompiledName("ToList")>]
-    let toList (result: Result<'a, 'b>) : 'a list =
-        match result with
-        | Error _ -> []
-        | Ok x -> [ x ]
-
-    [<CompiledName("ToOption")>]
-    let toOption (result: Result<'a, 'b>) : Option<'a> =
-        match result with
-        | Error _ -> None
-        | Ok x -> Some x
-
-    [<CompiledName("ToValueOption")>]
-    let toValueOption (result: Result<'a, 'b>) : ValueOption<'a> =
-        match result with
-        | Error _ -> ValueNone
-        | Ok x -> ValueSome x
-
 [<CompiledName("FSharpChoice`2")>]
 type Choice<'T1, 'T2> =
     | Choice1Of2 of 'T1
diff --git a/src/fable-library-dart/Fable.Library.Dart.fsproj b/src/fable-library-dart/Fable.Library.Dart.fsproj
index 46009a0dd4..f6e5956605 100644
--- a/src/fable-library-dart/Fable.Library.Dart.fsproj
+++ b/src/fable-library-dart/Fable.Library.Dart.fsproj
@@ -10,6 +10,7 @@
         <Compile Include="Global.fs" />
         <Compile Include="FSharp.Core.fs" />
         <Compile Include="Option.fs" />
+        <Compile Include="Result.fs" />
         <Compile Include="Choice.fs" />
         <Compile Include="Seq.fs" />
         <Compile Include="Seq2.fs" />
diff --git a/src/fable-library-dart/Result.fs b/src/fable-library-dart/Result.fs
new file mode 100644
index 0000000000..af44d5a315
--- /dev/null
+++ b/src/fable-library-dart/Result.fs
@@ -0,0 +1,115 @@
+namespace FSharp.Core
+
+[<CompiledName("FSharpResult`2")>]
+type Result<'T, 'TError> =
+    | Ok of ResultValue: 'T
+    | Error of ErrorValue: 'TError
+
+module Result =
+    [<CompiledName("Map")>]
+    let map mapping result =
+        match result with
+        | Error e -> Error e
+        | Ok x -> Ok(mapping x)
+
+    [<CompiledName("MapError")>]
+    let mapError mapping result =
+        match result with
+        | Error e -> Error(mapping e)
+        | Ok x -> Ok x
+
+    [<CompiledName("Bind")>]
+    let bind binder result =
+        match result with
+        | Error e -> Error e
+        | Ok x -> binder x
+
+    [<CompiledName("IsOk")>]
+    let isOk (result: Result<'a, 'b>) : bool =
+        match result with
+        | Error _ -> false
+        | Ok _ -> true
+
+    [<CompiledName("IsError")>]
+    let isError (result: Result<'a, 'b>) : bool =
+        match result with
+        | Error _ -> true
+        | Ok _ -> false
+
+    [<CompiledName("Contains")>]
+    let contains (value: 'a) (result: Result<'a, 'b>) : bool =
+        match result with
+        | Error _ -> false
+        | Ok x -> x = value
+
+    [<CompiledName("Count")>]
+    let count (result: Result<'a, 'b>) : int =
+        match result with
+        | Error _ -> 0
+        | Ok _ -> 1
+
+    [<CompiledName("DefaultValue")>]
+    let defaultValue (defaultValue: 'a) (result: Result<'a, 'b>) : 'a =
+        match result with
+        | Error _ -> defaultValue
+        | Ok x -> x
+
+    [<CompiledName("DefaultWith")>]
+    let defaultWith (defThunk: 'b -> 'a) (result: Result<'a, 'b>) : 'a =
+        match result with
+        | Error e -> defThunk e
+        | Ok x -> x
+
+    [<CompiledName("Exists")>]
+    let exists (predicate: 'a -> bool) (result: Result<'a, 'b>) : bool =
+        match result with
+        | Error _ -> false
+        | Ok x -> predicate x
+
+    [<CompiledName("Fold")>]
+    let fold<'a, 'b, 's> (folder: 's -> 'a -> 's) (state: 's) (result: Result<'a, 'b>) : 's =
+        match result with
+        | Error _ -> state
+        | Ok x -> folder state x
+
+    [<CompiledName("FoldBack")>]
+    let foldBack<'a, 'b, 's> (folder: 'a -> 's -> 's) (result: Result<'a, 'b>) (state: 's) : 's =
+        match result with
+        | Error _ -> state
+        | Ok x -> folder x state
+
+    [<CompiledName("ForAll")>]
+    let forall (predicate: 'a -> bool) (result: Result<'a, 'b>) : bool =
+        match result with
+        | Error _ -> true
+        | Ok x -> predicate x
+
+    [<CompiledName("Iterate")>]
+    let iterate (action: 'a -> unit) (result: Result<'a, 'b>) : unit =
+        match result with
+        | Error _ -> ()
+        | Ok x -> action x
+
+    [<CompiledName("ToArray")>]
+    let toArray (result: Result<'a, 'b>) : 'a[] =
+        match result with
+        | Error _ -> [||]
+        | Ok x -> [| x |]
+
+    [<CompiledName("ToList")>]
+    let toList (result: Result<'a, 'b>) : 'a list =
+        match result with
+        | Error _ -> []
+        | Ok x -> [ x ]
+
+    [<CompiledName("ToOption")>]
+    let toOption (result: Result<'a, 'b>) : Option<'a> =
+        match result with
+        | Error _ -> None
+        | Ok x -> Some x
+
+    [<CompiledName("ToValueOption")>]
+    let toValueOption (result: Result<'a, 'b>) : ValueOption<'a> =
+        match result with
+        | Error _ -> ValueNone
+        | Ok x -> ValueSome x
diff --git a/src/fable-library-py/fable_library/Fable.Library.fsproj b/src/fable-library-py/fable_library/Fable.Library.fsproj
index 183137fd92..8de5e1d32e 100644
--- a/src/fable-library-py/fable_library/Fable.Library.fsproj
+++ b/src/fable-library-py/fable_library/Fable.Library.fsproj
@@ -18,6 +18,7 @@
     <Compile Include="Native.fs" />
     <Compile Include="../../fable-library/MutableMap.fs" Link="MutableMap.fs" />
     <Compile Include="../../fable-library/MutableSet.fs" Link="MutableSet.fs" />
+    <Compile Include="../../fable-library/Result.fs" Link="Result.fs" />
     <Compile Include="../../fable-library/Choice.fs" Link="Choice.fs" />
     <Compile Include="Array.fs" />
     <Compile Include="List.fs" />
diff --git a/src/fable-library/Choice.fs b/src/fable-library/Choice.fs
index de0722762c..4394a6daec 100644
--- a/src/fable-library/Choice.fs
+++ b/src/fable-library/Choice.fs
@@ -1,119 +1,5 @@
 namespace FSharp.Core
 
-[<CompiledName("FSharpResult`2")>]
-type Result<'T, 'TError> =
-    | Ok of ResultValue: 'T
-    | Error of ErrorValue: 'TError
-
-module Result =
-    [<CompiledName("Map")>]
-    let map (mapping: 'a -> 'b) (result: Result<'a, 'c>) : Result<'b, 'c> =
-        match result with
-        | Error e -> Error e
-        | Ok x -> Ok(mapping x)
-
-    [<CompiledName("MapError")>]
-    let mapError (mapping: 'a -> 'b) (result: Result<'c, 'a>) : Result<'c, 'b> =
-        match result with
-        | Error e -> Error(mapping e)
-        | Ok x -> Ok x
-
-    [<CompiledName("Bind")>]
-    let bind (binder: 'a -> Result<'b, 'c>) (result: Result<'a, 'c>) : Result<'b, 'c> =
-        match result with
-        | Error e -> Error e
-        | Ok x -> binder x
-
-    [<CompiledName("IsOk")>]
-    let isOk (result: Result<'a, 'b>) : bool =
-        match result with
-        | Error _ -> false
-        | Ok _ -> true
-
-    [<CompiledName("IsError")>]
-    let isError (result: Result<'a, 'b>) : bool =
-        match result with
-        | Error _ -> true
-        | Ok _ -> false
-
-    [<CompiledName("Contains")>]
-    let contains (value: 'a) (result: Result<'a, 'b>) : bool =
-        match result with
-        | Error _ -> false
-        | Ok x -> x = value
-
-    [<CompiledName("Count")>]
-    let count (result: Result<'a, 'b>) : int =
-        match result with
-        | Error _ -> 0
-        | Ok _ -> 1
-
-    [<CompiledName("DefaultValue")>]
-    let defaultValue (defaultValue: 'a) (result: Result<'a, 'b>) : 'a =
-        match result with
-        | Error _ -> defaultValue
-        | Ok x -> x
-
-    [<CompiledName("DefaultWith")>]
-    let defaultWith (defThunk: 'b -> 'a) (result: Result<'a, 'b>) : 'a =
-        match result with
-        | Error e -> defThunk e
-        | Ok x -> x
-
-    [<CompiledName("Exists")>]
-    let exists (predicate: 'a -> bool) (result: Result<'a, 'b>) : bool =
-        match result with
-        | Error _ -> false
-        | Ok x -> predicate x
-
-    [<CompiledName("Fold")>]
-    let fold<'a, 'b, 's> (folder: 's -> 'a -> 's) (state: 's) (result: Result<'a, 'b>) : 's =
-        match result with
-        | Error _ -> state
-        | Ok x -> folder state x
-
-    [<CompiledName("FoldBack")>]
-    let foldBack<'a, 'b, 's> (folder: 'a -> 's -> 's) (result: Result<'a, 'b>) (state: 's) : 's =
-        match result with
-        | Error _ -> state
-        | Ok x -> folder x state
-
-    [<CompiledName("ForAll")>]
-    let forall (predicate: 'a -> bool) (result: Result<'a, 'b>) : bool =
-        match result with
-        | Error _ -> true
-        | Ok x -> predicate x
-
-    [<CompiledName("Iterate")>]
-    let iterate (action: 'a -> unit) (result: Result<'a, 'b>) : unit =
-        match result with
-        | Error _ -> ()
-        | Ok x -> action x
-
-    [<CompiledName("ToArray")>]
-    let toArray (result: Result<'a, 'b>) : 'a[] =
-        match result with
-        | Error _ -> [||]
-        | Ok x -> [| x |]
-
-    [<CompiledName("ToList")>]
-    let toList (result: Result<'a, 'b>) : 'a list =
-        match result with
-        | Error _ -> []
-        | Ok x -> [ x ]
-
-    [<CompiledName("ToOption")>]
-    let toOption (result: Result<'a, 'b>) : Option<'a> =
-        match result with
-        | Error _ -> None
-        | Ok x -> Some x
-
-    [<CompiledName("ToValueOption")>]
-    let toValueOption (result: Result<'a, 'b>) : ValueOption<'a> =
-        match result with
-        | Error _ -> ValueNone
-        | Ok x -> ValueSome x
-
 [<CompiledName("FSharpChoice`2")>]
 type Choice<'T1, 'T2> =
     | Choice1Of2 of 'T1
diff --git a/src/fable-library/Fable.Library.fsproj b/src/fable-library/Fable.Library.fsproj
index da80224f5a..c8ffc86036 100644
--- a/src/fable-library/Fable.Library.fsproj
+++ b/src/fable-library/Fable.Library.fsproj
@@ -23,6 +23,7 @@
     <Compile Include="Native.fs" />
     <Compile Include="MutableMap.fs" />
     <Compile Include="MutableSet.fs" />
+    <Compile Include="Result.fs" />
     <Compile Include="Choice.fs" />
     <Compile Include="Array.fs" />
     <Compile Include="List.fs" />
diff --git a/src/fable-library/Result.fs b/src/fable-library/Result.fs
new file mode 100644
index 0000000000..fc1c0936b7
--- /dev/null
+++ b/src/fable-library/Result.fs
@@ -0,0 +1,115 @@
+namespace FSharp.Core
+
+[<CompiledName("FSharpResult`2")>]
+type Result<'T, 'TError> =
+    | Ok of ResultValue: 'T
+    | Error of ErrorValue: 'TError
+
+module Result =
+    [<CompiledName("Map")>]
+    let map (mapping: 'a -> 'b) (result: Result<'a, 'c>) : Result<'b, 'c> =
+        match result with
+        | Error e -> Error e
+        | Ok x -> Ok(mapping x)
+
+    [<CompiledName("MapError")>]
+    let mapError (mapping: 'a -> 'b) (result: Result<'c, 'a>) : Result<'c, 'b> =
+        match result with
+        | Error e -> Error(mapping e)
+        | Ok x -> Ok x
+
+    [<CompiledName("Bind")>]
+    let bind (binder: 'a -> Result<'b, 'c>) (result: Result<'a, 'c>) : Result<'b, 'c> =
+        match result with
+        | Error e -> Error e
+        | Ok x -> binder x
+
+    [<CompiledName("IsOk")>]
+    let isOk (result: Result<'a, 'b>) : bool =
+        match result with
+        | Error _ -> false
+        | Ok _ -> true
+
+    [<CompiledName("IsError")>]
+    let isError (result: Result<'a, 'b>) : bool =
+        match result with
+        | Error _ -> true
+        | Ok _ -> false
+
+    [<CompiledName("Contains")>]
+    let contains (value: 'a) (result: Result<'a, 'b>) : bool =
+        match result with
+        | Error _ -> false
+        | Ok x -> x = value
+
+    [<CompiledName("Count")>]
+    let count (result: Result<'a, 'b>) : int =
+        match result with
+        | Error _ -> 0
+        | Ok _ -> 1
+
+    [<CompiledName("DefaultValue")>]
+    let defaultValue (defaultValue: 'a) (result: Result<'a, 'b>) : 'a =
+        match result with
+        | Error _ -> defaultValue
+        | Ok x -> x
+
+    [<CompiledName("DefaultWith")>]
+    let defaultWith (defThunk: 'b -> 'a) (result: Result<'a, 'b>) : 'a =
+        match result with
+        | Error e -> defThunk e
+        | Ok x -> x
+
+    [<CompiledName("Exists")>]
+    let exists (predicate: 'a -> bool) (result: Result<'a, 'b>) : bool =
+        match result with
+        | Error _ -> false
+        | Ok x -> predicate x
+
+    [<CompiledName("Fold")>]
+    let fold<'a, 'b, 's> (folder: 's -> 'a -> 's) (state: 's) (result: Result<'a, 'b>) : 's =
+        match result with
+        | Error _ -> state
+        | Ok x -> folder state x
+
+    [<CompiledName("FoldBack")>]
+    let foldBack<'a, 'b, 's> (folder: 'a -> 's -> 's) (result: Result<'a, 'b>) (state: 's) : 's =
+        match result with
+        | Error _ -> state
+        | Ok x -> folder x state
+
+    [<CompiledName("ForAll")>]
+    let forall (predicate: 'a -> bool) (result: Result<'a, 'b>) : bool =
+        match result with
+        | Error _ -> true
+        | Ok x -> predicate x
+
+    [<CompiledName("Iterate")>]
+    let iterate (action: 'a -> unit) (result: Result<'a, 'b>) : unit =
+        match result with
+        | Error _ -> ()
+        | Ok x -> action x
+
+    [<CompiledName("ToArray")>]
+    let toArray (result: Result<'a, 'b>) : 'a[] =
+        match result with
+        | Error _ -> [||]
+        | Ok x -> [| x |]
+
+    [<CompiledName("ToList")>]
+    let toList (result: Result<'a, 'b>) : 'a list =
+        match result with
+        | Error _ -> []
+        | Ok x -> [ x ]
+
+    [<CompiledName("ToOption")>]
+    let toOption (result: Result<'a, 'b>) : Option<'a> =
+        match result with
+        | Error _ -> None
+        | Ok x -> Some x
+
+    [<CompiledName("ToValueOption")>]
+    let toValueOption (result: Result<'a, 'b>) : ValueOption<'a> =
+        match result with
+        | Error _ -> ValueNone
+        | Ok x -> ValueSome x
diff --git a/tests/Dart/src/ResultTests.fs b/tests/Dart/src/ResultTests.fs
index b789730b50..8d32c925b0 100644
--- a/tests/Dart/src/ResultTests.fs
+++ b/tests/Dart/src/ResultTests.fs
@@ -13,14 +13,14 @@ let foo (a: Foo): bool =
 let asError = Error
 
 let tests() =
-    testCase "constructors can be generated" <| fun () ->
+    testCase "Result constructors can be compared" <| fun () ->
         let ok: Result<int, int> = Ok 10
         Ok 10 |> equal ok
 
         let error: Result<int, int> = Error 10
         Error 10 |> equal error
 
-    testCase "pattern matching works" <| fun () ->
+    testCase "Result pattern matching works" <| fun () ->
         let ok: Result<string, int> = Ok "foo"
         match ok with
         | Ok x -> Some x
@@ -32,30 +32,30 @@ let tests() =
         | Error y -> Some y
         |> equal (Some 10)
 
-    testCase "map function can be generated" <| fun () ->
+    testCase "Result.map works" <| fun () ->
         let f = (+) 1
         Ok 9 |> Result.map f |> equal (Ok 10)
 
-    testCase "mapError function can be generated" <| fun () ->
+    testCase "Result.mapError works" <| fun () ->
         let f = (+) 1
         Error 9 |> Result.mapError f |> equal (Error 10)
 
-    testCase "bind function can be generated" <| fun () ->
+    testCase "Result.bind works" <| fun () ->
         Ok 10 |> Result.bind asError |> equal (Error 10)
 
     testCase "Nesting Result in pattern matching works" <| fun () -> // See #816
         Ok 5 |> Foo |> foo |> equal true
         Error "error" |> Foo |> foo |> equal false
 
-    testCase "isOk function can be generated" <| fun () ->
+    testCase "Result.isOk works" <| fun () ->
         Ok 10 |> Result.isOk |> equal true
         Error 10 |> Result.isOk |> equal false
 
-    testCase "isError function can be generated" <| fun () ->
+    testCase "Result.isError works" <| fun () ->
         Ok 10 |> Result.isError |> equal false
         Error 10 |> Result.isError |> equal true
 
-    testCase "contains function can be generated" <| fun () ->
+    testCase "Result.contains works" <| fun () ->
         let ok: Result<int, string> = Ok 42
         let err: Result<int, string> = Error "error"
 
@@ -63,28 +63,28 @@ let tests() =
         ok |> Result.contains 43 |> equal false
         err |> Result.contains 42 |> equal false
 
-    testCase "count function can be generated" <| fun () ->
+    testCase "Result.count works" <| fun () ->
         let ok: Result<int, string> = Ok 42
         let err: Result<int, string> = Error "error"
 
         ok |> Result.count |> equal 1
         err |> Result.count |> equal 0
 
-    testCase "defaultValue function can be generated" <| fun () ->
+    testCase "Result.defaultValue works" <| fun () ->
         let ok: Result<int, string> = Ok 42
         let err: Result<int, string> = Error "error"
 
         ok |> Result.defaultValue 0 |> equal 42
         err |> Result.defaultValue 0 |> equal 0
 
-    testCase "defaultWith function can be generated" <| fun () ->
+    testCase "Result.defaultWith works" <| fun () ->
         let ok: Result<int, string> = Ok 42
         let err: Result<int, string> = Error "error"
 
         ok |> Result.defaultWith (fun e -> e.Length) |> equal 42
         err |> Result.defaultWith (fun e -> e.Length) |> equal 5
 
-    testCase "exists function can be generated" <| fun () ->
+    testCase "Result.exists works" <| fun () ->
         let ok: Result<int, string> = Ok 42
         let err: Result<int, string> = Error "error"
 
@@ -92,21 +92,21 @@ let tests() =
         ok |> Result.exists ((=) 43) |> equal false
         err |> Result.exists ((=) 42) |> equal false
 
-    testCase "fold function can be generated" <| fun () ->
+    testCase "Result.fold works" <| fun () ->
         let ok: Result<int, string> = Ok 42
         let err: Result<int, string> = Error "error"
 
         ok |> Result.fold (fun s x -> s || x % 2 = 0) false |> equal true
         err |> Result.fold (fun s x -> s || x % 2 = 0) false |> equal false
 
-    testCase "foldBack function can be generated" <| fun () ->
+    testCase "Result.foldBack works" <| fun () ->
         let ok: Result<int, string> = Ok 42
         let err: Result<int, string> = Error "error"
 
         (ok, false) ||> Result.foldBack (fun x s -> s || x % 2 = 0) |> equal true
         (err, false) ||> Result.foldBack (fun x s -> s || x % 2 = 0) |> equal false
 
-    testCase "forAll function can be generated" <| fun () ->
+    testCase "Result.forall works" <| fun () ->
         let ok: Result<int, string> = Ok 42
         let err: Result<int, string> = Error "error"
 
@@ -114,7 +114,7 @@ let tests() =
         ok |> Result.forall ((=) 43) |> equal false
         err |> Result.forall ((=) 42) |> equal true
 
-    testCase "iter function can be generated" <| fun () ->
+    testCase "Result.iter works" <| fun () ->
         let ok: Result<int, string> = Ok 42
         let err: Result<int, string> = Error "error"
 
@@ -126,30 +126,37 @@ let tests() =
         err |> Result.iter (fun x -> count <- count + x)
         equal 0 count
 
-    testCase "toArray function can be generated" <| fun () ->
+    testCase "Result.toArray works" <| fun () ->
         let ok: Result<int, string> = Ok 42
         let err: Result<int, string> = Error "error"
 
         ok |> Result.toArray |> equal [| 42 |]
         err |> Result.toArray |> equal [||]
 
-    testCase "toList function can be generated" <| fun () ->
+    testCase "Result.toList works" <| fun () ->
         let ok: Result<int, string> = Ok 42
         let err: Result<int, string> = Error "error"
 
         ok |> Result.toList |> equal [ 42 ]
         err |> Result.toList |> equal []
 
-    testCase "toOption function can be generated" <| fun () ->
+    testCase "Result.toOption works" <| fun () ->
         let ok: Result<int, string> = Ok 42
         let err: Result<int, string> = Error "error"
 
         ok |> Result.toOption |> Option.get |> equal 42
         err |> Result.toOption |> Option.isNone |> equal true
 
-    testCase "toValueOption works" <| fun () ->
+    testCase "Result.toValueOption works" <| fun () ->
         let ok: Result<int, string> = Ok 42
         let err: Result<int, string> = Error "error"
 
         ok |> Result.toValueOption |> ValueOption.get |> equal 42
         err |> Result.toValueOption |> ValueOption.isNone |> equal true
+
+    testCase "Choice pattern matching works" <| fun () ->
+        let ok: Choice<string, int> = Choice1Of2 "foo"
+        match ok with
+        | Choice1Of2 x -> Some x
+        | Choice2Of2 _ -> None
+        |> equal (Some "foo")
diff --git a/tests/Js/Main/ResultTests.fs b/tests/Js/Main/ResultTests.fs
index a75a44ef0b..0ee00c922c 100644
--- a/tests/Js/Main/ResultTests.fs
+++ b/tests/Js/Main/ResultTests.fs
@@ -12,14 +12,14 @@ let foo (a: Foo): bool =
 
 let tests =
   testList "Result" [
-    testCase "constructors can be generated" <| fun () ->
+    testCase "Result constructors can be compared" <| fun () ->
         let ok = Ok 10
         Ok 10 |> equal ok
 
         let error = Error 10
         Error 10 |> equal error
 
-    testCase "pattern matching works" <| fun () ->
+    testCase "Result pattern matching works" <| fun () ->
         let mutable f = fun ok ->
             match ok with
             | Ok x -> Some x
@@ -35,15 +35,15 @@ let tests =
         let ok = Ok "foo"
         f ok
 
-    testCase "map function can be generated" <| fun () ->
+    testCase "Result.map works" <| fun () ->
         let f = (+) 1
         Ok 9 |> Result.map f |> equal (Ok 10)
 
-    testCase "mapError function can be generated" <| fun () ->
+    testCase "Result.mapError works" <| fun () ->
         let f = (+) 1
         Error 9 |> Result.mapError f |> equal (Error 10)
 
-    testCase "bind function can be generated" <| fun () ->
+    testCase "Result.bind works" <| fun () ->
         let f = Error
         Ok 10 |> Result.bind f |> equal (Error 10)
 
@@ -51,15 +51,15 @@ let tests =
         Ok 5 |> Foo |> foo |> equal true
         Error "error" |> Foo |> foo |> equal false
 
-    testCase "isOk function can be generated" <| fun () ->
+    testCase "Result.isOk works" <| fun () ->
         Ok 10 |> Result.isOk |> equal true
         Error 10 |> Result.isOk |> equal false
 
-    testCase "isError function can be generated" <| fun () ->
+    testCase "Result.isError works" <| fun () ->
         Ok 10 |> Result.isError |> equal false
         Error 10 |> Result.isError |> equal true
 
-    testCase "contains works" <| fun () ->
+    testCase "Result.contains works" <| fun () ->
         let ok: Result<int, string> = Ok 42
         let err: Result<int, string> = Error "error"
 
@@ -67,28 +67,28 @@ let tests =
         ok |> Result.contains 43 |> equal false
         err |> Result.contains 42 |> equal false
 
-    testCase "count works" <| fun () ->
+    testCase "Result.count works" <| fun () ->
         let ok: Result<int, string> = Ok 42
         let err: Result<int, string> = Error "error"
 
         ok |> Result.count |> equal 1
         err |> Result.count |> equal 0
 
-    testCase "defaultValue works" <| fun () ->
+    testCase "Result.defaultValue works" <| fun () ->
         let ok: Result<int, string> = Ok 42
         let err: Result<int, string> = Error "error"
 
         ok |> Result.defaultValue 0 |> equal 42
         err |> Result.defaultValue 0 |> equal 0
 
-    testCase "defaultWith works" <| fun () ->
+    testCase "Result.defaultWith works" <| fun () ->
         let ok: Result<int, string> = Ok 42
         let err: Result<int, string> = Error "error"
 
         ok |> Result.defaultWith (fun e -> e.Length) |> equal 42
         err |> Result.defaultWith (fun e -> e.Length) |> equal 5
 
-    testCase "exists works" <| fun () ->
+    testCase "Result.exists works" <| fun () ->
         let ok: Result<int, string> = Ok 42
         let err: Result<int, string> = Error "error"
 
@@ -96,21 +96,21 @@ let tests =
         ok |> Result.exists ((=) 43) |> equal false
         err |> Result.exists ((=) 42) |> equal false
 
-    testCase "fold works" <| fun () ->
+    testCase "Result.fold works" <| fun () ->
         let ok: Result<int, string> = Ok 42
         let err: Result<int, string> = Error "error"
 
         ok |> Result.fold (fun s x -> s || x % 2 = 0) false |> equal true
         err |> Result.fold (fun s x -> s || x % 2 = 0) false |> equal false
 
-    testCase "foldBack works" <| fun () ->
+    testCase "Result.foldBack works" <| fun () ->
         let ok: Result<int, string> = Ok 42
         let err: Result<int, string> = Error "error"
 
         (ok, false) ||> Result.foldBack (fun x s -> s || x % 2 = 0) |> equal true
         (err, false) ||> Result.foldBack (fun x s -> s || x % 2 = 0) |> equal false
 
-    testCase "forAll works" <| fun () ->
+    testCase "Result.forall works" <| fun () ->
         let ok: Result<int, string> = Ok 42
         let err: Result<int, string> = Error "error"
 
@@ -118,7 +118,7 @@ let tests =
         ok |> Result.forall ((=) 43) |> equal false
         err |> Result.forall ((=) 42) |> equal true
 
-    testCase "iter works" <| fun () ->
+    testCase "Result.iter works" <| fun () ->
         let ok: Result<int, string> = Ok 42
         let err: Result<int, string> = Error "error"
 
@@ -130,31 +130,40 @@ let tests =
         err |> Result.iter (fun x -> count <- count + x)
         equal 0 count
 
-    testCase "toArray works" <| fun () ->
+    testCase "Result.toArray works" <| fun () ->
         let ok: Result<int, string> = Ok 42
         let err: Result<int, string> = Error "error"
 
         ok |> Result.toArray |> equal [| 42 |]
         err |> Result.toArray |> equal [||]
 
-    testCase "toList works" <| fun () ->
+    testCase "Result.toList works" <| fun () ->
         let ok: Result<int, string> = Ok 42
         let err: Result<int, string> = Error "error"
 
         ok |> Result.toList |> equal [ 42 ]
         err |> Result.toList |> equal []
 
-    testCase "toOption works" <| fun () ->
+    testCase "Result.toOption works" <| fun () ->
         let ok: Result<int, string> = Ok 42
         let err: Result<int, string> = Error "error"
 
         ok |> Result.toOption |> Option.get |> equal 42
         err |> Result.toOption |> Option.isNone |> equal true
 
-    testCase "toValueOption works" <| fun () ->
+    testCase "Result.toValueOption works" <| fun () ->
         let ok: Result<int, string> = Ok 42
         let err: Result<int, string> = Error "error"
 
         ok |> Result.toValueOption |> ValueOption.get |> equal 42
         err |> Result.toValueOption |> ValueOption.isNone |> equal true
+
+#if !FABLE_COMPILER_TYPESCRIPT
+    testCase "Choice pattern matching works" <| fun () ->
+        let ok: Choice<string, int> = Choice1Of2 "foo"
+        match ok with
+        | Choice1Of2 x -> Some x
+        | Choice2Of2 _ -> None
+        |> equal (Some "foo")
+#endif
   ]
diff --git a/tests/Python/TestResult.fs b/tests/Python/TestResult.fs
index 4770724e2d..2f71af9ab9 100644
--- a/tests/Python/TestResult.fs
+++ b/tests/Python/TestResult.fs
@@ -11,7 +11,7 @@ let foo (a: Foo): bool =
     | _ -> false
 
 [<Fact>]
-let ``test constructors can be generated`` () =
+let ``test Result constructors can be compared`` () =
     let ok = Ok 10
     Ok 10 |> equal ok
 
@@ -19,7 +19,7 @@ let ``test constructors can be generated`` () =
     Error 10 |> equal error
 
 [<Fact>]
-let ``test pattern matching works`` () =
+let ``test Result pattern matching works`` () =
     let ok = Ok "foo"
     match ok with
     | Ok x -> Some x
@@ -33,17 +33,17 @@ let ``test pattern matching works`` () =
     |> equal (Some 10)
 
 [<Fact>]
-let ``test map function can be generated`` () =
+let ``test Result.map works`` () =
     let f = (+) 1
     Ok 9 |> Result.map f |> equal (Ok 10)
 
 [<Fact>]
-let ``test mapError function can be generated`` () =
+let ``test Result.mapError works`` () =
     let f = (+) 1
     Error 9 |> Result.mapError f |> equal (Error 10)
 
 [<Fact>]
-let ``test bind function can be generated`` () =
+let ``test Result.bind works`` () =
     let f = Error
     Ok 10 |> Result.bind f |> equal (Error 10)
 
@@ -53,17 +53,17 @@ let ``test Nesting Result in pattern matching works`` () =
     Error "error" |> Foo |> foo |> equal false
 
 [<Fact>]
-let ``test isOk function can be generated`` () =
+let ``test Result.isOk works`` () =
     Ok 5 |> Result.isOk |> equal true
     Error "error" |> Result.isOk |> equal false
 
 [<Fact>]
-let ``test isError function can be generated`` () =
+let ``test Result.isError works`` () =
     Ok 5 |> Result.isError |> equal false
     Error "error" |> Result.isError |> equal true
 
 [<Fact>]
-let ``test contains function can be generated`` () =
+let ``test Result.contains works`` () =
     let ok: Result<int, string> = Ok 42
     let err: Result<int, string> = Error "error"
 
@@ -72,7 +72,7 @@ let ``test contains function can be generated`` () =
     err |> Result.contains 42 |> equal false
 
 [<Fact>]
-let ``count function can be generated`` () =
+let ``test Result.count works`` () =
     let ok: Result<int, string> = Ok 42
     let err: Result<int, string> = Error "error"
 
@@ -80,7 +80,7 @@ let ``count function can be generated`` () =
     err |> Result.count |> equal 0
 
 [<Fact>]
-let ``defaultValue function can be generated`` () =
+let ``test Result.defaultValue works`` () =
     let ok: Result<int, string> = Ok 42
     let err: Result<int, string> = Error "error"
 
@@ -88,7 +88,7 @@ let ``defaultValue function can be generated`` () =
     err |> Result.defaultValue 0 |> equal 0
 
 [<Fact>]
-let ``defaultWith function can be generated`` () =
+let ``test Result.defaultWith works`` () =
     let ok: Result<int, string> = Ok 42
     let err: Result<int, string> = Error "error"
 
@@ -96,7 +96,7 @@ let ``defaultWith function can be generated`` () =
     err |> Result.defaultWith (fun e -> e.Length) |> equal 5
 
 [<Fact>]
-let ``exists function can be generated`` () =
+let ``test Result.exists works`` () =
     let ok: Result<int, string> = Ok 42
     let err: Result<int, string> = Error "error"
 
@@ -105,7 +105,7 @@ let ``exists function can be generated`` () =
     err |> Result.exists ((=) 42) |> equal false
 
 [<Fact>]
-let ``fold function can be generated`` () =
+let ``test Result.fold works`` () =
     let ok: Result<int, string> = Ok 42
     let err: Result<int, string> = Error "error"
 
@@ -113,7 +113,7 @@ let ``fold function can be generated`` () =
     err |> Result.fold (fun s x -> s || x % 2 = 0) false |> equal false
 
 [<Fact>]
-let ``foldBack function can be generated`` () =
+let ``test Result.foldBack works`` () =
     let ok: Result<int, string> = Ok 42
     let err: Result<int, string> = Error "error"
 
@@ -121,7 +121,7 @@ let ``foldBack function can be generated`` () =
     (err, false) ||> Result.foldBack (fun x s -> s || x % 2 = 0) |> equal false
 
 [<Fact>]
-let ``forAll function can be generated`` () =
+let ``test Result.forall works`` () =
     let ok: Result<int, string> = Ok 42
     let err: Result<int, string> = Error "error"
 
@@ -130,7 +130,7 @@ let ``forAll function can be generated`` () =
     err |> Result.forall ((=) 42) |> equal true
 
 [<Fact>]
-let ``iter function can be generated`` () =
+let ``test Result.iter works`` () =
     let ok: Result<int, string> = Ok 42
     let err: Result<int, string> = Error "error"
 
@@ -143,7 +143,7 @@ let ``iter function can be generated`` () =
     equal 0 count
 
 [<Fact>]
-let ``toArray function can be generated`` () =
+let ``test Result.toArray works`` () =
     let ok: Result<int, string> = Ok 42
     let err: Result<int, string> = Error "error"
 
@@ -151,7 +151,7 @@ let ``toArray function can be generated`` () =
     err |> Result.toArray |> equal [||]
 
 [<Fact>]
-let ``toList function can be generated`` () =
+let ``test Result.toList works`` () =
     let ok: Result<int, string> = Ok 42
     let err: Result<int, string> = Error "error"
 
@@ -159,7 +159,7 @@ let ``toList function can be generated`` () =
     err |> Result.toList |> equal []
 
 [<Fact>]
-let ``toOption function can be generated`` () =
+let ``test Result.toOption works`` () =
     let ok: Result<int, string> = Ok 42
     let err: Result<int, string> = Error "error"
 
@@ -167,9 +167,17 @@ let ``toOption function can be generated`` () =
     err |> Result.toOption |> Option.isNone |> equal true
 
 [<Fact>]
-let ``toValueOption function can be generated`` () =
+let ``test Result.toValueOption works`` () =
     let ok: Result<int, string> = Ok 42
     let err: Result<int, string> = Error "error"
 
     ok |> Result.toValueOption |> ValueOption.get |> equal 42
     err |> Result.toValueOption |> ValueOption.isNone |> equal true
+
+[<Fact>]
+let ``test Choice pattern matching works`` () =
+    let ok: Choice<string, int> = Choice1Of2 "foo"
+    match ok with
+    | Choice1Of2 x -> Some x
+    | Choice2Of2 _ -> None
+    |> equal (Some "foo")
diff --git a/tests/Rust/tests/src/ResultTests.fs b/tests/Rust/tests/src/ResultTests.fs
index 50f0f8f171..27c02094d6 100644
--- a/tests/Rust/tests/src/ResultTests.fs
+++ b/tests/Rust/tests/src/ResultTests.fs
@@ -11,14 +11,14 @@ let foo (a: Foo): bool =
     | _ -> false
 
 // [<Fact>]
-// let ``Generic constructors can be compared`` () =
+// let ``Result constructors can be compared`` () =
 //     let ok = Ok 10
 //     Ok 10 |> equal ok
 //     let error = Error 10
 //     Error 10 |> equal error
 
 [<Fact>]
-let ``Pattern matching works`` () =
+let ``Result pattern matching works`` () =
     let ok: Result<string, int> = Ok "foo"
     match ok with
     | Ok x -> Some x
@@ -32,19 +32,19 @@ let ``Pattern matching works`` () =
     |> equal (Some 10)
 
 [<Fact>]
-let ``Map function can be generated`` () =
+let ``Result.map works`` () =
     let f = (+) 1
     let ok: Result<int, float> = Ok 9
     ok |> Result.map f |> equal (Ok 10)
 
 [<Fact>]
-let ``MapError function can be generated`` () =
+let ``Result.mapError works`` () =
     let f = (+) 1
     let error: Result<float, int> = Error 9
     error |> Result.mapError f |> equal (Error 10)
 
 [<Fact>]
-let ``Bind function can be generated`` () =
+let ``Result.bind works`` () =
     let res: Result<int, int> = Ok 10 |> Result.bind Error
     res |> equal (Error 10)
 
@@ -54,21 +54,21 @@ let ``Nesting Result in pattern matching works`` () =
     Error "error" |> Foo |> foo |> equal false
 
 [<Fact>]
-let ``isOk function can be generated`` () =
+let ``Result.isOk works`` () =
     let ok: Result<int, string> = Ok 5
     let err: Result<int, string> = Error "error"
     ok |> Result.isOk |> equal true
     err |> Result.isOk |> equal false
 
 [<Fact>]
-let ``isError function can be generated`` () =
+let ``Result.isError works`` () =
     let ok: Result<int, string> = Ok 5
     let err: Result<int, string> = Error "error"
     ok |> Result.isError |> equal false
     err |> Result.isError |> equal true
 
 [<Fact>]
-let ``test contains function can be generated`` () =
+let ``Result.contains works`` () =
     let ok: Result<int, string> = Ok 42
     let err: Result<int, string> = Error "error"
 
@@ -77,7 +77,7 @@ let ``test contains function can be generated`` () =
     err |> Result.contains 42 |> equal false
 
 [<Fact>]
-let ``count function can be generated`` () =
+let ``Result.count works`` () =
     let ok: Result<int, string> = Ok 42
     let err: Result<int, string> = Error "error"
 
@@ -85,7 +85,7 @@ let ``count function can be generated`` () =
     err |> Result.count |> equal 0
 
 [<Fact>]
-let ``defaultValue function can be generated`` () =
+let ``Result.defaultValue works`` () =
     let ok: Result<int, string> = Ok 42
     let err: Result<int, string> = Error "error"
 
@@ -93,7 +93,7 @@ let ``defaultValue function can be generated`` () =
     err |> Result.defaultValue 0 |> equal 0
 
 [<Fact>]
-let ``defaultWith function can be generated`` () =
+let ``Result.defaultWith works`` () =
     let ok: Result<int, string> = Ok 42
     let err: Result<int, string> = Error "error"
 
@@ -101,7 +101,7 @@ let ``defaultWith function can be generated`` () =
     err |> Result.defaultWith (fun e -> e.Length) |> equal 5
 
 [<Fact>]
-let ``exists function can be generated`` () =
+let ``Result.exists works`` () =
     let ok: Result<int, string> = Ok 42
     let err: Result<int, string> = Error "error"
 
@@ -110,7 +110,7 @@ let ``exists function can be generated`` () =
     err |> Result.exists ((=) 42) |> equal false
 
 [<Fact>]
-let ``fold function can be generated`` () =
+let ``Result.fold works`` () =
     let ok: Result<int, string> = Ok 42
     let err: Result<int, string> = Error "error"
 
@@ -118,7 +118,7 @@ let ``fold function can be generated`` () =
     err |> Result.fold (fun s x -> s || x % 2 = 0) false |> equal false
 
 [<Fact>]
-let ``foldBack function can be generated`` () =
+let ``Result.foldBack works`` () =
     let ok: Result<int, string> = Ok 42
     let err: Result<int, string> = Error "error"
 
@@ -126,7 +126,7 @@ let ``foldBack function can be generated`` () =
     (err, false) ||> Result.foldBack (fun x s -> s || x % 2 = 0) |> equal false
 
 [<Fact>]
-let ``forAll function can be generated`` () =
+let ``Result.forall works`` () =
     let ok: Result<int, string> = Ok 42
     let err: Result<int, string> = Error "error"
 
@@ -135,7 +135,7 @@ let ``forAll function can be generated`` () =
     err |> Result.forall ((=) 42) |> equal true
 
 [<Fact>]
-let ``iter function can be generated`` () =
+let ``Result.iter works`` () =
     let ok: Result<int, string> = Ok 42
     let err: Result<int, string> = Error "error"
 
@@ -148,7 +148,7 @@ let ``iter function can be generated`` () =
     equal 0 count
 
 [<Fact>]
-let ``toArray function can be generated`` () =
+let ``Result.toArray works`` () =
     let ok: Result<int, string> = Ok 42
     let err: Result<int, string> = Error "error"
 
@@ -156,7 +156,7 @@ let ``toArray function can be generated`` () =
     err |> Result.toArray |> equal [||]
 
 [<Fact>]
-let ``toList function can be generated`` () =
+let ``Result.toList works`` () =
     let ok: Result<int, string> = Ok 42
     let err: Result<int, string> = Error "error"
 
@@ -164,7 +164,7 @@ let ``toList function can be generated`` () =
     err |> Result.toList |> equal []
 
 [<Fact>]
-let ``toOption function can be generated`` () =
+let ``Result.toOption works`` () =
     let ok: Result<int, string> = Ok 42
     let err: Result<int, string> = Error "error"
 
@@ -172,7 +172,7 @@ let ``toOption function can be generated`` () =
     err |> Result.toOption |> Option.isNone |> equal true
 
 [<Fact>]
-let ``toValueOption function can be generated`` () =
+let ``Result.toValueOption works`` () =
     let ok: Result<int, string> = Ok 42
     let err: Result<int, string> = Error "error"
 
@@ -180,7 +180,7 @@ let ``toValueOption function can be generated`` () =
     err |> Result.toValueOption |> ValueOption.isNone |> equal true
 
 [<Fact>]
-let ``Choice matching works`` () =
+let ``Choice pattern matching works`` () =
     let ok: Choice<string, int> = Choice1Of2 "foo"
     match ok with
     | Choice1Of2 x -> Some x