Type Class / Witness

[Remi Forax]

Hello,
for those who where not at the JVMLS, it may make sense to re-read this email later,
when the talk of Brian on Type class / witness is visible on youtube.
I write this now because i'm sure i will totally forget about that in few days.

During the talk, Brian said that witness are restricted to be used only by value classes so we avoid the operator overloading hell that you can see in other languages.

I think this restriction can be bypassed.

The problem is that you can always wrap any class into a value class organized as a monad (containing a superposition of states) thus bypassing that restriction.


As an example, let say we want to abuse of the >> operator to emulate C++ iostream.
Let suppose we have this witness interface defined in the JDK (it is by example used by Integer)

witness interface BitwiseNumeric<V> {
  V rightShift(V v1, V v2);

  // other methods
}

And the witness interface for exact conversion also defined in the JDK

witness interface Conversion<U, V> {
  U convert(V value);
}


So the trick is to create a value class that encode either a Writer or any value you want to add to the writer as a monad,
The exact conversion is used to wrap any value into the IOStream, the righShift is used to consume the wrapped value using a side-effect.

value class IOStream {
 private final Writer writer;
 private final Object o;

 private IOStream(Writer writer, Object o) { this.writer = writer; this.o = o; super(); }

 public IOWriter(Writer! writer) { this(writer, null); }  

 public static final witness BitwiseNumeric<IOStream!> BITWISE_NUMERIC = new BitwiseNumeric<>() {
   public IOStream! rightShift(IOStream! v1, IOStream! v2) {
     if (v1.writer == null || v2.writer != null) {
       throw new ISE();
     }
     v1.writer.append("" + v2.o);
     return v1;
   }

   // other methods throw UnsupportedOperationException
 };

 public static final witness Conversion<IOStream!, Integer!> FROM_INTEGER = new Conversion<>() {
   IOStream! convert(Integer! value) {
     return new IOStream(null, value);
   }
 };
}

So one can write
  IOStream stream = new IOStream(writer);
  var _ = stream >> 2 >> 3;

I think this is a general mechanism so any operator can be abused that way.

regards,
Rémi