Is there a language where types can take content of fields into account?

I had this crazy idea and was wondering if such a thing exists:

Usually, in a strongly typed language, types are mainly concerned with memory layout, or membership to an abstract 'class'. So class Foo {int a;} and class Bar {int a; int b;} are disti开发者_开发技巧nct, but so is class Baz {int a; int b;} (although it has the same layout, it's a different type). So far, so good.

I was wondering if there is a language that allows one to specify more fine grained contraints as to what makes a type. For example, I'd like to have:

class Person {
    //...
    int height;
}

class RollercoasterSafe: Person (where .height>140) {}

void ride(RollercoasterSafe p) { //... }

and the compiler would make sure that it's impossible to have p.height < 140 in ride. This is just a stupid example, but I'm sure there are use cases where this could really help. Is there such a thing?

It depends on whether the predicate is checked statically or dynamically. In either case the answer is yes, but the resulting systems look different.

On the static end: PL researchers have proposed the notion of a refinement type, which consists of a base type together with a predicate: http://en.wikipedia.org/wiki/Program_refinement. I believe the idea of refinement types is that the predicates are checked at compile time, which means that you have to restrict the language of predicates to something tractable.

It's also possible to express constraints using dependent types, which are types parameterized by run-time values (as opposed to polymorphic types, which are parameterized by other types).

There are other tricks that you can play with powerful type systems like Haskell's, but IIUC you would have to change height from int to something whose structure the type checker could reason about.

On the dynamic end: SQL has something called domains, as in CREATE DOMAIN: http://developer.postgresql.org/pgdocs/postgres/sql-createdomain.html (see the bottom of the page for a simple example), which again consist of a base type and a constraint. The domain's constraint is checked dynamically whenever a value of that domain is created. In general, you can solve the problem by creating a new abstract data type and performing the check whenever you create a new value of the abstract type. If your language allows you to define automatic coercions from and to your new type, then you can use them to essentially implement SQL-like domains; if not, you just live with plain old abstract data types instead.

Then there are contracts, which are not thought of as types per se but can be used in some of the same ways, such as constraining the arguments and results of functions/methods. Simple contracts include predicates (eg, "accepts a Person object with height > 140"), but contracts can also be higher-order (eg, "accepts a Person object whose makeSmallTalk() method never returns null"). Higher-order contracts cannot be checked immediately, so they generally involve creating some kind of proxy. Contract checking does not create a new type of value or tag existing values, so the dynamic check will be repeated every time the contract is performed. Consequently, programmers often put contracts along module boundaries to minimize redundant checks.

An example of a language with such capabilities is Spec#. From the tutorial documentation available on the project site:

Consider the method ISqrt in Fig. 1, which computes the integer square root of a given integer x. It is possible to implement the method only if x is non-negative, so

int ISqrt(int x) 
  requires 0 <= x; 
  ensures result*result <= x && x < (result+1)*(result+1); 
{ 
  int r = 0; 
  while ((r+1)*(r+1) <= x) 
    invariant r*r <= x; 
  { 
    r++; 
  } 
  return r; 
} 

In your case, you could probably do something like (note that I haven't tried this, I'm just reading docs):

void ride(Person p)
  requires p.height > 140;
{
  //...
}

There may be a way to roll up that requires clause into a type declaration such as RollercoasterSafe that you have suggested.

Your idea sounds somewhat like C++0x's concepts, though not identical. However, concepts have been removed from the C++0x standard.

I don't know any language that supports that kind of thing, but I don't find it really necessary.

I'm pretty convinced that simply applying validation in the setters of the properties may give you all the necessary restrictions.

In your RollercoasterSafe class example, you may throw an exception when the value of height property is set to a value less than 140. It's runtime checking, but polymorphism can make compile-time checking impossible.