Question

我正在尝试：

MyObject.myMethod(_:MyType.myAttribute)

失败

type myAttribute is not a member of object MyObject

这是正确的。问题是，我想在myMethod的{{1}}上致电myAttribute，而不是将_:MyType归于MyType:myAttribute。我可以以某种方式对类型归属_进行分组吗？ _:MyType会返回(_:MyType).myAttribute类型，这不是我想要的。

编辑：我更改了这篇文章的标题和文字，不再将其称为点的相关性，我认为这是不正确的。

Answer 1

您是否尝试使用underscore创建功能(m: MyType) => MyObject.myMethod(m.myAttribute)？

如果是这样，问题是MyObject.myMethod((_:MyType).myAttribute)表示MyObject.myMethod((m:MyType) => m.myAttribute)。

您可以使用中缀表示法：

MyObject myMethod (_:MyType).myAttribute

证明它有效：

scala> case class MyType(myAttribute: Int)
defined class MyType

scala> object MyObject {
     |   def myMethod(a: Int) = a.toString
     | }
defined module MyObject

scala> MyObject myMethod (_:MyType).myAttribute
res0: MyType => java.lang.String = <function1>

scala> res0(MyType(1))
res1: java.lang.String = 1

scala> MyObject myMethod (MyType(1))
<console>:1: error: type mismatch;
 found   : MyType
 required: Int
              MyObject myMethod (_:MyType)
                                  ^

Answer 2

我不确定这是否说明或回答了你的问题，但这是真的。

我的猜测是，在添加归属（键入参数）之后，您希望a.b（_。i）成为一个匿名函数。

但是subexpr会使你there is no other expression of syntactic category Expr which is properly contained in e and which itself properly contains u.（SLS 6.23）

此外，您可以使用scalac -Xprint:parser查看如何使用。

object Foo {
  def m(k: Int) = 7 * k
}
class Bar {
  val i = 5
  val What = i
}
object Bar {
  type What = Int
}

object Test extends App {
  Foo.m(_:Bar.What)
  // this is not anon func placeholder syntax...
  //Foo.m((_:Bar).What)  // _ is in a subexpr
  //Foo.m(_.i)
  // ...for this
  val f = (x: Bar) => Foo.m(x.i)
  // InfixExpr is ok
  val g = Foo m (_: Bar).i
  val b = new Bar
  println(f(b))
  println(g(b))
}

对比，以说明受限制的内容：

scala> val f: (Int,Int)=>Int = _+_
f: (Int, Int) => Int = <function2>

scala> val g: Int=>Int = if (_ > 0) 1 else 2
<console>:7: error: missing parameter type for expanded function ((x$1) => x$1.$greater(0))

Answer 3

List(1,2,3).map((i: Int) => i * i)

修改

List(1,2,3).map((_: Int).unary_-)

编辑2

implicit class MyAttribute(i: Int) { def myMethod() = i * i }
List(1,2,3).map((_: Int).myMethod.unary_-)

说明

我使用隐式类（Scala-2.10）在Int上添加myMethod，然后在结果上执行一元“ - ”操作。您可以将def wrap: MyAttribute添加到MyAttribute，并将其用作(_: Int).wrap.method1.method2.method3.result.abs，例如。{/ p>

强制在scala中对下划线分组归属

3 个答案: