I wrote a couple of functions that look like this:

def myWrite(os: OutputStream) = {}
def myWrite(w: Writer) = {}

Now both are very similar and I thought I would try to write a single parametrized version of the function.

I started with a type with the two methods that are common in the Java OutputStream and Writer:

type Writable[T] = {
    def close() : Unit
    def write(cbuf: Array[T], off: Int, len: Int): Unit
}

One issue is that OutputStream writes Byte and Writer writes Char, so I parametrized the type with T.

Then I write my function:

def myWrite[T, A[T] <: Writable[T]](out: A[T]) = {}

and try to use it:

val w = new java.io.StringWriter()
myWrite(w)                        

Result:

<console>:9: error: type mismatch;
 found   : java.io.StringWriter
 required: ?A[ ?T ]
Note that implicit conversions are not applicable because they are ambiguous:
 both method any2ArrowAssoc in object Predef of type [A](x: A)ArrowAssoc[A]
 and method any2Ensuring in object Predef of type [A](x: A)Ensuring[A]
 are possible conversion functions from java.io.StringWriter to ?A[ ?T ]
       myWrite(w)

I tried a few other combinations of types and parameters, to no avail so far.

My question is whether there is a way of achieving this at all, and if so how.

(Note that the implementation of myWrite will need, internally, to know the type T that parametrizes the write() method, because it needs to create a buffer as in new ArrayT.)