Lambda умозаключение типа и неявное преобразование

Question

я определил следующий класс:

class TransparentFunction1[-T1, +R1](val func : T1 => R1, val text : String) { 
    @inline 
    def apply(t : T1) = func(t) 

    override def toString = text 
} 

В принципе, TransparentFunction1 просто обертка Function1, которая обеспечивает текстовое поле удобочитаемого, описывающее то, что функция.

Я хотел бы определить неявное преобразование, которое может преобразовать любой Function1 в TransparentFunction1, передавая код функции в текстовый параметр.

Я определил такое неявное преобразование с помощью макроса:

implicit def transparentFunction1[T1, R1](expression : T1 => R1) : TransparentFunction1[T1, R1] = macro Macros.transparentImpl[T1, R1, TransparentFunction1[T1, R1]] 

object Macros { 
    def transparentImpl[T : context.WeakTypeTag, U : context.WeakTypeTag, V : context.WeakTypeTag](context : scala.reflect.macros.whitebox.Context) (expression : context.Expr[T => U]) : context.Expr[V] = { 
     import context.universe._ 
     context.Expr[V](
     Apply(
      Select(
      New(
       TypeTree(
       appliedType(weakTypeOf[V].typeConstructor, weakTypeOf[T] :: weakTypeOf[U] :: Nil) 
      ) 
      ), 
      termNames.CONSTRUCTOR 
     ), 
      List(expression.tree, Literal(Constant(expression.tree.toString))) 
     ) 
    ) 
    } 
} 

Это работает. Однако это вызывает проблему вывода типа.

Например, если я пытаюсь вызвать метод, названный «карта», которая принимает аргумент типа TransparentFunction1[Int, Int] так:

map(_ + 2) 

я получаю ошибку «отсутствует параметр типа для расширенной функции», а если Тип параметра карты был только Int => Int, вывод типа работает правильно.

Есть ли способ исправить макрос, чтобы тип вывода продолжал работать?

Answer 1

Чтобы это исправить, нужно только иметь TransparentFunction1 расширить Function1 (который, кажется естественным в любом случае, учитывая, что TransparentFunction1 концептуально очень много Function1, это только добавляет пользовательские toString но должен иначе действовать как обычный Funciton):

class TransparentFunction1[-T1, +R1](val func : T1 => R1, val text : String) extends (T1 => R1){ 
    @inline 
    def apply(t : T1) = func(t) 

    override def toString = text 
} 

Есть только несколько причин, по которым я могу видеть, для определения функционально-подобного класса, который делает не extend Function1. С моей точки зрения основной причиной является то, что ваш класс предназначен для использования в качестве неявных значений (например, типа), и вы не хотите, чтобы компилятор автоматически использовал эти неявные значения как неявные преобразования (которые он будет если он распространяет Function1). Кажется, это не так, потому что TransparentFunction1 простирается Function1 кажется правильным.

Answer 2

Я не думаю, что есть способ сделать это. Я попытался сделать то же самое для js.FunctionN в Scala.js (например, неявно преобразовать T1 => R в js.Function1[T1, R]), и я никогда не смог бы сделать операцию вывода типа для параметров лямбда. К сожалению, это кажется невозможным.