This is a fundamental feature of object-oriented programming that doesn’t get as much attention as it deserves. Suppose you have a collection C[+T]. What the +T means is that if U <: T, then C[U] <: C[T]. Fair enough. But what does it mean to be a subclass? It means that every method should work … Read more
Note that this can be done much more elegantly without the toString / c.parse business: import scala.language.experimental.macros abstract class Model { def toMap[T]: Map[String, Any] = macro Macros.toMap_impl[T] } object Macros { import scala.reflect.macros.Context def toMap_impl[T: c.WeakTypeTag](c: Context) = { import c.universe._ val mapApply = Select(reify(Map).tree, newTermName(“apply”)) val pairs = weakTypeOf[T].declarations.collect { case m: MethodSymbol … Read more
It is really easy to accidentally use a no-arg case class incorrectly as a pattern. scala> case class Foo warning: there were deprecation warnings; re-run with -deprecation for details defined class Foo scala> (new Foo: Any) match { case Foo => true; case _ => false } res10: Boolean = false Instead of: scala> (new … Read more
Define the case class so that the second member is a var: case class Stuff(name: String, var value: Option[String]) Now you can create an instance of Stuff and modify the second value: val s = Stuff(“bashan”, None) s.value = Some(“hello”) However, making case classes mutable is probably not a good idea. You should prefer working … Read more
from Java, say: my.awesome.package.PressureSensor$.MODULE$
This can be done with macros (that are officially a part of Scala since 2.10.0-M3). Here’s a gist example of what you are looking for. 1) My macro generates a local class that inherits from the provided case class and Persisted, much like new T with Persisted would do. Then it caches its argument (to … Read more
The reason why case class companion objects implement FunctionN is that before, case classes generated a class and a factory method, not a companion object. When we added extractors to Scala it made more sense to turn the factory method into a full companion object with apply and unapply methods. But then, since the factory … Read more
This is an expected behavior because of how case class works. case class automatically extends two traits, namely Product and Serializable. Product trait is extended as case class is an algebraic data type with product type. Serializable trait is extended so that case class can be treated as a pure data – i.e capable of … Read more
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 JSON4s JSON4s is quite mature and supports jackson or a native JSON-Parser. Used it in many projects to replace jerkson. https://github.com/json4s/json4s play-json Can be used without the full play stack. Great support … Read more
Here’s the technique to have a private constructor and a public apply method. trait Meter { def m: Int } object Meter { def apply(m: Int): Meter = { MeterImpl(m) } private case class MeterImpl(m: Int) extends Meter { println(m) } } object Application extends App { val m1 = new Meter(10) // Forbidden val … Read more