Welcome to the Lounge

class AgeInYears : int
    {
    public static implicit operator AgeInYears(int i)
        {
        return (AgeInYears)i;
        }
    public static implicit operator int(AgeInYears a)
        {
        return (int)a;
        }
    }

OriginalGriff wrote:

Annoyingly, int is a sealed type in C#, or all you would have to do is provide the implicit cast operators:

OriginalGriff wrote:

And don't forget that an Age is not a constant value: it will vary as the application runs...

OriginalGriff wrote:

But...what is an age plus an age?

class AgeInYears
{
  public AgeInYears(DateTime birthdate)
  {
    _Birthdate = birthdate;
  }
  private DateTime _Birthdate;
  public int Years
  {
    get
    {
       return (DataTime.Now - _Birthdate).Days / 365; // yes, I know 365 isn't right; it's just an example, for gosh sakes
    }
  }
}

Gary Wheeler wrote:

The Ada programming language provided a semblance of semantic typing.

Rob Grainger wrote:

"If you don't fail at least 90 percent of the time, you're not aiming high enough."

greydmar wrote:

I believe that this threshold "semantic" is outside the domain of a programming language (commonly, it is a "system domain" concept),

Member 7989122 wrote:

CHILL (CCITT HIgh Level Language - CCITT was the old name of ITU-T)

newtype meter m = meter m deriving (Show, Num, Eq, Ord)
newtype foot f = foot f deriving (Show, Num, Eq, Ord)

-- Usage (ghci> is an iteractive prompt)
ghci> let m1 = meter 5
ghci> let m2 = meter 10
ghci> let m3 = m1 + m2
ghci> m3
meter 15
ghci> let f1 = foot 3
ghci> let f2 = foot 4
ghci> let f3 = f1 + f2
ghci> f3
foot 7
ghci> let e1 = f1 + m1      -- Won't Work - produces error of types mismatching

Rob Grainger wrote:

Don't know if your familiar with Haskell at all, but its a wonderful thing.

Rob Grainger wrote:

I think I've learned more from learning Haskell than any language since I learned Smalltalk.

Rob Grainger wrote:

Alan Kay has stated that biology heavily influenced the invention of OOP

class AgeInYears(int):
    unit = "years"
    def __new__(cls, age:int):
        cls.age = age
        return int.__new__(cls,age)

    def __str__(self):
        return "{} {}".format(self.age, self.unit)
    def __add__(self, value:int):
        self.age += value
        return self


class User():
    def __init__(self, age:int):
        self.age = AgeInYears(age)

    def __str__(self):
        return "User: age: {}".format(self.age)

user = User(29)
print(user) #User: age: 29 years
print(user.age) #29 years
print(type(user.age)) #<class '__main__.AgeInYears'>

user.age += 2 #use it like an int, and just increase it.
print(user.age) #31 years
print(type(user.age)) #<class '__main__.AgeInYears'>