Что такое Scala аналогия типа программирования для ключевого слова this this?

Я пытаюсь понять способ программирования типов в Scala, и я обнаружил, что большая часть того, что нужно знать о программировании типов, имеет аналогичный аналог в программировании значений, как это отражено в страница викинга на уровне программирования. Тем не менее, я не нашел аналогию с ключевым словом this или само-типами. Я подозреваю, может быть, нет смысла ожидать такого, но я думал, что попрошу.

Например, я могу написать следующее для представления Booleans как значений во время выполнения:

sealed trait BoolVal {
  def not:BoolVal
  def or(that:BoolVal):BoolVal
  def and(that:BoolVal) =
    (this.not or that.not).not
  def imp(that:BoolVal) =
    this.not or that
}
case object TrueVal extends BoolVal {
  override val not = FalseVal
  override def or(that:BoolVal) = TrueVal
}
case object FalseVal extends BoolVal {
  override val not = TrueVal
  override def or(that:BoolVal) = that
}

Здесь мои and и imp могут воспользоваться тем фактом, что не имеет значения, правильно ли я определяю ложный объект или истинный объект. Мои объекты TrueVal и FalseVal могут наследовать один и тот же код.

Я могу сделать аналогичные конструкторы программирования на уровне типа, но я не понимаю, как определить and и imp в моей базовой характеристике.

sealed trait BoolType {
  type Not <: BoolType
  type Or[That <: BoolType] <: BoolType
  type And[That <: BoolType] = ???
  type Imp[That <: BoolType] = ???
}
sealed trait TrueType extends BoolType {
  override type Not = FalseType
  override type Or[That <: BoolType] = TrueType
}
sealed trait FalseType extends BoolType {
  override type Not = TrueType
  override type Or[That <: BoolType] = That
}

Я вижу, где, возможно, не имеет смысла, что мои типы наследуют типы, но, конечно, наследуют абстрактные типы. Есть ли способ определить and и Impl в моем BoolType, или мне нужно определить каждый из соответствующих признаков TrueType и FalseType?

Ответ 1

Вы всегда можете определить абстрактный тип для вашего базового типа следующим образом:

trait MyBool extends BoolType{
  type This <: BoolType
}

trait TrueType extends BoolType{
  type This = TrueType
}

и вам должно быть хорошо идти со ссылкой на себя. Затем вы можете использовать законы DeMorgan для выполнения следующих

 !(x && y) == (!x || !y)

Затем двойным отрицательным вы можете получить условие And:

 !(!x || !y) == !!(x && y) == (x && y)

Ответ 2

Я бы предложил использовать self, пример вашего сообщения в блоге настроен:

sealed trait BoolType { self =>
  type Not <: BoolType
  type Or[That <: BoolType] <: BoolType
  type And[That <: BoolType] = self.type#Not#Or[That#Not]#Not
  type Imp[That <: BoolType] = self.type#Not#Or[That]
}
sealed trait TrueType extends BoolType {
  override type Not = FalseType
  override type Or[That <: BoolType] = TrueType
}
sealed trait FalseType extends BoolType {
  override type Not = TrueType
  override type Or[That <: BoolType] = That
}

Ответ 3

Почему бы просто не использовать ключевое слово this? Когда я самостоятельно изучал программирование уровня, я не мог видеть разницу при использовании этого вместо себя.

sealed trait BoolType {
  type Not <: BoolType 
  type Or[That <: BoolType] <: BoolType
  type And[That <: BoolType] = this.type#Not#Or[That#Not]#Not
  type Imp[That <: BoolType] = this.type#Not#Or[That]
}