Hello, it may be a stupid question (if so please forgive me), but is there a reason that let-bindings cannot be overloaded, but they can be shadowed ?

In the following code the type inference is able to determine that 'anyrecord' is type "MostLocalRecord" because it fits the type checks and is the last defined type. It infers that 'somerecord' is type "LeastLocalRecord" because that is the only possibility. Couldn't the same hold true for let bindings; either the last defined ones work out, or some previous ones should be used instead.

type LeastLocalRecord = { name: string; }
let f {LeastLocalRecord.name=name} = {LeastLocalRecord.name=name}

type MostLocalRecord = { name: string; }
// This 'overload' to function f cannot be bound to the name 'f',
// the formal error text is "Duplicate definition of value 'f'"
//let f {MostLocalRecord.name=name} = {MostLocalRecord.name=name}

let anyrecord = { name = "Anybody" }
let somerecord = f {name= "Somebody"}

I agree that it might (in some cases) lead to type inference that is not always clear as day to the programmer, but often a strategic type annotation here and there would do the trick (just as we are used to), I would guess.

Best regards,
Robert

You cannot overload let-bound functions. You can only overload methods (class members).

Then, I hope there is a way to write this as one function - a function which can take either one of the types listed and internally somehow differentiates among them. For reference types I can use

1

match value with | :? string as s 

but what can I do for value types?