2

这对我来说开始是一个很常见的情况：

  trait CoVariant[+T] {
    def bar: T
  }

  def curried[T](x: String)(y: CoVariant[T]) = y // Not really, but for simplicity
  val applied = curried("foo") _

  val bar = new CoVariant[String] {
    def bar = "bar"
  }
  applied(bar)

所以我有一些共同变体的东西，我需要先做一些常见的事情，然后让一个通用的部分未应用。我真的很希望能够像上面的柯里化函数一样编写它，但这当然会在最后一行产生编译错误：

- type mismatch;  found   : CoVariant[String]  required: CoVariant[Nothing]

我似乎诉诸于引入一个类只是为了在某个地方粘贴类型参数，以便可以将其保留为抽象：

trait StupidWrapper {
   def apply[T](y: CoVariant[T]) : CoVariant[T]
}

而不是咖喱的东西

def notAsNice(x: String) = new StupidWrapper {
   def apply[T](y: CoVariant[T]) = y
}

所以现在：

val applied = notAsNice("foo")
applied(bar)

编译。

这感觉很愚蠢，我想有更好的方法吗？

更新：

我想我会更好地具体化。我所拥有的是：

  abstract class ParserToSeq {
    def apply[T](parser: Parser[T]): Seq[T]
  }

  def fromTrainingData(trainingLines: Seq[String]) = new ParserToSeq {
    def apply[T](p: Parser[T]) = trainingLines.map(parseAll(p, _)).map {
      _ match {
        case Success(wt, _) => Some(wt)
        case _ => None
      }
    }.flatten
  }

进而

val thisData = fromTrainingData(trainingLines)
lazy val wordTags = thisData(wordtagParser) // Parser[WordTag]
lazy val uniGrams = thisData(uniGramParser) // Parser[UniGram]
…

我只想取消 ParserToSeq 并执行以下操作：

def fromTrainingData[T](trainingLines: Seq[String])(p: Parser[T]) = 
  trainingLines.map(parseAll(p, _)).map {
  _ match {
    case Success(wt, _) => Some(wt)
    case _ => None
  }
}.flatten

请注意，此处的 T 特定于每个解析器。据我了解，问题是 T 被解析为部分应用方法上的具体类型，即使该类型实际上适用于第二个参数列表。

看来我想把类型参数的声明放在中间的某个地方：

def fromTrainingData(trainingLines: Seq[String])[T](p: Parser[T])

这当然不是有效的Scala。

4

1 回答 1

2

正如您所提到的，scalaFunction对象不携带类型参数。

但是，您可以替换为采用更高种类ParseToSeq的更通用~>的类型，

trait ~>[A[_],B[_]] {
  def apply[X](a : A[X]) : B[X]
}

然后你的例子变成了，

trait Parser[T]
trait WordTag
trait UniGram
val trainingLines: Seq[String] = ???
val wordtagParser: Parser[WordTag] = ???
val uniGramParser: Parser[UniGram] = ???

def fromTrainingData[T](trainingLines: Seq[String]) = new ~>[Parser,Seq] {
  def apply[T](p: Parser[T]): Seq[T] = ???
}
val thisData = fromTrainingData(trainingLines)
lazy val wordTags = thisData(wordtagParser) // Seq[WordTag]
lazy val uniGrams = thisData(uniGramParser) // Seq[UniGram]
于 2013-04-14T15:43:17.383 回答