Question

我遇到类型推断问题并请求帮助here。最初的问题是由于过载。一旦纠正我还是有问题。

所以这是代码：

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}，这确实是一个双。

但是如果我使用＆＃34;＆amp;＆gt;＆＃34;运算符，不会发生错误。在里面下面的测试代码，只需翻转评论。所以我的问题是，为什么这是怎么回事。这是Scala 2.12.0的新功能吗？

TIA

Answer 1

问题在于运营商的优先级。以下是更多详情：Operator precedence in Scala

这取决于运算符的第一个字符。 #的优先级高于!，!的优先级高于&。

因此你得到了

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

而不是

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

Scala运算符＃＆gt;导致编译错误，但没有＆amp;＆gt; - 为什么？

1 个答案: