What is the Scala type-programming analogy for the `this` keyword?

Question

I'm trying to work my way into understanding type-programming in Scala, and I've found that most of what one needs to know about type programming has an analogous counterpart in value programming as is reflected in the type-level programming wiki page. However, I've not found the analogy for the `this` key word or self-types. I suspect maybe it doesn't make sense to expect such a thing, but I thought I would ask. For instance, I can write the following to represent Booleans as values at run time: ``` 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 } ``` Here my `and` and `imp` are able to take advantage of the fact it doesn't matter if I am a false object or a true…

Accepted Answer

You can always define an abstract type on your boolean base type as follows:

```
trait MyBool extends BoolType{
  type This <: BoolType
}

trait TrueType extends BoolType{
  type This = TrueType
}
```

and you should be good to go with a reference to yourself. Then you can use DeMorgan's Laws to do the following

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

Then by a double negative you can get you `And` condition going:

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

What is the Scala type-programming analogy for the `this` keyword?

Solution

Problem

Related problems