In F# 6 fsi, a `float -> float` function dynamically casts `int` input to `float`

[nhirschey]

Repro steps
This could be known but I could not find this in open or closed recent issues. A float function acts like F# does not have static types when operating on integers.

Using dotnet 6.0.101 or 6.0.100

let f x = x + 1.0
let g (x: float) = x ** 2.0

f 1 // evaluates to 2.0
g 2 //  evaluates to 4.0
f 1m // type error expected float but got decimal

// even with assigned values
let z: int = 3 // val z: int = 3
g z              // evaluates to val it: float = 9.0

Expected behavior

Type error as you get in F# 5.0

Actual behavior

Dynamic instead of static types.

Related information

Provide any related information (optional):

• Windows 11
• dotnet 6.0.1XX
• Editing environment: Seen in fsi command line tool and dotnet interactive notebooks.

[vzarytovskii]

It's a new F# 6 feature for type directed conversions.

Here's an RFC for it: https://github.com/fsharp/fslang-design/blob/main/FSharp-6.0/FS-1093-additional-conversions.md

It's still statically typed and safe, no "casts" involved, instead, it will perfom conversion where it's safe (or where op_Implicit is defined).

[nhirschey]

Thank you for kindly pointing me to the RFC. I now also see that the F# 6.0 announcement very clearly discusses implicit integer conversions. Apologies for missing those.

I get nervous when numeric types start converting because I have code that expects an integer to be an integer. But reading the RFC and experimenting, it's clear a lot of care was put into choosing which conversions were implemented in order to avoid bugs.

The type system will be a bit harder to explain to beginners (e.g., 3=3.0 vs 3.0=3), but the change seems to be a net benefit. Thanks again for the explanation.