Re: How to "exclude" certain type from local type inference (was: How to make implicit conversion pick the right type)

After thinking this over for a few times I realized that IntegerType
with Bindable _is_ minimal, since, well, IntegerType with Bindable <:
IntegerType, so Scala behaves as designed.

For the moment I came up with the following working code:

trait Type
trait BooleanType
extends Type
trait IntegerType
extends Type
trait StringType
extends Type
trait Bindable
extends Type

trait PrimaryType
extends AnyRef
with BooleanType
with IntegerType
with StringType

trait Expression[+T <: Type]
class IntegerConstant(val value: BigInt)
extends Expression[IntegerType]
class Variable[T <: Type]
extends Expression[T with Bindable]

class BindLhs[T <: Type]
(val lhs: Expression[T with Bindable]) {
def #=(rhs: Expression[T]) =
throw new UnsupportedOperationException
}

object Main {
def _int = new Variable[IntegerType]
implicit def toIntegerConstant(value: Int) =
new IntegerConstant(BigInt(value))
implicit def toBindLhs[T >: PrimaryType <: Type]
(lhs: Expression[T with Bindable]) =
new BindLhs[T](lhs)

def dsl = {
val v = _int
toBindLhs(v) #= 1
}
}

Here I introduced PrimaryType trait that serves the purpose of
"excluding" Bindable from local type inference. However, this is not a
very good solution, since client libraries (that define specialized
versions of DSL) should be able to introduce their own types.

What I would like to see is something along the lines of T >: (Any - Bindable).

Any ideas are very much appreciated.

On 10/20/11, Ilya Leoshkevich wrote:
> This still fails to compile with the same error.
> I think the problem here is not that toBindLhs[T] and
> toIntegerConstant have wrong priorities, but rather that
> T is inferred in a way that does not fit my use case.
>
> I have found this in the language spec:
>
> 6.26.4 Local Type Inference
> ...
> If several substitutions exist,
> local-type inference will choose for each type variable ai a minimal
> or maximal type
> Ti of the solution space. A maximal type Ti will be chosen if the type
> parameter ai
> appears contravariantly (§4.5) in the type T of the expression. A
> minimal type Ti
> will be chosen in all other situations
>
> In my case type parameter is invariant, so I would assume it should
> pick minimal one
> (i.e. just IntegerType, as opposed to IntegerType with Bindable).
>
> On Thu, Oct 20, 2011 at 4:35 PM, Josh Suereth
> wrote:
>> You can alter the *priority* of implicits by placing them in an
>> inheritance
>> relationship. The lower in the chain, the more likely to be pulled.
>> This
>> is why the standard library has a bunch of LowPriority* traits.
>> trait LowPriority {
>> implicit def toBindLhs[T <: Type](lhs: Expression[T with Bindable]) =
>> new
>> BindLhs[T](lhs)
>> }
>> object Main extends LowPriority {
>> def _int = new Variable[IntegerType]
>> implicit def toIntegerConstant(value: Int) =
>> new IntegerConstant(BigInt(value))
>> def dsl = {
>> val v = _int
>> v #= 1
>> }
>> }
>>
>> On Thu, Oct 20, 2011 at 7:00 AM, Ilya Leoshkevich
>> wrote:
>>>
>>> Consider a code fragment below:
>>>
>>> trait Type
>>> trait IntegerType extends Type
>>> trait Bindable extends Type
>>>
>>> trait Expression[+T <: Type]
>>> class IntegerConstant(val value: BigInt) extends
>>> Expression[IntegerType]
>>> class Variable[T <: Type] extends Expression[T with Bindable]
>>>
>>> class BindLhs[T <: Type](val lhs: Expression[T with Bindable]) {
>>> def #=(rhs: Expression[T]) = throw new UnsupportedOperationException
>>> }
>>>
>>> object Main {
>>> def _int = new Variable[IntegerType]
>>> implicit def toIntegerConstant(value: Int) = new
>>> IntegerConstant(BigInt(value))
>>> implicit def toBindLhs[T <: Type](lhs: Expression[T with Bindable])
>>> = new BindLhs[T](lhs)
>>>
>>> def dsl = {
>>> val v = _int
>>> v #= 1
>>> }
>>> }
>>>
>>> This is an attempt to define DSL that operates on typed expressions.
>>> Method "dsl" is a simple program in this DSL that is supposed to
>>> assign number 1 to variable "v" (actual implementation of assignment
>>> operation is omitted, since only typing is relevant to my question).
>>> The fragment fails to compile with the following error:
>>>
>>> Main.scala:20: error: type mismatch;
>>> found : Int(1)
>>> required: Expression[IntegerType with Bindable]
>>> v #= 1
>>>
>>> Scala has correctly determined that I would like to apply toBindLhs[T]
>>> to v, however, instead of just T=IntegerType it must have picked
>>> T=IntegerType with Bindable, which is an overkill.
>>>
>>> My question is: is it possible to make this code work (possibly by
>>> employing some trick to alter process of picking T in my favor)?
>>
>