How to "extend" built-in types

[simendsjo]

Not sure if this is a bug or intended behavior:

import std.traits;
struct S {
      int i;
      T opCast(T)() if(isFloatingPoint!T) {
          return cast(T)i;
      }
}

template myIsFloatingPoint(T) {
      enum myIsFloatingPoint =  isFloatingPoint!T
          || __traits(compiles, { cast(real)T.init; });
}

void main() {
      auto s = S(10);
      assert(cast(real)s == 10.0);
      // static assert( isFloatingPoint!S); // false
      static assert( myIsFloatingPoint!S);
      static assert( myIsFloatingPoint!float);
      static assert(!myIsFloatingPoint!int);
}


Think of a Fraction or RangedInt struct for instance:

import std.traits;

struct Ranged(T, T minValue, T maxValue)
      if(isNumeric!T)
{
      enum T max = maxValue;
      enum T min = minValue;
      T value = min;

      invariant() {
          assert(value >= min && value <= max);
      }

      T opCast()() {
          return value;
      }

      void opAssign(T value) {
          this.value = value;
      }

      bool opEquals(T value) {
          return this.value == value;
      }
}

void f(int v) {}

void g(T)(T v) if(isNumeric!T) {
}

void main() {
      Ranged!(int, 10, 20) v;
      assert(v == 10);
      v = 20;
      //v = 21; // assert as expected
      // f(v); // ok if we would use an alias this, but then the
Ranged isn't in effect anymore
      //g(v); // oops.. Ranged is not numeric

}

So.. What do I need to implement for a struct to be a valid
built-in type?
All valid properties (min, max etc) and operators for that type?