Phantom Types in Rust

Yes, it's unfortunate that I lost a bunch of articles in a drive corruption on linode: http://bluishcoder.co.nz/2013/04/03/parts-of-this-site-tempo...

I've been going through archive.org recovering posts when I can. I do have a bunch of the factor articles in my project that produces a PDF from them: https://github.com/doublec/factor-articles

No, the compiler doesn't infer the types quite like you're imagining. It is possible, depending on usage, to have TI(1) of type T<~str>, or TS(~"Hello") of type T<int>. The following is actually still legal in the first example, and will result in a runtime error:

    let a = TI(1);
    let b = TS(~"foo");
    let z = concat(a, b);

The reason is that the Rust compiler is trying to work out the types for you. In this case, it sees that concat requires two T<~str>s and infers logically that both a and b must have the type T<~str>... even though one of them was created with TI.

If you look at the example with a compile error, you'll notice that the two things being concatenated which result in the error were themselves the results of calls to `plus` and `concatenate`, which are guaranteed to produce T<int> and T<~string>. You could also guide the compiler by providing the types manually

    let a : T<int>  = TI(1);
    let b : T<~str> = TS(~"foo");
    /* now this produces a compile-time error */
    let z = concat(a, b);

Or by writing wrapper functions over the constructors

    fn makeTI(i : int) -> T<int> { TI(i) }
    fn makeTS(s : ~str) -> T<~str> { TS(s) }
    ...
    let a = makeTI(1);
    let b = makeTS(~"foo");
    /* this also now produces a compile-time error */
    let z = concat(a, b);

Other languages with phantom types use something called Generalized Algebraic Data types (GADTs) which—to handwave a bit—are something like the latter solution, except built directly into the data type constructors (rather than manually writing those extra functions).

I've updated the article to try to make it clearer about what types are inferred and how to make it infer the correct types.

I'm not really sure of Rust's semantics, but this sort of thing is achieved using GADTs in Haskell. They look like this

    data T a where
      TI :: Int    -> T Int
      TS :: String -> T String

which lets you reflect a value up into its type. Something similar but more implicit seems to be going on with that Rust example.

Another method is kind of a hack: unify the type variable with an unused argument. This looks like

    data T a b = T b              -- we want to find a way to choose a

    setA :: a -> T a b -> T a b
    setA _ t = t                  -- Just returns the second argument
                                  -- BUT tells the compiler the `a` type unifies
                                  -- with the type of the first argument

    > :t setA Int (T "foo")
    setA Int (T "foo") :: T Int String

See andolanra's answer below: https://news.ycombinator.com/item?id=6219283

What he said. The entire post seems to just quitely ignore the question of how let works in the first place.

The Rust Enum is a more generalized data structure, which aside from being able to provide your usual Enum functionalities, can also contain members with type parameters.

The cool thing is that all this functionality is accessible through the match() syntax, which exhaustively checks all possible forms the Enum can take, thus making data access completely safe.

We had a long debate about this. Eventually it was decided that "union" would give C programmers the impression that it was about unsafe unions, not tagged unions. Also, the idea of associating data with enums has precedent in Java.

It's rather infuriating. An Enum is supposed to be just a Union of nullary constructors. What they're doing here is using the word Enum when they really ought to mean Union.

This sort of overloading of language happens all over the place in programming and it leads to endless confusion. I find it extremely frustrating but what can I do about it?

I think it's for familiarity for C++ programmers:

    enum Day {
      Monday, Tuesday, Wednesday, ...
    }

You can assign values too:

    enum Color { 
      Red = 0xff0000,
      Green = 0x00ff00,
      Blue = 0x0000ff
    }