scala-2.10

For example, I want to create the following query: SELECT c.* FROM Coffees c WHERE c.name IN ('robusta', 'arabica') My attempt failed: val cnames = List("robusta", "arabica") sql""" SELECT c.* FROM Coffees c WHERE c.name IN ${cnames} """ could not find implicit value for parameter pconv: scala.slick.jdbc.SetParameter[List[String]] Is it possible to somehow use in clause in Slick plain sql queries? I don't see anything out of the box to handle this. You're best bet is probably something like this: val cnames = List("robusta", "arabica").map("'" + _ + "'").mkString(",") val query = sql""" SELECT

Is there a method in Akka (or in the standard library in Scala 2.10) to convert a Future[A] which might fail into a Future[Either[Exception,A]] ? I know that you can write f.map(Right(_)).recover { case e:Exception => Left(e) } It just seems to be such a common task that I wonder whether I have overlooked something. I'm interested in answers for Scala 2.9/Akka and Scala 2.10. The primary reason why this method is missing is that it does not really have good semantics: the static type Future[Either[Throwable, T]] does not ensure that that future cannot fail, hence the type change does not gain

Given a string of JSON, and a case class that corresponds to it, what's a simple way to parse the JSON into the case class? There are many libraries available, but it seems that Scala might now do this out of the box. What about if the JSON should be parsed into a list of the case class? UPDATE: Jerkson seems to be abandoned, and I don't want to install the full Play or Lift framework or anything else heavy. There are several frameworks which can exactly do that. circe Used a lot nowdays. Many great features. Will pull cats in. https://circe.github.io/circe/ https://github.com/circe/circe

Possible Duplicate: Scala 2.10: What is a TypeTag and how do I use it? I have been reading about the new TypeTags which come along with the new reflection api. It seems that Manifests are supposed to be replaced with that new concept. Can anyone post some code examples to show the benefits? Some references: TypeTags API SIP: Self-cleaning macros Metaprogramming in Scala Manifests are a lie. It has no knowledge of variance (assumes all type parameters are co-variants), and it has no support for path-dependent, existential or structural types. TypeTags are types as the compiler understands them

I'll start with an example. Here's an equivalent of List.fill for tuples as a macro in Scala 2.10: import scala.language.experimental.macros import scala.reflect.macros.Context object TupleExample { def fill[A](arity: Int)(a: A): Product = macro fill_impl[A] def fill_impl[A](c: Context)(arity: c.Expr[Int])(a: c.Expr[A]) = { import c.universe._ arity.tree match { case Literal(Constant(n: Int)) if n < 23 => c.Expr( Apply( Select(Ident("Tuple" + n.toString), "apply"), List.fill(n)(a.tree) ) ) case _ => c.abort( c.enclosingPosition, "Desired arity must be a compile-time constant less than 23!" ) }