Pollak D. Beginning Scala
Подождите немного. Документ загружается.
CHAPTER 8 ■ PARSERS—BECAUSE BNF IS NOT JUST FOR ACADEMICS ANYMORE
247
/*
DoubleStringCharacters ::
DoubleStringCharacter DoubleStringCharacters(opt)
*/
lazy val doubleStringCharacters: Parser[String] =
rep1(doubleStringCharacter) ^^ (_.mkString)
/*
SingleStringCharacters ::
SingleStringCharacter SingleStringCharacters(opt)
*/
lazy val singleStringCharacters: Parser[String] =
rep1(singleStringCharacter) ^^ (_.mkString)
/* DoubleStringCharacter ::
SourceCharacter but not double-quote " or backslash \ or LineTerminator
\ EscapeSequence
*/
lazy val doubleStringCharacter: Parser[Char] =
('\\' ~> escapeSequence) |
((not('"') ~ not('\\') ~ not(lineTerminator)) ~> sourceCharacter)
/*
LineTerminator ::
<LF>
<CR>
<LS>
<PS>
*/
lazy val lineTerminator = elem("Line Terminator",
c => (c == '\r' ||
c == '\n' ||
c == '\u2028' ||
c == '\u2029'))
/*
SingleStringCharacter ::
SourceCharacter but not single-quote ' or backslash \ or LineTerminator
\ EscapeSequence
*/
19897ch08.fm Page 247 Wednesday, April 22, 2009 3:54 PM
248
CHAPTER 8
■ PARSERS—BECAUSE BNF IS NOT JUST FOR ACADEMICS ANYMORE
lazy val singleStringCharacter: Parser[Char] =
('\\' ~> escapeSequence) |
((not('\'') ~ not('\\') ~ not(lineTerminator)) ~> sourceCharacter)
/*
EscapeSequence ::
CharacterEscapeSequence
HexEscapeSequence
UnicodeEscapeSequence
*/
lazy val escapeSequence: Parser[Char] =
characterEscapeSequence | hexEscapeSequence | unicodeEscapeSequence
/*
CharacterEscapeSequence ::
SingleEscapeCharacter
NonEscapeCharacter
*/
lazy val characterEscapeSequence: Parser[Char] =
singleEscapeCharacter | nonEscapeCharacter
/*
SingleEscapeCharacter :: one of
' " \ b f n r t
*/
lazy val singleEscapeCharacter: Parser[Char] =
'\'' ^^^ '\'' |
'"' ^^^ '"' |
'\\' ^^^ '\\' |
'b' ^^^ '\b' |
'f' ^^^ '\f' |
'n' ^^^ '\n' |
'r' ^^^ '\r' |
't' ^^^ '\t'
/*
NonEscapeCharacter ::
SourceCharacter but not EscapeCharacter or LineTerminator
*/
lazy val nonEscapeCharacter: Parser[Char] =
(not(escapeCharacter) ~ not(lineTerminator) ~> sourceCharacter)
19897ch08.fm Page 248 Wednesday, April 22, 2009 3:54 PM
CHAPTER 8 ■ PARSERS—BECAUSE BNF IS NOT JUST FOR ACADEMICS ANYMORE
249
/*
EscapeCharacter ::
SingleEscapeCharacter
DecimalDigit
x
u
*/
lazy val escapeCharacter: Parser[Unit] =
(singleEscapeCharacter | decimalDigit | 'x' | 'u') ^^^ ()
/*
HexEscapeSequence ::
x HexDigit HexDigit
*/
lazy val hexEscapeSequence: Parser[Char] =
'x' ~> hexDigit ~ hexDigit ^^
{case d1 ~ d2 => Integer.parseInt(d1.toString + d2, 16).toChar}
/*
UnicodeEscapeSequence ::
u HexDigit HexDigit HexDigit HexDigit
*/
lazy val unicodeEscapeSequence =
'u' ~> hexDigit ~ hexDigit ~ hexDigit ~ hexDigit ^^
{case d1 ~ d2 ~ d3 ~ d4 =>
Integer.parseInt(d1.toString + d2 + d3 + d4, 16).toChar}
/*
ArrayLiteral :
[ Elision(opt) ]
[ ElementList ]
[ ElementList , Elision(opt) ]
*/
lazy val arrayLiteral: Parser[List[Any]] =
spaces ~ '[' ~ spaces ~> elementList <~
spaces ~ opt(elision) ~ spaces ~ ']' ~ spaces
/*
ElementList :
Elision(opt) AssignmentExpression
ElementList , Elision(opt) AssignmentExpression
*/
19897ch08.fm Page 249 Wednesday, April 22, 2009 3:54 PM
250
CHAPTER 8
■ PARSERS—BECAUSE BNF IS NOT JUST FOR ACADEMICS ANYMORE
lazy val elementList: Parser[List[Any]] =
repsep(spaces ~> jsonObject, elision)
/*
Elision :
,
Elision ,
*/
lazy val elision: Parser[Unit] =
rep1(spaces ~ ',' ~ spaces) ^^^ ()
/*
ObjectLiteral :
{ }
{ PropertyNameAndValueList }
*/
lazy val objectLiteral: Parser[Map[String, Any]] =
spaces ~ '{' ~ spaces ~ '}' ~ spaces ^^^ Map[String, Any]() |
spaces ~ '{' ~ spaces ~> propertyNameAndValueList <~
spaces ~'}' ~ spaces ^^ (vl => Map(vl :_*))
/*
PropertyNameAndValueList :
PropertyName : AssignmentExpression
PropertyNameAndValueList , PropertyName : AssignmentExpression
*/
lazy val propertyNameAndValueList:Parser[List[(String, Any)]] =
rep1sep((spaces ~> propertyName) ~
(spaces ~ ':' ~ spaces ~> jsonObject) ^^ {
case n ~ v => (n, v)},
spaces ~ ',' ~ spaces)
/*
PropertyName :
Identifier
StringLiteral
NumericLiteral
*/
lazy val propertyName: Parser[String] = stringLiteral |
numericLiteral ^^ (_.longValue.toString) | identifier
19897ch08.fm Page 250 Wednesday, April 22, 2009 3:54 PM
CHAPTER 8 ■ PARSERS—BECAUSE BNF IS NOT JUST FOR ACADEMICS ANYMORE
251
/*
IdentifierName ::
IdentifierStart
IdentifierName IdentifierPart
*/
lazy val identifier: Parser[String] =
identifierStart |
identifier ~ identifierPart ^^ {
case a ~ b => a+b
}
/*
IdentifierStart ::
UnicodeLetter
$
_
*/
lazy val identifierStart: Parser[String] =
'$' ^^^ "$" | '_' ^^^ "_" | unicodeLetter ^^ (_.toString)
/*
IdentifierPart ::
IdentifierStart
UnicodeDigit
*/
lazy val identifierPart: Parser[String] =
identifierStart | unicodeDigit ^^ (_.toString)
lazy val unicodeLetter = elem("Letter", Character.isLetter)
lazy val unicodeDigit = elem("Letter", Character.isDigit)
lazy val jsonObject: Parser[Any] = objectLiteral | arrayLiteral | literal
type RootType = Any
def root = jsonObject
}
19897ch08.fm Page 251 Wednesday, April 22, 2009 3:54 PM
252
CHAPTER 8
■ PARSERS—BECAUSE BNF IS NOT JUST FOR ACADEMICS ANYMORE
So, that’s it. Let’s see how the Parser does with various JSON input:
scala> JSON.run("1")
res0: JSON.ParseResult[JSON.RootType] = [1.2] parsed: 1.0
scala> JSON.run("'Elwood Eats Mice'")
res1: JSON.ParseResult[JSON.RootType] = [1.19] parsed: Elwood Eats Mice
scala> JSON.run("'Elwood \u0021 Eats Mice'")
res2: JSON.ParseResult[JSON.RootType] = [1.21] parsed: Elwood ! Eats Mice
scala> JSON.run("[1,2,3,]")
res3: JSON.ParseResult[JSON.RootType] = [1.9] parsed: List(1.0, 2.0, 3.0)
scala> JSON.run("{a:true, 'hello':33}")
res4: parsed: Map(a -> true, hello -> 33.0)
Great. We’ve converted the ECMAScript spec into a running Parser. Let’s see what we
can layer on top of the JSON
Parser. Let’s build some code that will parse Twitter APIs.
Twitter JSON Parsing
JSON is great for storing and transmitting dynamically typed information, but Scala is a
statically typed language. It would be great to be able to convert the dynamic stuff parsed
from JSON data into statically typed Scala. As an example, we’re going to use some of the
19897ch08.fm Page 252 Wednesday, April 22, 2009 3:54 PM
CHAPTER 8 ■ PARSERS—BECAUSE BNF IS NOT JUST FOR ACADEMICS ANYMORE
253
Twitter APIs that return Twitter’s public timeline.
6
We’ll request the data in JSON format,
parse it, and then run the parsed data through a conversion to create Scala instances that
represent the Twitter data.
Utilities
In order to use Scala’s for comprehension to safely and easily extract data from the result
of the JSON parsing, we’re going to write a helper trait,
SafeMap, which does type-safe
testing and casting.
SafeMap has an is method that takes an implicit parameter, man, which
is a
Manifest representing the type T. The Scala compiler correctly builds the Manifest and
passes it to the method.
7
We use the Manifest to get the class for T and do testing. First we
have the code in Listing 8-3 and then a dissection.
Listing 8-3. Type-Safe Map Utility
trait SafeMap {
import scala.reflect._
class SafeCast(in: Any) {
def is[T](implicit man: Manifest[T]): Option[T] = {
// special case for Boolean
val cls = if (man.toString == "boolean") classOf[java.lang.Boolean]
else man.erasure
in match {
case null => None
case t: AnyRef if cls.isAssignableFrom(t.getClass) =>
Some(t.asInstanceOf[T])
case _ => None
}
}
}
6. http://apiwiki.twitter.com/REST+API+Documentation. Alex Payne, co-author with Dean Wampler
of the fine book Programming Scala (O’Reilly, forthcoming), maintains Twitter’s APIs.
7. Manifest is an experimental feature introduced in Scala 2.7.2, but it’s so very useful that I’m including
it in the book.
19897ch08.fm Page 253 Wednesday, April 22, 2009 3:54 PM
254
CHAPTER 8
■ PARSERS—BECAUSE BNF IS NOT JUST FOR ACADEMICS ANYMORE
class SafeMapC[A, B](m: Map[A, B]) {
def sGet[T](key: A)(implicit man: Manifest[T]): Option[T] =
m.get(key).flatMap(v => new SafeCast(v).is(man))
}
implicit def mToSM[A, B](in: Map[A, B]) = new SafeMapC(in)
implicit def iToIs(v: Any) = new SafeCast(v)
}
When the Java Virtual Machine was introduced in 1996, the Java language did not
include generics. In Java 1.0, an
ArrayList contained only Object. You had to manually cast
each element of
ArrayList into the class that you wanted. Java 1.5 introduced generics so
that at compile time you could specify
ArrayList<String>. This avoided the manual cast
because the compiler did the casting for you. However, the JVM was not updated to keep
track of the generics associated with
ArrayList<?>, so under the covers, an ArrayList<String>
is just an
ArrayList, not an ArrayList<String>. The type, <String>, is erased, which means
it is known at compile time but not at runtime. This design was perpetuated through to Scala.
Scala introduced a feature in 2.7.2 called
Manifests. They were an experimental, undoc-
umented feature, but they are very, very useful. They allow a method implicitly to take a
Manifest as a parameter for each type parameter passed to the method. The Manifest
contains information including the type that is to be erased when the bytecode is rendered.
Thus, the
Manifest allows us to reify the erased type.
8
We will use this feature in our SafeMap trait to do syntactically pleasing, type-safe casting.
First, we define a
SafeMap trait that we can mix into any class or object and make use of
type-safe access to
Maps.
trait SafeMap {
We import the scala.reflect package to the Manifest:
import scala.reflect._
We define the SafeCast class. It has a single method, is, which takes an implicit Manifest
as a parameter and tests to see whether the class of
in is assignable from the class contained
by the
Manifest and accessed using the erasure method.
class SafeCast(in: Any) {
def is[T](implicit man: Manifest[T]): Option[T] = {
// special case for Boolean
val cls = if (man.toString == "boolean") classOf[java.lang.Boolean]
else man.erasure
8. See http://scala-blogs.org/2008/10/manifests-reified-types.html.
19897ch08.fm Page 254 Wednesday, April 22, 2009 3:54 PM
CHAPTER 8 ■ PARSERS—BECAUSE BNF IS NOT JUST FOR ACADEMICS ANYMORE
255
We do the actual testing of the in variable:
in match {
case null => None
case t: AnyRef if cls.isAssignableFrom(t.getClass) =>
Some(t.asInstanceOf[T])
case _ => None
}
}
}
SafeMapC is a class that contains a method that gets the key and uses SafeCast to ensure
that the key is of the class we want to cast it to.
sGet will test that the key is in the Map and
returns the value associated with the key if the value is of type
T, otherwise None.
class SafeMapC[A, B](m: Map[A, B]) {
def sGet[T](key: A)(implicit man: Manifest[T]): Option[T] =
m.get(key).flatMap(v => new SafeCast(v).is(man))
}
implicit def mToSM[A, B](in: Map[A, B]) = new SafeMapC(in)
implicit def iToIs(v: Any) = new SafeCast(v)
}
Parsing the JSON
First, let’s look Listing 8-4, and then we’ll work through it.
Listing 8-4. Twitter Parser
trait TwitterElem
/*
<status>
created_at
id
text
source
truncated
in_reply_to_status_id
in_reply_to_user_id
favorited
*/
19897ch08.fm Page 255 Wednesday, April 22, 2009 3:54 PM
256
CHAPTER 8
■ PARSERS—BECAUSE BNF IS NOT JUST FOR ACADEMICS ANYMORE
case class TwitterStatus(id: Long,
createdAt: String,
text: String,
source: String,
truncated: Boolean,
inReplyToStatus: Option[Long],
inReplyToUser: Option[Long],
favorited: Boolean,
user: TwitterUser) extends TwitterElem
object TwitterStatus extends SafeMap {
def apply(in: Any): Option[TwitterStatus] =
for {m <- in.is[Map[String, Any]]
id <- m.sGet[String]("id").map(_.toLong)
createdAt <- m.sGet[String]("created_at")
text <- m.sGet[String]("text")
source <- m.sGet[String]("source")
truncated <- m.sGet[Boolean]("truncated")
inRepSt = m.sGet[Double]("in_reply_to_status_id").map(_.toLong)
inRepUsr = m.sGet[Double]("in_reply_to_user_id").map(_.toLong)
fav = m.sGet[Boolean]("favorited") getOrElse false
userObj <- m.sGet[Map[String, Any]]("user")
user <- TwitterUser(userObj)
} yield new TwitterStatus(id, createdAt, text, source,
truncated,
inRepSt, inRepUsr, fav, user)
def fromList(in: Any): List[TwitterStatus] = {
for {list <- in.is[List[Any]].toList
item <- list
st <- apply(item)
} yield st
}
}
/*
<user>
id
name
screen_name
description
19897ch08.fm Page 256 Wednesday, April 22, 2009 3:54 PM