[RFC] inline op_Implicit for Erased Unions

src/Fable.Core/Fable.Core.Types.fs

@@ -125,18 +125,61 @@ type NamedParamsAttribute = ParamObjectAttribute
 type InjectAttribute() =
     inherit Attribute()
 
-/// Erased union type to represent one of two possible values.
-/// More info: https://fable.io/docs/communicate/js-from-fable.html#erase-attribute
+/// <summary>
+/// Erased union type to represent one of two possible value types mainly intended for typing the signature of imported
+/// JS functions.
+/// </summary>
+/// <remarks>
+/// Pattern matching is possible, but should consider the implications of the Erased union and JS type testing (see the
+/// docs for details).
+/// <br/>
+/// Member concrete types will be implicitly cast into the union, and will provide a warning to this effect. Usage of
+/// the explicit cast operator <c>!^</c> available in <c>Fable.Core.JsInterop</c> will remove this warning.
+/// <a href="https://github.com/fable-compiler/Fable/pull/4143">Collection types, can provide an error</a> that will
+/// only be resolved with the explicit operator. <a href="https://github.com/glutinum-org/cli/issues/80">Anonymous
+/// records have other considerations that may be relevant if you are encountering issues.</a>
+/// <code lang="fsharp">
+/// let test(arg: U3&lt;string, int, float[]>) =
+///     match arg with
+///     | U3.Case1 x -> printfn "A string %s" x
+///     | U3.Case2 x -> printfn "An int %i" x
+///     | U3.Case3 xs -> Array.sum xs |> printfn "An array with sum %f"
+/// </code>
+/// </remarks>
+/// <seealso href="https://fable.io/docs/communicate/js-from-fable.html#erase-attribute"/>
 [<Erase>]
 type U2<'a, 'b> =
     | Case1 of 'a
     | Case2 of 'b
 
     static member op_ErasedCast(x: 'a) = Case1 x
     static member op_ErasedCast(x: 'b) = Case2 x
+    static member inline op_Implicit(x: 'a) : U2<'a, 'b> = Case1 x
+    static member inline op_Implicit(x: 'b) : U2<'a, 'b> = Case2 x
+
+/// <summary>
+/// Erased union type to represent one of three possible value types mainly intended for typing the signature of imported
+/// JS functions.
+/// </summary>
+/// <remarks>
+/// Pattern matching is possible, but should consider the implications of the Erased union and JS type testing (see the
+/// docs for details).
+/// <br/>
+/// Member concrete types will be implicitly cast into the union, and will provide a warning to this effect. Usage of
+/// the explicit cast operator <c>!^</c> available in <c>Fable.Core.JsInterop</c> will remove this warning.
+/// <a href="https://github.com/fable-compiler/Fable/pull/4143">Collection types, can provide an error</a> that will
+/// only be resolved with the explicit operator. <a href="https://github.com/glutinum-org/cli/issues/80">Anonymous
+/// records have other considerations that may be relevant if you are encountering issues.</a>
+/// <code lang="fsharp">
+/// let test(arg: U3&lt;string, int, float[]>) =
+///     match arg with
+///     | U3.Case1 x -> printfn "A string %s" x
+///     | U3.Case2 x -> printfn "An int %i" x
+///     | U3.Case3 xs -> Array.sum xs |> printfn "An array with sum %f"
+/// </code>
+/// </remarks>
+/// <seealso href="https://fable.io/docs/communicate/js-from-fable.html#erase-attribute"/>
 
-/// Erased union type to represent one of three possible values.
-/// More info: https://fable.io/docs/communicate/js-from-fable.html#erase-attribute
 [<Erase>]
 type U3<'a, 'b, 'c> =
     | Case1 of 'a
@@ -146,9 +189,32 @@ type U3<'a, 'b, 'c> =
     static member op_ErasedCast(x: 'a) = Case1 x
     static member op_ErasedCast(x: 'b) = Case2 x
     static member op_ErasedCast(x: 'c) = Case3 x
-
-/// Erased union type to represent one of four possible values.
-/// More info: https://fable.io/docs/communicate/js-from-fable.html#erase-attribute
+    static member inline op_Implicit(x: 'a) : U3<'a, 'b, 'c> = Case1 x
+    static member inline op_Implicit(x: 'b) : U3<'a, 'b, 'c> = Case2 x
+    static member inline op_Implicit(x: 'c) : U3<'a, 'b, 'c> = Case3 x
+
+/// <summary>
+/// Erased union type to represent one of four possible value types mainly intended for typing the signature of imported
+/// JS functions.
+/// </summary>
+/// <remarks>
+/// Pattern matching is possible, but should consider the implications of the Erased union and JS type testing (see the
+/// docs for details).
+/// <br/>
+/// Member concrete types will be implicitly cast into the union, and will provide a warning to this effect. Usage of
+/// the explicit cast operator <c>!^</c> available in <c>Fable.Core.JsInterop</c> will remove this warning.
+/// <a href="https://github.com/fable-compiler/Fable/pull/4143">Collection types, can provide an error</a> that will
+/// only be resolved with the explicit operator. <a href="https://github.com/glutinum-org/cli/issues/80">Anonymous
+/// records have other considerations that may be relevant if you are encountering issues.</a>
+/// <code lang="fsharp">
+/// let test(arg: U3&lt;string, int, float[]>) =
+///     match arg with
+///     | U3.Case1 x -> printfn "A string %s" x
+///     | U3.Case2 x -> printfn "An int %i" x
+///     | U3.Case3 xs -> Array.sum xs |> printfn "An array with sum %f"
+/// </code>
+/// </remarks>
+/// <seealso href="https://fable.io/docs/communicate/js-from-fable.html#erase-attribute"/>
 [<Erase>]
 type U4<'a, 'b, 'c, 'd> =
     | Case1 of 'a
@@ -160,9 +226,33 @@ type U4<'a, 'b, 'c, 'd> =
     static member op_ErasedCast(x: 'b) = Case2 x
     static member op_ErasedCast(x: 'c) = Case3 x
     static member op_ErasedCast(x: 'd) = Case4 x
-
-/// Erased union type to represent one of five possible values.
-/// More info: https://fable.io/docs/communicate/js-from-fable.html#erase-attribute
+    static member inline op_Implicit(x: 'a) : U4<'a, 'b, 'c, 'd> = Case1 x
+    static member inline op_Implicit(x: 'b) : U4<'a, 'b, 'c, 'd> = Case2 x
+    static member inline op_Implicit(x: 'c) : U4<'a, 'b, 'c, 'd> = Case3 x
+    static member inline op_Implicit(x: 'd) : U4<'a, 'b, 'c, 'd> = Case4 x
+
+/// <summary>
+/// Erased union type to represent one of five possible value types mainly intended for typing the signature of imported
+/// JS functions.
+/// </summary>
+/// <remarks>
+/// Pattern matching is possible, but should consider the implications of the Erased union and JS type testing (see the
+/// docs for details).
+/// <br/>
+/// Member concrete types will be implicitly cast into the union, and will provide a warning to this effect. Usage of
+/// the explicit cast operator <c>!^</c> available in <c>Fable.Core.JsInterop</c> will remove this warning.
+/// <a href="https://github.com/fable-compiler/Fable/pull/4143">Collection types, can provide an error</a> that will
+/// only be resolved with the explicit operator. <a href="https://github.com/glutinum-org/cli/issues/80">Anonymous
+/// records have other considerations that may be relevant if you are encountering issues.</a>
+/// <code lang="fsharp">
+/// let test(arg: U3&lt;string, int, float[]>) =
+///     match arg with
+///     | U3.Case1 x -> printfn "A string %s" x
+///     | U3.Case2 x -> printfn "An int %i" x
+///     | U3.Case3 xs -> Array.sum xs |> printfn "An array with sum %f"
+/// </code>
+/// </remarks>
+/// <seealso href="https://fable.io/docs/communicate/js-from-fable.html#erase-attribute"/>
 [<Erase>]
 type U5<'a, 'b, 'c, 'd, 'e> =
     | Case1 of 'a
@@ -176,9 +266,34 @@ type U5<'a, 'b, 'c, 'd, 'e> =
     static member op_ErasedCast(x: 'c) = Case3 x
     static member op_ErasedCast(x: 'd) = Case4 x
     static member op_ErasedCast(x: 'e) = Case5 x
-
-/// Erased union type to represent one of six possible values.
-/// More info: https://fable.io/docs/communicate/js-from-fable.html#erase-attribute
+    static member inline op_Implicit(x: 'a) : U5<'a, 'b, 'c, 'd, 'e> = Case1 x
+    static member inline op_Implicit(x: 'b) : U5<'a, 'b, 'c, 'd, 'e> = Case2 x
+    static member inline op_Implicit(x: 'c) : U5<'a, 'b, 'c, 'd, 'e> = Case3 x
+    static member inline op_Implicit(x: 'd) : U5<'a, 'b, 'c, 'd, 'e> = Case4 x
+    static member inline op_Implicit(x: 'e) : U5<'a, 'b, 'c, 'd, 'e> = Case5 x
+
+/// <summary>
+/// Erased union type to represent one of six possible value types mainly intended for typing the signature of imported
+/// JS functions.
+/// </summary>
+/// <remarks>
+/// Pattern matching is possible, but should consider the implications of the Erased union and JS type testing (see the
+/// docs for details).
+/// <br/>
+/// Member concrete types will be implicitly cast into the union, and will provide a warning to this effect. Usage of
+/// the explicit cast operator <c>!^</c> available in <c>Fable.Core.JsInterop</c> will remove this warning.
+/// <a href="https://github.com/fable-compiler/Fable/pull/4143">Collection types, can provide an error</a> that will
+/// only be resolved with the explicit operator. <a href="https://github.com/glutinum-org/cli/issues/80">Anonymous
+/// records have other considerations that may be relevant if you are encountering issues.</a>
+/// <code lang="fsharp">
+/// let test(arg: U3&lt;string, int, float[]>) =
+///     match arg with
+///     | U3.Case1 x -> printfn "A string %s" x
+///     | U3.Case2 x -> printfn "An int %i" x
+///     | U3.Case3 xs -> Array.sum xs |> printfn "An array with sum %f"
+/// </code>
+/// </remarks>
+/// <seealso href="https://fable.io/docs/communicate/js-from-fable.html#erase-attribute"/>
 [<Erase>]
 type U6<'a, 'b, 'c, 'd, 'e, 'f> =
     | Case1 of 'a
@@ -194,9 +309,35 @@ type U6<'a, 'b, 'c, 'd, 'e, 'f> =
     static member op_ErasedCast(x: 'd) = Case4 x
     static member op_ErasedCast(x: 'e) = Case5 x
     static member op_ErasedCast(x: 'f) = Case6 x
-
-/// Erased union type to represent one of seven possible values.
-/// More info: https://fable.io/docs/communicate/js-from-fable.html#erase-attribute
+    static member inline op_Implicit(x: 'a) : U6<'a, 'b, 'c, 'd, 'e, 'f> = Case1 x
+    static member inline op_Implicit(x: 'b) : U6<'a, 'b, 'c, 'd, 'e, 'f> = Case2 x
+    static member inline op_Implicit(x: 'c) : U6<'a, 'b, 'c, 'd, 'e, 'f> = Case3 x
+    static member inline op_Implicit(x: 'd) : U6<'a, 'b, 'c, 'd, 'e, 'f> = Case4 x
+    static member inline op_Implicit(x: 'e) : U6<'a, 'b, 'c, 'd, 'e, 'f> = Case5 x
+    static member inline op_Implicit(x: 'f) : U6<'a, 'b, 'c, 'd, 'e, 'f> = Case6 x
+
+/// <summary>
+/// Erased union type to represent one of seven possible value types mainly intended for typing the signature of imported
+/// JS functions.
+/// </summary>
+/// <remarks>
+/// Pattern matching is possible, but should consider the implications of the Erased union and JS type testing (see the
+/// docs for details).
+/// <br/>
+/// Member concrete types will be implicitly cast into the union, and will provide a warning to this effect. Usage of
+/// the explicit cast operator <c>!^</c> available in <c>Fable.Core.JsInterop</c> will remove this warning.
+/// <a href="https://github.com/fable-compiler/Fable/pull/4143">Collection types, can provide an error</a> that will
+/// only be resolved with the explicit operator. <a href="https://github.com/glutinum-org/cli/issues/80">Anonymous
+/// records have other considerations that may be relevant if you are encountering issues.</a>
+/// <code lang="fsharp">
+/// let test(arg: U3&lt;string, int, float[]>) =
+///     match arg with
+///     | U3.Case1 x -> printfn "A string %s" x
+///     | U3.Case2 x -> printfn "An int %i" x
+///     | U3.Case3 xs -> Array.sum xs |> printfn "An array with sum %f"
+/// </code>
+/// </remarks>
+/// <seealso href="https://fable.io/docs/communicate/js-from-fable.html#erase-attribute"/>
 [<Erase>]
 type U7<'a, 'b, 'c, 'd, 'e, 'f, 'g> =
     | Case1 of 'a
@@ -214,9 +355,36 @@ type U7<'a, 'b, 'c, 'd, 'e, 'f, 'g> =
     static member op_ErasedCast(x: 'e) = Case5 x
     static member op_ErasedCast(x: 'f) = Case6 x
     static member op_ErasedCast(x: 'g) = Case7 x
-
-/// Erased union type to represent one of eight possible values.
-/// More info: https://fable.io/docs/communicate/js-from-fable.html#erase-attribute
+    static member inline op_Implicit(x: 'a) : U7<'a, 'b, 'c, 'd, 'e, 'f, 'g> = Case1 x
+    static member inline op_Implicit(x: 'b) : U7<'a, 'b, 'c, 'd, 'e, 'f, 'g> = Case2 x
+    static member inline op_Implicit(x: 'c) : U7<'a, 'b, 'c, 'd, 'e, 'f, 'g> = Case3 x
+    static member inline op_Implicit(x: 'd) : U7<'a, 'b, 'c, 'd, 'e, 'f, 'g> = Case4 x
+    static member inline op_Implicit(x: 'e) : U7<'a, 'b, 'c, 'd, 'e, 'f, 'g> = Case5 x
+    static member inline op_Implicit(x: 'f) : U7<'a, 'b, 'c, 'd, 'e, 'f, 'g> = Case6 x
+    static member inline op_Implicit(x: 'g) : U7<'a, 'b, 'c, 'd, 'e, 'f, 'g> = Case7 x
+
+/// <summary>
+/// Erased union type to represent one of eight possible value types mainly intended for typing the signature of imported
+/// JS functions.
+/// </summary>
+/// <remarks>
+/// Pattern matching is possible, but should consider the implications of the Erased union and JS type testing (see the
+/// docs for details).
+/// <br/>
+/// Member concrete types will be implicitly cast into the union, and will provide a warning to this effect. Usage of
+/// the explicit cast operator <c>!^</c> available in <c>Fable.Core.JsInterop</c> will remove this warning.
+/// <a href="https://github.com/fable-compiler/Fable/pull/4143">Collection types, can provide an error</a> that will
+/// only be resolved with the explicit operator. <a href="https://github.com/glutinum-org/cli/issues/80">Anonymous
+/// records have other considerations that may be relevant if you are encountering issues.</a>
+/// <code lang="fsharp">
+/// let test(arg: U3&lt;string, int, float[]>) =
+///     match arg with
+///     | U3.Case1 x -> printfn "A string %s" x
+///     | U3.Case2 x -> printfn "An int %i" x
+///     | U3.Case3 xs -> Array.sum xs |> printfn "An array with sum %f"
+/// </code>
+/// </remarks>
+/// <seealso href="https://fable.io/docs/communicate/js-from-fable.html#erase-attribute"/>
 [<Erase>]
 type U8<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h> =
     | Case1 of 'a
@@ -236,9 +404,37 @@ type U8<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h> =
     static member op_ErasedCast(x: 'f) = Case6 x
     static member op_ErasedCast(x: 'g) = Case7 x
     static member op_ErasedCast(x: 'h) = Case8 x
-
-/// Erased union type to represent one of nine or more possible values.
-/// More info: https://fable.io/docs/communicate/js-from-fable.html#erase-attribute
+    static member inline op_Implicit(x: 'a) : U8<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h> = Case1 x
+    static member inline op_Implicit(x: 'b) : U8<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h> = Case2 x
+    static member inline op_Implicit(x: 'c) : U8<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h> = Case3 x
+    static member inline op_Implicit(x: 'd) : U8<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h> = Case4 x
+    static member inline op_Implicit(x: 'e) : U8<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h> = Case5 x
+    static member inline op_Implicit(x: 'f) : U8<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h> = Case6 x
+    static member inline op_Implicit(x: 'g) : U8<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h> = Case7 x
+    static member inline op_Implicit(x: 'h) : U8<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h> = Case8 x
+
+/// <summary>
+/// Erased union type to represent one of nine possible value types mainly intended for typing the signature of imported
+/// JS functions.
+/// </summary>
+/// <remarks>
+/// Pattern matching is possible, but should consider the implications of the Erased union and JS type testing (see the
+/// docs for details).
+/// <br/>
+/// Member concrete types will be implicitly cast into the union, and will provide a warning to this effect. Usage of
+/// the explicit cast operator <c>!^</c> available in <c>Fable.Core.JsInterop</c> will remove this warning.
+/// <a href="https://github.com/fable-compiler/Fable/pull/4143">Collection types, can provide an error</a> that will
+/// only be resolved with the explicit operator. <a href="https://github.com/glutinum-org/cli/issues/80">Anonymous
+/// records have other considerations that may be relevant if you are encountering issues.</a>
+/// <code lang="fsharp">
+/// let test(arg: U3&lt;string, int, float[]>) =
+///     match arg with
+///     | U3.Case1 x -> printfn "A string %s" x
+///     | U3.Case2 x -> printfn "An int %i" x
+///     | U3.Case3 xs -> Array.sum xs |> printfn "An array with sum %f"
+/// </code>
+/// </remarks>
+/// <seealso href="https://fable.io/docs/communicate/js-from-fable.html#erase-attribute"/>
 [<Erase>]
 type U9<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i> =
     | Case1 of 'a
@@ -260,6 +456,15 @@ type U9<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i> =
     static member op_ErasedCast(x: 'g) = Case7 x
     static member op_ErasedCast(x: 'h) = Case8 x
     static member op_ErasedCast(x: 'i) = Case9 x
+    static member inline op_Implicit(x: 'a) : U9<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i> = Case1 x
+    static member inline op_Implicit(x: 'b) : U9<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i> = Case2 x
+    static member inline op_Implicit(x: 'c) : U9<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i> = Case3 x
+    static member inline op_Implicit(x: 'd) : U9<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i> = Case4 x
+    static member inline op_Implicit(x: 'e) : U9<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i> = Case5 x
+    static member inline op_Implicit(x: 'f) : U9<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i> = Case6 x
+    static member inline op_Implicit(x: 'g) : U9<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i> = Case7 x
+    static member inline op_Implicit(x: 'h) : U9<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i> = Case8 x
+    static member inline op_Implicit(x: 'i) : U9<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i> = Case9 x
 
     static member inline op_ErasedCast(x: 't) : U9<_, _, _, _, _, _, _, _, ^U> =
         Case9(^U: (static member op_ErasedCast: 't -> ^U) x)