Ein methoden-lokales Typ-Alias

Question

In dem folgenden Code sehen Sie einige abschreckende wiederholte Typisierungen:

implicit def intEqualInstance
  [ root,
    path <: TypePath[root] ]
  ( implicit mappingResolver: rel.rules.MappingResolver[path] )
  = {
    new genExp.Compiler
      [ genExp.templates.Where.Comparison[root, path, genExp.templates.Operator.Equal, typeLevel.Bool],
        genExp.values.Where.Comparison[ genExp.values.Expression.Value[ Int ] ],
        relExp.templates.Where,
        List[rel.Value] ]
      {
        override def compileTemplate(tpl: genExp.templates.Where.Comparison[root, path, genExp.templates.Operator.Equal, typeLevel.Bool]) = {
          ...
        }
        override def processValues(vals: genExp.values.Where.Comparison[ genExp.values.Expression.Value[ Int ] ]) = {
          ...
        }
      }
  }

Ich möchte Typaliase für die wiederholten Typen deklarieren.

I've tried adding subtype constraints as in the following, but it makes the implicit resolution fail:

implicit def intEqualInstance
  [ ...,
    inputTemplate <: genExp.templates.Where.Comparison[root, path, genExp.templates.Operator.Equal, typeLevel.Bool],
    inputValues <: genExp.values.Where.Comparison[ genExp.values.Expression.Value[ Int ] ] ]
  ( implicit mappingResolver: rel.rules.MappingResolver[path] )
  = {
    new genExp.Compiler
      [ inputTemplate, 
        inputValues, 
        ... ]
      {
        override def compileTemplate(tpl: inputTemplate) = ...
        override def processValues(vals: inputValues) = ...
      }
      ...

Das Hinzufügen lokaler Typaliase lässt die implizite Auflösung ebenfalls scheitern:

implicit def intEqualInstance
  ...
  = {
    type InputTemplate = genExp.templates.Where.Comparison[root, path, genExp.templates.Operator.Equal, typeLevel.Bool]
    type InputValues = genExp.values.Where.Comparison[ genExp.values.Expression.Value[ Int ] ]
    new genExp.Compiler
      [ InputTemplate
        InputValues,
        ... ]
      ...

Gibt es eine Lösung für dieses Problem?

Answer 1

Das Beste, was mir einfallen konnte, war, Typaliase im äußeren Bereich zu deklarieren:

private type InputTemplate[root, path <: TypePath[root]] = 
  genExp.templates.Where.Comparison[root, path, genExp.templates.Operator.Equal, typeLevel.Bool]
private type InputValues = 
  genExp.values.Where.Comparison[ genExp.values.Expression.Value[ Int ] ]

implicit def intEqualInstance
  [ root, path <: TypePath[root] ]
  ( implicit mappingResolver: rel.rules.MappingResolver[path] )
  =
  new genExp.Compiler
    [ InputTemplate[root, path], InputValues, ... ]
    {
      override def compileTemplate(tpl: InputTemplate[root, path]) = ...
      override def processValues(vals: InputValues) = ...
    }