companion-object

I'd like to write a type alias to shorten, nice and encapsulated Scala code. Suppose I got some collection which has the property of being a list of maps, the value of which are tuples. My type would write something like List[Map[Int, (String, String)]] , or anything more generic as my application allows it. I could imagine having a supertype asking for a Seq[MapLike[Int, Any]] or whatever floats my boat, with concrete subclasses being more specific. I'd then want to write an alias for this long type. class ConcreteClass { type DataType = List[Map[Int, (String, String)]] ... } I would then

Can I check the value of field in companion object without referring to class' actual object? I'd like to store a static counter, increase it everytime new object of that class is created and be able to check it's value without using object itself, is this possible? Is this what you want? object Foo { private var counter = 0 private def increment = { counter += 1; counter } } class Foo { val i = Foo.increment println(i) } import java.util.concurrent.atomic.AtomicInteger object Foo { val counter = new AtomicInteger(0) } class Foo { val i = Foo.counter.incrementAndGet() println(i) } 来源： https:/

I have a JSON protocol written in spray trait MyJsonProtocol { //some logic } object MyJsonProtocol extends MyJsonProtocol { } Now which is better ?? Importing this companion object or extending the trait ? If you are creating some JsonFormat instances for spray, then you can just create an object directly and import that. This means that you only have a single instance of your implicit vals and objects. object MyJsonProtocol extends DefaultJsonProtocol { implicit object MyTypeJsonFormat extends RootJsonFormat[MyType] { def write(v: MyType): JsValue = ... def read(value: JsValue): MyType = ...

object ScalaTrueRing { def rule = println("To rule them all") } this piece of code will be compiled into java byte code, if I decompile it, then the equivalent Java code is similar to this: public final class JavaTrueRing { public static final void rule() { ScalaTrueRing..MODULE$.rule(); } } /* */ public final class JavaTrueRing$ /* */ implements ScalaObject /* */ { /* */ public static final MODULE$; /* */ /* */ static /* */ { /* */ new (); /* */ } /* */ /* */ public void rule() /* */ { /* 11 */ Predef..MODULE$.println("To rule them all"); /* */ } /* */ /* */ private JavaTrueRing$() /* */ { /*

Using a Scala 2.10/2.11 macro paradise annotation macro, how can I add or extend the companion object of an annotated class? Skeleton: import scala.annotation.StaticAnnotation import scala.reflect.macros._ import language.experimental.macros class foo extends StaticAnnotation { def macroTransform(annottees: Any*) = macro fooMacro.impl } object fooMacro { def impl(c: Context)(annottees: c.Expr[Any]*): c.Expr[Any] = ??? } Such that, given trait Foo[A] the following input @foo class Bar object Baz { def baz = 33 } @foo class Baz will be expanded as: object Bar { implicit def hasFoo: Foo[Bar] = ??