Implementing a Scala trait by passing functions as arguments

Question

Say we have a Scala trait

trait Foo {
  def bar(baz: Qux): Quux
  def corge: Grault
}

and we want to implement it in such a way that the implementation of bar() can be handled by an anonymous function. We can do this:

class FooImpl1(_bar: (Qux) => Quux, val corge: Grault) extends Foo {
  override def bar(baz: Qux) = { _bar(baz) }
}

allowing, e.g.:

val foo: Foo = new FooImpl({ qux: Qux => qux.asQuux()}, someGrault)

But this seems unnecessarily verbose (and also introduces the dreaded, and clunky, leading underscore).

Naively, noting that def corge in Foo is implemented by val corge in FooImpl1, it seems it should be possible to do something like this:

class FooImpl2(val bar: (Qux) => Quux, val corge: Grault) extends Foo {}

But we can't, presumably because Foo.bar doesn't return a function, it is a function (or rather a method).

Is there anything cleaner than FooImpl1 that we can do here?

n0741337 · Accepted Answer · 2014-03-21 06:50:32Z

1

If you have control of the trait, you could try modifying it instead:

trait Foo {
  val bar: Function1[Qux, Quux]
  def corge: Grault
}

which makes your FooImpl2 definition possible. Here's an example from an Eclipse ScalaWorksheet:

package so

object ClassExperiment {
  type Qux = Int
  type Quux = Boolean
  type Grault = String

  trait Foo {
    val bar: Function1[Qux, Quux]
    def corge: Grault
  }

  class FooImpl2(val bar: (Qux) => Quux, val corge: Grault) extends Foo {
    def blue = bar( 9 )
  }

  val foo = new FooImpl2( { a: Qux => a == 4 }, new Grault("monkey") )
                                                  //> foo  : so.ClassExperiment.FooImpl2 = so.ClassExperiment$FooImpl2@68f
                                                  //| e748f

  foo.blue                                        //> res0: so.ClassExperiment.Quux = false
  foo.bar( 4 )                                    //> res1: so.ClassExperiment.Quux = true
  foo.bar( 7 )                                    //> res2: so.ClassExperiment.Quux = false
  foo.corge                                       //> res3: so.ClassExperiment.Grault = monkey
}

I left off the Foo type specifier when creating foo so I could show the call output to blue.

answered Mar 21, 2014 at 6:50

n0741337

2,5242 gold badges16 silver badges17 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

David Moles Over a year ago

In the general case it's more likely that implementations are just going to implement the method.

reggert · Accepted Answer · 2014-03-21 01:33:13Z

0

Why not just do this?

val foo = new Foo { 
   def bar(qux : Qux) = qux.asQuux 
   val corge = someGrault
}

It doesn't seem like defining a FooImpl class really buys you anything.

answered Mar 21, 2014 at 1:33

reggert

8424 silver badges10 bronze badges

2 Comments

millhouse Over a year ago

He wants to be able to specify the behaviour of bar() separately from the construction of the class

David Moles Over a year ago

It's a toy example. IRL it's obviously not worth doing unless you have multiple implementations.

Collectives™ on Stack Overflow

Implementing a Scala trait by passing functions as arguments

2 Answers 2

1 Comment

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related