Back to Questions
867
views2
comments
Stricter typedefs needed
f#

It seems that

1

type x = (*...*)

Merely defines a type synonym. In other words, effectively a simple text substitution which is mainly good for readability. So, for example, the following is legal:

1
2
3
4
5

type Int1 = int
type Int2 = int

let (x:Int1) = 5
let (y:Int2) = x

This is fine for a lot of cases, but in some cases it's fairly annoying, and in other cases it's really just not what you want at all. One case where it's annoying is where you've created a type synonym for something that is fairly long and convoluted, then at some point you take an instance of that type and pass it into a function, causing the type inference system to infer than the function has the associated type. However, instead of inferring that it has the synonym'ed type, it infers the more complicated type (for example, when you hover over the argument with the mouse to see what type was inferred). This is, of course, expected behavior as you could have had an arbitrary number of different synonyms that boil down to exactly the same thing, and it has no way to know which one you intended.

What I really want is a way to make the aforementioned code fragment not compile at all, with a message saying that you can't assign a variable of type Int1 to a variable of type Int2 because they are not the same type.

If it is a limitation of the .NET Framework and IL, then I wonder if we can propose to get those changed as well :D

.

You can do

type X = X of int

e.g. a single-case DU, and get many of the benefits. However it comes at the cost of an extra allocation/indirection. We will consider adding an attribute so that you can decorate this to say "just erase 'X', make it a compile-time typechecking thing only, with no runtime representation", but this is unlikely to make the cut for the first supported release of F# in VS2010.

Another possibility people sometimes use in .Net is to wrap a struct around your data - a struct with a single member can have zero run-time overhead and add the type safety you want. I never do this because I hate structs. I do use the 'single case DU' idiom a bit, but beware the runtime cost.

By on 3/19/2009 11:30 AM ()

You could use a union:

> type Int1 = Int1 of int
- type Int2 = Int2 of int
- ;;

type Int1 = | Int1 of int
type Int2 = | Int2 of int

> let x = Int1 5;;
val x : Int1

> let y = Int2 5;;
val y : Int2

> let foo (x : Int1) = printfn "%A" x;;
val foo : Int1 -> unit

> foo x;;
Int1 5
val it : unit = ()

> foo y;;
foo y;;
----^^
stdin(30,5): error FS0001: This expression has type
Int2
but is here used with type
Int1.

By on 3/19/2009 11:27 AM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper