Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

Read case class object from string in Scala (something like Haskell's "read" typeclass)

I'd like to read a string as an instance of a case class. For example, if the function were named "read" it would let me do the following:

case class Person(name: String, age: Int)
val personString: String = "Person(Bob,42)"
val person: Person = read(personString)

This is the same behavior as the read typeclass in Haskell.

like image 457
emchristiansen Avatar asked May 29 '12 18:05

emchristiansen


2 Answers

dflemstr answered more towards setting up the actual read method- I'll answer more for the actual parsing method.

My approach has two objects that can be used in scala's pattern matching blocks. AsInt lets you match against strings that represent Ints, and PersonString is the actual implementation for Person deserialization.

object AsInt {
  def unapply(s: String) = try{ Some(s.toInt) } catch {
    case e: NumberFormatException => None
  }
}

val PersonRegex = "Person\\((.*),(\\d+)\\)".r

object PersonString {
  def unapply(str: String): Option[Person] = str match {
    case PersonRegex(name, AsInt(age)) => Some(Person(name, age))
    case _ => None
  }
}

The magic is in the unapply method, which scala has syntax sugar for. So using the PersonString object, you could do

val person = PersonString.unapply("Person(Bob,42)")
//  person will be Some(Person("Bob", 42))

or you could use a pattern matching block to do stuff with the person:

"Person(Bob,42)" match {
  case PersonString(person) => println(person.name + " " + person.age)
  case _ => println("Didn't get a person")
}
like image 159
Dylan Avatar answered Sep 21 '22 12:09

Dylan


Scala does not have type classes, and in this case, you cannot even simulate the type class with a trait that is inherited from, because traits only express methods on an object, meaning that they have to be "owned" by a class, so you cannot put the definition of a "constructor that takes a string as the only argument" (which is what "read" might be called in OOP languages) in a trait.

Instead, you have to simulate type classes yourself. This is done like so (equivalent Haskell code in comments):

// class Read a where read :: String -> a
trait Read[A] { def read(s: String): A }

// instance Read Person where read = ... parser for Person ...
implicit object ReadPerson extends Read[Person] {
  def read(s: String): Person = ... parser for Person ...
}

Then, when you have a method that depends on the type class, you have to specify it as an implicit context:

// readList :: Read a => [String] -> [a]
// readList ss = map read ss
def readList[A: Read] (ss: List[String]): List[A] = {
  val r = implicitly[Read[A]] // Get the class instance of Read for type A
  ss.map(r.read _)
}

The user would probably like a polymorphic method like this for ease of use:

object read {
  def apply[A: Read](s: String): A = implicitly[Read[A]].read(s)
}

Then one can just write:

val person: Person = read[Person]("Person(Bob,42)")

I am not aware of any standard implementation(s) for this type class, in particular.

Also, a disclaimer: I don't have a Scala compiler and haven't used the language for years, so I can't guarantee that this code compiles.

like image 37
dflemstr Avatar answered Sep 20 '22 12:09

dflemstr