Inferring type parameters - scala

Question

I am integrating with some java api, that looks kinda like this (these are java classes, I'll just use scala syntax for brevity:
class AbstractFooBuilder[ActualType <: AbstractFooBuilder, WhatToBuild <: Foo] {
// ...
def withFoo(f: Foo): ActualType
def withBar(b: Bar): ActualType
// ...
def build: WhatToBuild
}
class FooBarBuilder extends AbstractFooBuilder[FooBarBuilder, FooBar]
class FooBazBuilder extends AbstractFooBuilder[FooBazBuilder, FooBaz]
// .. etc
There is a bunch of these, and I am trying to make the creation of these foos less repetitive with something like this:
def anyFoo[T <: Foo, B <: AbstractFooBuilder[B, T] : Manifest](foo: Foo, b: Bar) = manifest
.runtimeClass
.newInstance
.withFoo(foo)
.withBar(bar)
.build
The problem is, that now, to create FooBar, I have to write something like this:
val foobar = new anyFoo[FooBar, FooBarBuilder](foo, bar)
which is longer than I would like. Specifically, once FooBarBuilder type parameter is known, FooBaris the only possibility for the second param ... I wonder if there is some trick I am missing, that would make it possible to "infer" the other param, and only have to specify one.
Any ideas?

Answer 1

Unfortunately, the standard trick to split the type parameters doesn't work here because B depends on T.
But what about getting rid of Manifest and simplifying to
def anyFoo[T <: Foo](builder: AbstractFooBuilder[_, T])(foo: Foo, b: Bar) =
builder.withBar(b).withFoo(foo).build
? You call it as anyFoo(new FooBarBuilder)(foo, b), so T is inferred, solving your problem. And as a bonus, it's faster and there is no runtime error if your class happens not to have a default constructor.
If your method didn't always need to create the builder, you could use by-name parameter or () => AbstractFooBuilder[_, T].
EDIT: Given the comment, this could work:
def mkBuilder[B <: AbstractFooBuilder[B, _] : Manifest]: B = // the complex creation code
anyFoo(mkBuilder[FooBarBuilder])(foo, b) // infers FooBar
The question is whether you can implement mkBuilder without access to T, but if your original code doesn't need a Manifest[T], it should be possible.
Or even
implicit class AnyFoo[T, B <: AbstractFooBuilder[B, T]](builder: B) {
def apply(foo: Foo, b: Bar) = builder.withBar(b).withFoo(foo).build
}
mkBuilder[FooBarBuilder](foo, b)

Answer 2

If I'm reading code correctly. The code does not imply there is only one AbstractFooBuilder factory for this type and this is left to the caller to specify the factory to use.
If you can use implicit, you can do something like this
def anyFoo[T <: Foo](foo: Foo, b: Bar)(implicit factory: AbstractFooBuilder[T]): T = {
factory.
withBar(b).
withFoo(foo).
build
}