Question

I am struggling with a Scala implicit conversion problem. The following code snippet illustrates my problem :

import org.junit.{ Test, Before, After };

class ImplicitsTest {

    implicit def toStringWrapper(str: String) = new StringWrapper(str);

    @Test
    def test(){
        val res1: Predicate = "str" startsWith "other";
    }

}

class StringWrapper(str: String){

    def startsWith(other: String): Predicate = null;

}

trait Predicate

How can I force the String literal “str” to be converted through the implicit conversion toStringWrapper to get startsWith return Predicate instead of Boolean?

The code example doesn’t compile. I am aware that String has already a startsWith method, I just want to use a different one, and I thought that using implicit conversions might be a way to do it.

Answer 1

Scala thankfully doesn’t let you sneak replacement methods in without you noticing–if you call a method on a class, and the class has that method, that’s the method call you get. To do otherwise would likely cause all sorts of confusion.

That leaves you with two other options:
(1) Rename the method
(2) Add a specific method to do the conversion.

The second approach works like so: you define a class that has both the method that you want and a uniquely-named method that returns itself, and optionally an implicit conversion from that class back to string if you want to be able to use the custom item like the original string (as if it had extended String):

object ImplicitExample {
  class CustomString(s: String) {
    def original = s
    def custom = this
    def startsWith(other: String): Int = if (s.startsWith(other)) 1 else 0
  }
  implicit def string_to_custom(s: String) = new CustomString(s)
  implicit def custom_to_string(c: CustomString) = c.original

  def test = {
    println("This".custom.startsWith("Thi"))
    println("This".custom.length())
  }
}

scala> ImplicitExample.test
1
4

scala>