如何使用Scala RegexParsers避免不完全匹配的警告？
Scala RegexParsers是Scala语言中的一个解析器库，用于处理正则表达式的解析和匹配。当使用RegexParsers进行匹配时，有时会遇到不完全匹配的警告。为了避免这个警告，可以采取以下几个步骤：
- 导入RegexParsers库：首先，需要在代码中导入RegexParsers库，以便使用其中的解析器和相关功能。
import scala.util.parsing.combinator.RegexParsers- 定义解析器：接下来，需要定义一个解析器，用于解析和匹配正则表达式。可以使用RegexParsers的
regex方法来定义解析器。
class MyParser extends RegexParsers {
def myRegex: Parser[String] = regex("your-regex-pattern".r)
}在上面的代码中，myRegex是一个解析器，它使用regex方法来匹配一个正则表达式模式。
- 处理不完全匹配的警告：当使用RegexParsers进行匹配时，有时会遇到不完全匹配的警告。为了避免这个警告，可以使用
^^操作符来指定解析器的返回类型。
class MyParser extends RegexParsers {
def myRegex: Parser[String] = regex("your-regex-pattern".r) ^^ {
case result => result
}
}在上面的代码中，^^操作符将解析器的返回结果包装在一个匿名函数中，并返回相同的结果。这样可以避免不完全匹配的警告。
- 使用解析器：最后，可以使用定义好的解析器来进行匹配和解析操作。
object Main extends App {
val parser = new MyParser()
val result = parser.parseAll(parser.myRegex, "your-input-string")
if (result.successful) {
println(result.get)
} else {
println("Parsing failed.")
}
}在上面的代码中，parseAll方法用于对输入字符串进行解析和匹配操作。如果解析成功，则打印结果；否则，打印解析失败的信息。
总结：
使用Scala RegexParsers可以避免不完全匹配的警告，需要导入RegexParsers库，定义解析器并使用^^操作符指定返回类型，最后使用解析器进行匹配和解析操作。
腾讯云相关产品和产品介绍链接地址：
- 腾讯云：https://cloud.tencent.com/
- 云服务器（CVM）：https://cloud.tencent.com/product/cvm
- 云数据库 MySQL 版：https://cloud.tencent.com/product/cdb_mysql
- 云原生应用引擎（TKE）：https://cloud.tencent.com/product/tke
- 人工智能：https://cloud.tencent.com/product/ai
- 物联网（IoT）：https://cloud.tencent.com/product/iotexplorer
- 移动开发：https://cloud.tencent.com/product/mobdev
- 对象存储（COS）：https://cloud.tencent.com/product/cos
- 腾讯区块链服务（TBCS）：https://cloud.tencent.com/product/tbcs
- 腾讯云元宇宙：https://cloud.tencent.com/solution/egc
相关·内容
2回答
下面是我为正面Int编写一个小型解析器的尝试：
import scala.util.parsing.combinator.RegexParsers
object PositiveIntParser extends RegexParsers {
private def positiveInt: Parser[Int] = """0*[1-9]\d*""".r ^^ { _.toInt }
def apply(input: String): Option[Int] = parseAll(positiveInt, input) match
浏览 4提问于2016-05-05得票数 1
回答已采纳
解析空白/空白有什么问题？
scala> object BlankParser extends RegexParsers {
def blank: Parser[Any] = " "
def foo: Parser[Any] = "foo"
}
defined module BlankParser
scala> BlankParser.parseAll(BlankParser.foo, "foo")
res15: BlankParser.ParseResult[Any] = [1.4
浏览 0提问于2010-08-25得票数 3
回答已采纳
因此，我想在我的SBT项目中使用库。
我的build.sbt如下所示
name := "SampleName"
version := "1.0"
scalaVersion := "2.12.4"
libraryDependencies += "com.github.philcali" % "cronish_2.11" % "0.1.3"
我必须明确地提到cronish_2.11，因为cronish_2.12不存在。我正在运行位于workers.scala的$ProjectRoot/src/main/
浏览 2提问于2017-10-31得票数 3
回答已采纳
假设我正在用Scala编写一个基本的SQL解析器。我有以下几点：
class Arith extends RegexParsers {
def selectstatement: Parser[Any] = selectclause ~ fromclause
def selectclause: Parser[Any] = "(?i)SELECT".r ~ tokens
def fromclause: Parser[Any] = "(?i)FROM".r ~ tokens
def tokens: Parser[Any] = rep(t
浏览 1提问于2011-10-19得票数 14
回答已采纳
我编写了以下Parser，其目的是在空白上使用fail-ing：
import scala.util.parsing.combinator._
object Foo extends JavaTokenParsers {
val wsTest = not(whiteSpace) // uses whitespace inherited from `RegexParsers`
}
为什么解析一堆空白是成功的？
scala> Foo.parseAll(Foo.wsTest, " ")
res5: Foo.ParseResult[Unit] = [1.1
浏览 2提问于2014-09-01得票数 1
回答已采纳
我使用Scala解析器组合子已经有一段时间了，我学习了一些方法来让它表现良好，并使用内置函数做我想做的大多数事情。
但是如何制作嵌入式语言(如php或ruby的erb)呢？它要求在实际代码的嵌入之外不要忽略空格。
我设法创建了一个简单的解析器，它将所有文本匹配到给定的正则表达式匹配，但我正在寻找一种更好、更漂亮的方式来实现这一点。可能有一些已经定义好的函数可以完成所需的工作。
测试语言解析文本的方式如下：
now: [[ millis; ]]
and now: [[; millis; ]]
并由以下代码生成：
package test
import scala.util.parsing.co
浏览 2提问于2010-07-28得票数 2
回答已采纳
我正在编写scala解析器来解析以下输入(x是数字)：/hdfs://xxx.x.x.x:xxxx/path1 1/file1.jpg+1
trait pathIdentifier extends RegexParsers{
def pathIdent: Parser[String] ="""^/hdfs://([\d\.]+):(\d+)/([\w/]+/(\w+\.\w+)$)""".r
}
class ParseExp extends JavaTokenParsers with pathIdentifier {
de
浏览 2提问于2015-06-13得票数 1
回答已采纳
对于scala组合器的第一次测试，我尝试从一个句子中获取所有单词，但我只是从以下代码中获得"None“：
import java.io.File
import scala.io.Source
import scala.util.parsing.combinator._
object PgnReader extends TagParser {
def parseFile(inputFile:File) = {
val pgnStream = Source.fromFile(inputFile)
val pgnStr = pgnStream.mkString
浏览 3提问于2014-11-24得票数 1
回答已采纳
对于逻辑表达式的简单解析器，我有以下代码：
import scala.util.parsing.combinator.RegexParsers
import scala.util.parsing.combinator.PackratParsers
object Parsers extends RegexParsers with PackratParsers
// Entities definition
sealed trait LogicalUnit
case class Variable(name: String) extends LogicalUnit
case class Not(
浏览 2提问于2014-10-19得票数 1
回答已采纳
我正在寻找一个函数来动态组合Scala组合器。例如，如果我想静态地这样做，我可以写：
def aDirective: Parser[String] = "a" ^^ { case _ => "a" }
def bDirective: Parser[String] = "b" ^^ { case _ => "b" }
def combinedDirective: Parser[List[String]] =
aDirective ~ bDirective ^^ { case a ~ b => List(a,
浏览 0提问于2014-06-20得票数 3
回答已采纳
我在玩弄Scala的解析器组合器，我被一个我似乎不太理解的错误所困扰。
以下是相关代码：
trait ASTNode
trait Terminal extends ASTNode
trait Nonterminal extends ASTNode
case class Identifier(id: String) extends Terminal
case class TypeDefinition(identifier: Identifier, optionalType: Option[TypeParameters]) extends Nonterminal
case class TypePa
浏览 0提问于2016-04-05得票数 0
回答已采纳
1回答
我有个简单的问题：
我希望有一个解析文本的结果的值映射：
example.txt
Anna
James
Katy
因此，它应该是一幅大地图--就像这样：
user_1 : Anna
user_2 : James
user_3 : Katy
我希望用case类将它与解析逻辑分开保存：
case class UserMap(userMap: Map[String, String])
所以，我开始解析它，我需要一些熟悉的东西：
(pseudo-scala)
def parseTxt: Parser[UserMap] = ".*".r ^^ {
case res =>
浏览 2提问于2015-04-28得票数 0
回答已采纳
我试图获得一个解析器来获取一个冒号分隔的单词序列，并将它们转换为一个数组。
这是一个SSCCE。
import util.parsing.combinator._
class Element {
def getSuper() = "TODO"
}
class Comp extends RegexParsers with PackratParsers {
lazy val element: PackratParser[Element] = (
"foo") ^^ {
s => new Element
}
lazy v
浏览 3提问于2015-05-27得票数 2
回答已采纳
1回答
我刚开始使用Scala中的解析器组合器，但是被一个解析器卡住了，用来解析诸如“我喜欢Scala”这样的句子。(单词以空格或句点(.)结尾)。
我从以下实现开始：
package example
import scala.util.parsing.combinator._
object Example extends RegexParsers {
override def skipWhitespace = false
def character: Parser[String] = """\w""".r
def word: Par
浏览 6提问于2014-01-25得票数 2
回答已采纳
1回答
使用scala.util.parsing.combinator._包，如何创建与abc匹配的简单Parser
示例：
val parser = new Parser("abc")
val stream: Stream[Character] = Stream('a', 'b', 'c', 'd')
println("parser(stream) : " + parser(stream))`
打印出来：
成功(a，b，c)，流(D)
浏览 1提问于2013-11-25得票数 0
回答已采纳
1回答
在受够了正则表达式之后，我一直在尝试使用scala的解析器组合器库作为正则表达式更直观的替代品。但是，当我想在一个字符串中搜索一个模式并忽略它之前的内容时，我遇到了一个问题，例如，如果我想检查一个字符串是否包含单词"octopus“，我可以这样做
val r = "octopus".r
r.findFirstIn("www.octopus.com")
这正确地给出了Some(octopus)。
但是，使用解析器组合子
import scala.util.parsing.combinator._
object OctopusParser extends R
浏览 0提问于2013-07-10得票数 1
我正在尝试从结果集中获取一个名为-> id的映射。
val isp = SQL("select id, name from internet_service_providers").map { x => x[String]("name") -> x[String]("id") }
我无法理解为什么我会犯这个错误。
Exception in thread "main" java.lang.NoSuchMethodError: scala.Predef$.ArrowAssoc(Ljava/lang/Object;)L
浏览 3提问于2015-05-20得票数 0
回答已采纳
1回答
我正在使用Scala RegexParser构建一个简单的计算器，并且我试图为使用**的电源操作创建一个规则，如下所示：
package com.pt.pedrorijo91.calc
import scala.util.parsing.combinator.RegexParsers
import scala.math.pow
class Arith extends RegexParsers {
def number: Parser[Double] = """\d+(\.\d*)?""".r ^^ { _.toDouble }
d
浏览 3提问于2014-12-27得票数 1
2回答
在一个特征中，我在使用从另一个特征中的方法返回的解析器时遇到了问题。编译器抱怨类型不匹配，在我看来这个问题是由于依赖于路径的类造成的。我不知道怎样才能得到我想要的。
trait Outerparser extends RegexParsers {
def inner: Innerparser
def quoted[T](something: Parser[T]) = "\"" ~> something <~ "\""
def quotedNumber = quoted(inner.number) // Comp
浏览 1提问于2012-09-19得票数 1
回答已采纳
2回答
解析器组合器防止字符串映射
、、、、
import scala.util.parsing.combinator._
object SimpleArith extends JavaTokenParsers {
"abc".map(identity)
产生
类型错配；找到:字符串(“abc”)要求：?{def map：?}注意隐式转换不适用，因为它们不明确:类型(x: String)scala.collection.immutable.StringOps中的对象Predef中的方法scala.collection.immutable.StringOps和类型(s: String)SimpleArith.Pa
浏览 4提问于2015-11-18得票数 0
回答已采纳
我正在用Scala创建一个解析器：
import scala.util.parsing.combinator._
// Parser of protocol
object Parser extends RegexParsers {
//code
}
当像这样创建我的主对象时：
import Parser._
object main extends Parser {
def main(args: Array[String]): Unit =
{
}
}
我得到以下信息:对象创建不可能，因为方法应用于类型为( in : Parser.Input)的解析器的类中没有定义Parser.
浏览 2提问于2018-12-16得票数 0
我正在使用解析器组合器将准结构化日志文件数据转换为JSON。我希望在执行过程中使用位置信息来丰富结果，以便可以在原始输入文件中定位输出中的数据元素。当我在和中看到对positioned方法的描述时，我认为解决方案就在我面前，但我却遇到了这样的异常：
Error:(133, 24) inferred type arguments [String]
do not conform to method positioned's type
parameter bounds [T <: scala.util.parsing.input.Positional]
从中提炼出来，我希望能够说出
浏览 0提问于2017-01-26得票数 0
1回答
我最近一直在使用Scala，在使用解析器组合子时，我在扩展它们时遇到了一些问题。基本上，我正在尝试做的事情是这样的。
import scala.util.parsing.combinator.RegexParsers
abstract class Statement
case object Foo extends Statement
case object Bar extends Statement
case object Baz extends Statement
class Program(statements: List[Statement])
class FooBarLangu
浏览 0提问于2013-06-01得票数 0
回答已采纳
2回答
我看到了在Scala中构建解析器的两种方法。
第一个是从RegexParsers扩展，并定义您的won词法模式。我看到的问题是，我并不真正理解它是如何处理关键字歧义的。例如，如果我的关键字与idents匹配相同的模式，则它将关键字作为idents处理。
为了反击这一点，我见过像这样的帖子，它们展示了如何使用StandardTokenParsers来指定关键字。但是，我不知道如何指定regexp模式！是的，StandardTokenParsers提供了"ident“，但它没有提供我需要的其他内容(复杂的浮点数表示、特定的字符串文字模式和转义规则等)。
如何既能指定关键字，又能用正则表达式
浏览 1提问于2010-09-22得票数 3
回答已采纳
我正在开发一个解析器，它解析了一些具有可选初始字符的术语，这些字符对于所有术语来说都是相同的。我的问题是，一些术语第一字符是相同的，最初的字符。我试图避免重写每一个词与和没有最初的字符。我认为packrat解析器听起来像解决方案，但我还没有让它按照我想要的方式工作。下面是我想要完成的最简单的例子。
import scala.util.parsing.combinator._
import scala.util.parsing.input._
object test extends App {
object MyParser extends RegexParsers with Packra
浏览 3提问于2014-03-23得票数 0
回答已采纳
1回答
是否可以使用更多的Parser组合器来扩展，也许需要包装器的帮助？我正在尝试添加一个具有自定义行为的新的Parser组合器。我目前的解决方案是采用这些文件(Parsers.scala、RegexParsers.scala和SubSequence.scala)，并直接添加自定义Parser。
编辑
在的帮助下，我得到了以下解决方案：
import scala.util.parsing.combinator._
trait JustTesting extends RegexParsers {
def test = "a" abc "b"
abstrac
浏览 1提问于2016-12-27得票数 0
我正在使用Scala中的本机解析器组合器库，我想解析输入的某些部分，但不解析其他部分。具体来说，我想放弃我关心的输入之间的所有任意文本。例如，使用此输入：
begin
Text I care about
Text I care about
DONT CARE
Text I don't care about
begin
More text I care about
...
现在我有：
object MyParser extends RegexParsers {
val beginToken: Parser[String] = "begin"
va
浏览 2提问于2013-09-25得票数 3
回答已采纳
2回答
我注意到Scala标准库使用了两种不同的策略来组织类、特性和单例对象。
使用成员为导入的包的。例如，这就是访问scala.collection.mutable.ListBuffer的方式。这种技术来自Java、Python等使用特性类型成员的。例如，这就是如何访问Parser类型。您首先需要混合在scala.util.parsing.combinator.Parsers中。这种技术来自Java、Python等，在第三方库中使用不多。。
我猜(2)的一个优点是它组织了方法和类型，但是根据Scala2.8的包对象，可以使用(1)完成同样的操作。为什么这两种策略都有呢？什么时候应该分别使用？
浏览 0提问于2011-03-16得票数 4
回答已采纳
我正在尝试使用scala.util.parsing.combinator来解析一些MIPS代码，我的代码对每个项目(即标签、指令、指令等)都有效，但它不能用于多个项目/行。我认为我传递给repsep函数的分隔符正则表达式不起作用。 例如，我可以解析标签str:，但不能解析str: .asciiz "Hello world!" def directive: Parser[Token] = Text.parse ||| Word.parse ||| Data.parse ||| Ascii.parse ||| Asciiz.parse
def instruction
浏览 44提问于2020-04-15得票数 0
回答已采纳
2回答
我正在尝试理解Scala对Case类做了什么，使它们在某种程度上对类型擦除警告具有免疫力。
假设我们有以下简单的类结构。它基本上是一个Either
abstract class BlackOrWhite[A, B]
case class Black[A,B]( val left: A ) extends BlackOrWhite[A,B]
case class White[A,B]( val right: B ) extends BlackOrWhite[A,B]
你试着这样使用它：
object Main extends App {
def echo[A,B] ( input:
浏览 1提问于2012-01-09得票数 21
回答已采纳
假设我想解析scala中的一个字符串，每次在每个字符串中嵌套括号时，我都会将某个数字与其本身相乘。number=3的Ex (()) +()是3*3 +3+3*3，我怎么用scala组合子做这个。
class SimpleParser extends JavaTokenParsers {
def Base:Parser[Int] = """(""" ~remainder ~ """)"""
def Plus = atom ~ '+' ~ remainder
def
浏览 5提问于2015-12-14得票数 3
回答已采纳
我是Scala的新手，在阅读解析器组合子(，)时，我遇到了这样的方法定义：
def classPrefix = "class" ~ ID ~ "(" ~ formals ~ ")"
我一直在通读scala.util.parsing.Parsers的API doc，它定义了一个名为(tilde)的方法，但我仍然不太理解上面例子中它的用法。在该示例中(代字号)是在java.lang.String上调用的一个方法，该方法没有该方法，并导致编译器失败。我知道(波浪号)的定义是
case class ~ [+a, +b] (_1: a, _2: b)
但是
浏览 0提问于2011-07-25得票数 21
回答已采纳
1回答
解析器组合子-简单语法
、、、
我正在尝试使用Scala中的解析器组合子来处理我从书中复制的简单语法。当我运行以下代码时，它在解析了第一个令牌并出现错误后立即停止
[1.3] failure: string matching regex '\z' expected but '+' found
我知道为什么会出问题了。第一个令牌是一个表达式，因此它是唯一需要根据语法进行解析的东西。然而，我不知道什么是修复它的好方法。
object SimpleParser extends RegexParsers
{
def Name = """[a-zA-Z]+"&#
浏览 1提问于2013-04-01得票数 0
回答已采纳
使用Scala解析器组合子(高效地)解析C风格的多行注释(即/* ... */)的最佳方法是什么？
在我参与的一个项目中，我们解析了一种类似C的编程语言，并希望支持多行注释。我们使用的一个子类，它已经处理了这样的注释(通过。但是，该类只适用于相当短的多行注释，否则会用完堆栈空间。
我们还尝试提供我们自己的空格定义，以提高工作效率。我们使用了一个RegexParser (灵感来自)，如下所示：
class Parser extends StandardTokenParsers {
override val lexical = new StdLexical {
def rp: Reg
浏览 3提问于2012-10-07得票数 5
回答已采纳
我正在学习scala中的解析器组合子，看到了不同的解析方法。我主要看到了三种不同的解析器ie.RegexpParsers，StandardTokenParsers和JavaTokenParsers.I。我是一个新手，不知道如何根据我们的requirement.Can选择合适的解析器。
浏览 0提问于2010-04-30得票数 19
回答已采纳
我正在编写一个解析器，它继承自JavaTokenParsers，因为我有如下函数：
import scala.util.parsing.combinator.lexical._
import scala.util.parsing._
import scala.util.parsing.combinator.RegexParsers;
import scala.util.parsing.combinator.syntactical.StdTokenParsers
import scala.util.parsing.combinator.token.StdTokens
import s
浏览 2提问于2015-06-22得票数 1
回答已采纳
1回答
我是Scala的新手，一直在尝试使用它优秀的combinator解析器库。我一直在尝试编译这段代码：
import scala.util.parsing.combinator._
...
val r:Parsers#ParseResult[Node] = parser.parseAll(parser.suite,reader)
r match {
case Success(r, n) => println(r)
case Failure(msg, n) => println(msg)
case Error(msg, n) => println(msg)
}
...
浏览 0提问于2012-12-09得票数 7
回答已采纳
3回答
我试图用(<，<=，>=，>)解析一个表达式。除了<=，一切都很好。有人能帮上忙吗。代码：
object MyTestParser extends RegexParsers {
override def skipWhitespace = true
private val expression: Parser[String] = """[a-zA-Z0-9\.]+""".r
val operation: Parser[Try[Boolean]] =
expression ~ ("<
浏览 3提问于2015-10-21得票数 4
回答已采纳
我正在实现一个Swing组件，我想要克服Reactor的####无型性。所以我想这是可行的：
trait Foo[A] extends scala.swing.Publisher {
final case class Bar(parent: Vector[A], children: A*) extends scala.swing.event.Event
}
trait Test {
val foo: Foo[Int]
foo.reactions += {
case foo.Bar(parent, children) => {
println(paren
浏览 0提问于2013-05-09得票数 26
回答已采纳
1回答
我希望将字符串序列解析为单个标记。现在它只分析第一个单词。
class SimpleRegexParser extends RegexParsers{
def word: Parser[String] = """[a-z]+""".r ^^ { _.toString }
}
object SimpleRegexParserMain extends SimpleRegexParser{
def main(args: Array[String]) = {
println(parse(word, "johnny has a li
浏览 4提问于2017-01-03得票数 0
2回答
开始使用Scala解析器组合，然后才能更好地掌握失败/错误处理(注意:仍然进入Scala )
希望将"a = b，c= d“这样的字符串解析为元组列表，但在找到悬空逗号时标记用户。
在匹配逗号分隔的属性分配时，考虑匹配off ("a = b，")：
def commaList[T](inner: Parser[T]): Parser[List[T]] =
rep1sep(inner, ",") | rep1sep(inner, ",") ~> opt(",") ~> failure("Dangl
浏览 1提问于2013-08-15得票数 4
回答已采纳
首先定义一个列表：
val list = List(1,2,3)
Scala编译器给出警告(即使它可以匹配)：
list match {
case head :: tail => println(s"h:${head} ~ t: ${tail}")
}
Scala编译器不会给出警告(即使它不匹配)：
list match {
case List(a,b) => println("!!!")
}
我不能理解第二个
浏览 1提问于2014-07-01得票数 2
3回答
我对Scala有些陌生。以下是我的代码。
Option(Session.get().getAttribute("player")) match {
case None => {
val player = new Player(user.getEmail, user.getNickname).createOrGet
Session.get().setAttribute("player", player)
}
}
在编译时，我收到以下警告
Warning:(35, 11) match may not be exhaustive.
It
浏览 2提问于2014-12-31得票数 7
回答已采纳
1回答
我有一个导致执行错误的警告：
[info] Set current project to calculator (in build file:/home/guillaume/projects/scala/2/)
[info] Updating {file:/home/guillaume/projects/scala/2/}root...
[info] Resolving org.fusesource.jansi#jansi;1.4 ...
[info] Done updating.
[warn] Scala version was updated by one of library depen
浏览 6提问于2016-04-04得票数 5
回答已采纳
1回答
我试图使用scala的解析器组合器解析一个字符串，如下所示：
import scala.util.parsing.combinator._
import scala.util.parsing.input.CharSequenceReader
object TestPackratParser extends RegexParsers with PackratParsers {
lazy val program: PackratParser[Any] = "start" ~ water ~ "end" ^^ (_ => println("pro
浏览 2提问于2015-01-16得票数 1
回答已采纳
我正在尝试编写一个用点分隔字符串的正则表达式。例如,
"abc", "abc.def", "a.b.c.e.f"
都是有效的，但是
"abc..def", ".abc", "abc."
是无效的
以下是我在scala中编写的regex代码
object Test {
def main(args: Array[String]) {
val TestPattern = "^([a-z]+)(\\.?[a-z]+)*".r
val x: String = "
浏览 0提问于2013-08-05得票数 3
我使用scala解析器组合器来提取输入字符串中的标识符("a“和"ACCOUNT_ID")。当我使用~>时，它会忽略字符串的所有前面部分，而不是前一个字符串。有没有人能帮我用Scala Parser Combinators从输入字符串中提取2个标识符？感谢您的帮助
class QParser extends JavaTokenParsers with RegexParsers {
def join: Parser [Any] = opt(ident) ~ (opt("(")) ~ ident ~ "." ~> ident &l
浏览 0提问于2015-07-17得票数 0
我是Scala的初学者，现在学习Scala解析器组合器，编写"MiniLogicParser"，这是一个用于命题逻辑公式的迷你解析器。我成功地部分解析了它，但不能转换为case类。我试过了下面的代码。
import java.io._
import scala.util.parsing.combinator._
sealed trait Bool[+A]
case object True extends Bool[Nothing]
case class Var[A](label: A) extends Bool[A]
case class Not[A](child: Bool
浏览 2提问于2016-05-05得票数 1
回答已采纳
给定以下代码片段：
import scala.util.Try
def foo(x:Int) : (Int, String) = {
(x+1, x.toString)
}
def main(args: Array[String]) : Unit = {
val r1: Try[(Int, String)] = for {
v <- Try { foo(3) }
} yield v
val r2: Try[(Int, String)] = for {
(i, s) <- Try { foo(3) } // compile warning re
浏览 0提问于2015-10-21得票数 7
回答已采纳
使用以下Scala Swing代码，我为什么会收到有关类型擦除的模式匹配器警告：
import scala.swing._
object Test extends ListView(Seq(1, 2, 3)) {
listenTo(selection)
reactions += {
case event.ListSelectionChanged(_, range, _) => println(range)
}
}
警告是：
warning: non variable type-argument A in type pattern
scala.swing.event.
浏览 0提问于2012-07-18得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
