I have recently been to a short F# presentation at HiQ in Arboga. One of the things that got mentioned was type inference. Both Visual Basic and C# have type inference in their current version, but F# takes this one step further. This approach will produce two integers in VB when Option Infer is set to On:
Dim X = 10 Dim Y = 20
This is the F# version of the above code:
let mutable x=10 let mutable y=20
But when it comes to function declarations, VB is not support type inference anymore. This will not compile:
Private Function DoSomething(ByVal X, ByVal Y) Return X End Function
You will need to declare the input types and the return type, like so:
Private Function DoSomething(ByVal X As Integer, ByVal Y As _ Integer) As Integer Return X End Function
In F#, type inference will work all the way. This is the F# version of the DoSomething function, with type inference:
let DoSomething x y = x
The DoSomething function can be called using any arguments. Type inference will take care of the argument and return typing. Once the function is called, the compiler knows what types the function will handle. Therefore, you can call the function using strings or integers but not a combination. Here, z1 will be a string and z2 will be an integer. This is the complete code listing:
let mutable x=10 let mutable y=20 let DoSomething x y = x let z1 = DoSomething "winsoft" "rocks" let z2 = DoSomething 10 20
Now, this is strange: If the types interact with each other, the first call will determine the types of the input and output. If I change my code, so that the function DoSomething returns x + y, only the first call will be accepted.
let mutable x=10 let mutable y=20 let DoSomething x y = x + y let z1 = DoSomething "winsoft" "rocks" //let z2 = DoSomething 10 20
The second call will fail, because the compiler in this case only provides a string version of the DoSomething function.