Conceptional language + type system

k-types.txt

// data types
type[T] Point {
    data x : T
    data y : T
}

type IntPoint = Point[Integer]

// complex concepts
type[T <= Differable] DifferenceOf {
    to +(b : T) : T
}
type Differable {
    to -(b : T) : DifferenceOf[T]
    to +(b : DifferenceOf[T]) : T
}

type Time { implements Diffeerable }
type TimeSpan = DifferenceOf[Time]

// conversion concept
type[Q] CanConvertTo {
    to convert : Q
}
type[Q] CanLosslesslyConvertTo {
    to losslesslyConvert : Q
    implements CanConvertTo[Q] {
        to convert = (this as CanLosslesslyConvertTo[Q]) :: losslesslyConvert
    }
}

type Integer {
    implements CanLosslesslyConvertTo[String] {
        to losslesslyConvert = LIBRARY_CONVERT_INT_TO_STRING(this)
    }
}

function[P <= CanConvertTo[Q], Q] convert(x : P) : Q {
    return x.convert
    // longhand: return (x as CanConvertTo[Q]).convert
}