A sealed trait can be extended only in the same file as its declaration. They are often used to provide an alternative to enums. Since they can be only extended in a single file, the compiler knows every possible subtypes and can reason about it. For instance with the declaration: sealed trait Answer case object … Read more
A TypeTag solves the problem that Scala’s types are erased at runtime (type erasure). If we wanna do class Foo class Bar extends Foo def meth[A](xs: List[A]) = xs match { case _: List[String] => “list of strings” case _: List[Foo] => “list of foos” } we will get warnings: <console>:23: warning: non-variable type argument … Read more
This answer uses the Manifest-API, which is deprecated as of Scala 2.10. Please see answers below for more current solutions. Scala was defined with Type Erasure because the Java Virtual Machine (JVM), unlike Java, did not get generics. This means that, at run time, only the class exists, not its type parameters. In the example, … Read more
Legacy. List was originally defined to be functional-languages-looking: 1 :: 2 :: Nil // a list list1 ::: list2 // concatenation of two lists list match { case head :: tail => “non-empty” case Nil => “empty” } Of course, Scala evolved other collections, in an ad-hoc manner. When 2.8 came out, the collections were … Read more
I can think of two differences Abstract classes can have constructor parameters as well as type parameters. Traits can have only type parameters. There was some discussion that in future even traits can have constructor parameters Abstract classes are fully interoperable with Java. You can call them from Java code without any wrappers. Traits are … Read more
It is predominately used for Dependency Injection, such as in the Cake Pattern. There exists a great article covering many different forms of dependency injection in Scala, including the Cake Pattern. If you Google “Cake Pattern and Scala”, you’ll get many links, including presentations and videos. For now, here is a link to another question. … Read more
Types of Implicits Implicits in Scala refers to either a value that can be passed “automatically”, so to speak, or a conversion from one type to another that is made automatically. Implicit Conversion Speaking very briefly about the latter type, if one calls a method m on an object o of a class C, and … Read more
I divide the operators, for the purpose of teaching, into four categories: Keywords/reserved symbols Automatically imported methods Common methods Syntactic sugars/composition It is fortunate, then, that most categories are represented in the question: -> // Automatically imported method ||= // Syntactic sugar ++= // Syntactic sugar/composition or common method <= // Common method _._ // … Read more
In the usual encoding an enumerator is essentially a StepT[E, F, ?] ~> F[StepT[E, F, ?]]. If you try to write a generic method converting this type into a Step[E, G, ?] ~> G[Step[E, G, ?]] given an F ~> G, you’ll quickly run into an issue: you need to “lower” a Step[E, G, A] … Read more
Case classes can be seen as plain and immutable data-holding objects that should exclusively depend on their constructor arguments. This functional concept allows us to use a compact initialization syntax (Node(1, Leaf(2), None))) decompose them using pattern matching have equality comparisons implicitly defined In combination with inheritance, case classes are used to mimic algebraic datatypes. … Read more