Scala неявные преобразования между функциональными объектами?

Question

Я пытаюсь повторно привязать некоторые функции в scala.math для получения и возврата Float объектов, а не Double объектов, чтобы я мог связать их с регистратором функций, который работает с функциями, которые принимают и возвращают Float объекты. Я пробовал это правило:

implicit def doubleFunc2floatFunc[T <: { def apply(x:Double):Double }] (func:T) = func(_:Float).floatValue

и это не работает. Компилятор жалуется, что мои функции (Double)=>Float, а не (Float)=>Float. Кто-нибудь может указать мне правильное направление?

РЕДАКТИРОВАТЬ : код, который я использую, выглядит следующим образом:

package org.nathanmoos.magnificalc.exprtreelib.functions

import org.nathanmoos.magnificalc.exprtreelib.Functions
import scala.math._


object InternalFunctions
{
    implicit def float2double(x:Float) = x.doubleValue
    // need an implicit def doubleFunc2floatFunc
    implicit def double2float(x:Double) = x.floatValue
    def csc(x:Float):Float = 1f/sin(x)
    def sec(x:Float):Float = 1f/cos(x)
    def cot(x:Float):Float = 1f/tan(x)

    def registerAll() = {
        Functions.register("ln", log _)
        Functions.register("log", log10 _)
        Functions.register("sqrt", sqrt _)
        Functions.register("sin", sin _)
        Functions.register("cos", cos _)
        Functions.register("tan", tan _)
        Functions.register("csc", csc _)
        Functions.register("sec", sec _)
        Functions.register("cot", cot _)
        Functions.register("sinh", sinh _)
        Functions.register("cosh", cosh _)
        Functions.register("tanh", tanh _)
        Functions.register("acos", acos _)
        Functions.register("asin", asin _)
        Functions.register("atan", atan _)
    }
}

Functions.register принимает String для имени функции и объекта-функции, с которым она ассоциируется.

Answer 1

Я не знаю, что именно происходит, но сначала проверяет тип возвращаемого значения функции, а затем завершается ошибкой, если не может это решить.Но если вы do даете ему возможность исправить тип возвращаемого значения, тогда он приступает к проверке всей функции.

Таким образом, вы можете сделать это, создав две импликации:

implicit def doubleToFloat(d: Double): Float = d.toFloat
implicit def doubleFunc2floatFunc(df : Double => Float) : Float => Float = (f : Float) => df(f)

Answer 2

Я думаю, что основной проблемой (после того, как мы удалим импликации, которые уже находятся в предопределенных, ненужных структурных типах, а затем ограничимся математическими функциями, которые не перегружены), является странное взаимодействие вывода типа между слабой согласованностью и расширением eta.Тип параметра Float соответствует ожидаемому типу параметра Double, поэтому неявное преобразование для типа функции не срабатывает;он включается для типа результата, который слишком поздно.Уже определено, что тип параметра Double.

scala> implicit def dd2ff(x: Double => Double): Float => Float = x => x
dd2ff: (x: (Double) => Double)(Float) => Float

scala> def dd(x: Double) = x
dd: (x: Double)Double

scala> val ff: Float => Float = (dd _)
<console>:9: error: type mismatch;
 found   : Double
 required: Float
       val ff: Float => Float = (dd _)
                                 ^

scala> val x = dd _
x: (Double) => Double = <function1>

scala> val ff: Float => Float = x
ff: (Float) => Float = <function1>

Answer 3

Здесь нет необходимости для структурных типов или параметров типа,

scala> implicit def doubleFunc2floatFunc(df : Double => Double) : Float => Float = (f : Float) => df(f).toFloat
doubleFunc2floatFunc: (df: (Double) => Double)(Float) => Float

Затем используется,

scala> val f : Float => Float = scala.math.abs
f: (Float) => Float = <function1>

scala> f(-1.0)
<console>:8: error: type mismatch;
 found   : Double(-1.0)
 required: Float
   f(-1.0)
     ^

scala> f(-1.0f)
res1: Float = 1.0