I have an experimental and somewhat half-baked programming language where all types are anonymous; type names always refer to interfaces. It then does global type inference to decide whether the thing you're referring to is a primitive type or an object for the actual implementation.

What this means is that at the semantic level, the language doesn't distinguish between objects and scalars, so avoiding the horrible schizophrenia that languages like C++ and Java do --- you can subclass an integer just as easily as you can anything else. Performance is really good, too, mostly.

The downside is somewhat unpredictable behaviour due to invisible boxing and unboxing. e.g.:

    function complexExpression(x: int) {
      // do something expensive with x
    }

    complexExpression(4);
    complexExpression(numberlikeObject);

The type inference will see that complexExpression() is being called by both a scalar and an object, which means that x needs to be implemented as an object pointer, and the literal 4 needs to be boxed. This means the calculations inside complexExpression() will end up being a lot more expensive due to boxing and unboxing overhead.

I should readdress this at some point; it was a really nice thing to write code for.

http://cowlark.com/cowbel/example.html