scala-2.10

Can someone explain what the Scala compiler is trying to tell me with the error message below? object Some { def apply[T: ClassTag](data: T)(implicit ordering: Ordering[T]): T = data } object Other { def apply[T: ClassTag](data: T)(implicit ordering: Ordering[T]): T = Some(data)(ordering.reverse) } Compiler says: not enough arguments for method apply: (implicit evidence$2: scala.reflect.ClassTag[T], implicit ordering: Ordering[T])T in object Some. Unspecified value parameter ordering. The error arose when I added the ClassTag to the method in object Some , in order to use some internal arrays

I have a scala macro which outputs nested case classes. I can assemble fragments of expressions created using reify to build up the nested case classes programmatically: case class Foo(name: String) case class Bar(foo: Foo) def foo(name: String) = { c.universe reify { Foo(c.literal(name).splice) } } def bar(foo: Expr[Foo]) = { c.universe reify { Bar(foo.splice) } } // output Bar(Foo("MyFoo")) c.Expr( bar(foo("MyFoo").asInstanceOf[Expr[Foo]]).tree ) Things work well apart from the annoying cast (how can i fix that?). Where I am stuck is when I want the macro to output some case class which

While working with macros, I have reached the point (I have been trying hard to avoid it) where I need to update those nodes in the AST which hold certain condition. For instance, let's say I would like to update each node: Literal(Constant(1)) with the value: Literal(Constant(2)) Those AST nodes could be anywhere in the expression tree, so I cannot use an ad-hoc pattern matcher. Obviously, the last thing I would like to do is to code a full pattern matcher which is able to cover all the compiler primitives. I have been searching in the API but I have the impression that methods such as

I have read several articles expressing that abstract types should be used to achieve f-bounded polymorphism in Scala. This is primarily to alleviate type inference issues, but also to remove the quadratic growth that type parameters seem to introduce when defining recursive types. These are defined as so: trait EventSourced[E] { self => type FBound <: EventSourced[E] { type FBound <: self.FBound } def apply(event: E): FBound } However, this appears to introduce two issues: 1) Each time a user wants to reference an object of this type, they must also refer to the FBound type parameter. This

I am developing a DSL and I am getting a "free term" failure while expanding a macro. I would like to know if it can be avoided. I have simplified the problem to the following situation. Suppose we have this expression: val list = join { 0 1 2 3 } println(list) where join is a macro whose implementation is: def join(c: Ctx)(a: c.Expr[Int]): c.Expr[List[Int]] = { import c.mirror._ a.tree match { case Block(list, ret) => // c.reify(List(new c.Expr(list(0)).eval, // new c.Expr(list(1)).eval, // new c.Expr(list(2)).eval) :+ new c.Expr(ret).eval) c.reify((for (expr <- list) yield new c.Expr(expr)