Scala运算符#>;导致编译错误,但不是&>;-为什么?

Scala运算符#>;导致编译错误,但不是&>;-为什么?,scala,compiler-errors,operators,type-inference,type-parameter,Scala,Compiler Errors,Operators,Type Inference,Type Parameter,我有一个类型推断问题,请求帮助。 最初的问题是由于过载。一旦纠正,我 仍然有问题 下面是代码: class DPipe[ A ]( a: A ) { def !>[ B ]( f: A => B ) = Try(f( a )) def #>[ B, C ]( f: B => C )(implicit ev: A =:= Try[B]) : Try[C] = a.map(f) //def &>[ B, C ]( f: B => C )( im

我有一个类型推断问题,请求帮助。 最初的问题是由于过载。一旦纠正,我 仍然有问题

下面是代码:

class DPipe[ A ]( a: A ) {
  def !>[ B ]( f: A => B ) = Try(f( a ))
  def #>[ B, C ]( f: B => C )(implicit ev: A =:= Try[B]) : Try[C] = a.map(f)
  //def &>[ B, C ]( f: B => C )( implicit ev: A =:= Try[ B ] ) =  a.map( f )
}

object DPipe {
  def apply[ A ]( v: A ) = new DPipe( v )
}

object DPipeOps {
  implicit def toDPipe[ A ]( a: A ): DPipe[ A ] = DPipe( a )
}
以下是测试:

object DPipeDebug {

 def main( args: Array[ String ] ) {

    import DPipeOps._

    val r8 = 100.0 !> {x : Double => x / 0.0}  
    println(r8)
    val r9 = r8 #> {x:Double => x* 3.0} 
    println(r9)
    /*
    val r8 = 100.0 !> { x: Double => x / 0.0 }
    println( r8.get )
    val r9 = r8 &> { x: Double => x * 3.0 }
    println( r9 )*/

    val r10 = (100.0 !> {x : Double => x / 0.0}) #> {x:Double => x* 3.0} 
   //val r10 = ( 100.0 !> { x: Double => x / 0.0 } ) &> { x: Double => x * 3.0 }

    val r11 = 100.0 !> {x : Double => x / 0.0} #> {x:Double => x* 3.0} 
    //val r11 = 100.0 !> { x: Double => x / 0.0 } &> { x: Double => x * 3.0     }
  }

}
目前,我们在最后一行代码中有以下错误:

Cannot prove that Double => Double =:= scala.util.Try[Double].
val r11 = 100.0 !> {x : Double => x / 0.0} #> {x:Double => x* 3.0} 
                                           ^
注意,在最后的第二行代码中,我只需要添加 用于强制左关联性的括号 (Scala默认设置)。似乎
#>
操作符试图 使用函数
{x:Double=>x/0.0}
,它确实是一个 加倍

但是,如果我使用“&>”运算符,则不会发生错误。在 测试下面的代码,只需翻转注释即可。所以我的问题是,为什么 这是真的吗。这是Scala 2.12.0的新功能吗


TIA

问题在于运算符优先级。详情如下:

它取决于运算符的第一个字符<代码>.的优先级高于
的优先级高于
&

因此你得到了

100.0 !> ({x : Double => x / 0.0} #> {x:Double => x* 3.0})
而不是

(100.0 !> {x : Double => x / 0.0}) #> {x:Double => x* 3.0}

问题在于运算符优先级。详情如下:

它取决于运算符的第一个字符<代码>.
的优先级高于
的优先级高于
&

因此你得到了

100.0 !> ({x : Double => x / 0.0} #> {x:Double => x* 3.0})
而不是

(100.0 !> {x : Double => x / 0.0}) #> {x:Double => x* 3.0}

这并不新鲜。我不考虑操作符优先级。被过载问题弄瞎了,这使我考虑了算子的关联性。这就是我需要的解释:#的优先级高于!(根据您提供的链接)。你能回答这个问题吗?这样我就可以把它贴上正确的标签了?蒂娅,不是那么新鲜。我不考虑操作符优先级。被过载问题弄瞎了,这使我考虑了算子的关联性。这就是我需要的解释:#的优先级高于!(根据您提供的链接)。你能回答这个问题吗?这样我就可以把它贴上正确的标签了?蒂亚。