#pragma once

namespace types {
  template <typename Self> struct Boolean {
    operator bool() const { return static_cast<Self const &>(*this).get(); }
  };

  template <typename Self> struct Incrementable {
    friend Self operator++(Self & self, int) {
      Self copy = self;
      self = Self(self.get() + 1);
      return copy;
    }
    friend Self & operator++(Self & self) {
      return self = Self(self.get() + 1);
    }
  };

  template <typename Self> struct Decrementable {
    friend Self operator--(Self & self, int) {
      Self copy = self;
      self = Self(self.get() - 1);
      return copy;
    }
    friend Self & operator--(Self & self) {
      return self = Self(self.get() - 1);
    }
  };

  template <typename Self> struct Addable {
    friend Self operator+(Self const & lhs, Self const & rhs) {
      return Self(lhs.get() + rhs.get());
    }
  };

  template <typename Self> struct Arithmetic : Addable<Self> {
    friend Self operator-(Self const & self) { return Self(-self.get()); }

    friend Self operator-(Self const & lhs, Self const & rhs) {
      return Self(lhs.get() - rhs.get());
    }
  };

  template <typename Self> struct Numeric : Arithmetic<Self> {
    friend Self operator*(Self const & lhs, Self const & rhs) {
      return Self(lhs.get() * rhs.get());
    }

    friend Self operator/(Self const & lhs, Self const & rhs) {
      return Self(lhs.get() / rhs.get());
    }
  };
}