Interface for Spotify API I'm trying to make a scala interface to the spotify API. I'm using it to learn Scala. I come from mostly a python background.

import dispatch._, Defaults._

trait Request {
  val name: String
  val endpoint: String
}

case class Track(name: String) extends Request {
  override val endpoint = "track.json"
}

case class Album(name: String) extends Request {
  override val endpoint = "album.json"
}

case class Artist(name: String) extends Request {
  override val endpoint = "artist.json"
}

object Spotify {

  def getResponse(req: Request) = {
    val params = Map("q" -&gt; req.name)
    val spotifyUrl = host("ws.spotify.com")

    spotifyUrl / "search"/ "1" / req.endpoint &lt;&lt;? params

  }

  val foo = Album("foo")
  val songs = Http(getResponse(foo) OK as.String)

}


I feel like getResponse should be in the Request trait, or something since it's generic enough to only need the overridden endpoint - but not sure.
Any general recommendations on structuring this sort of thing would be helpful.
Decouple everything.

I am certain that Scala veterans will have more to say than I do and possibly comment over my comments.

Here are some changes and respective comments to your code.

import dispatch._, Defaults._

// decouple from any "master" class.
case class Track(name: String)

case class Album(name: String)

case class Artist(name: String)

// This is called a structural type. We are using a def
// because a val restricts extensibility.
type Named = {def name: String}

// Separate out the endpoints into their own category
object endpointResolver {

  // Use a partial function which you can re-use in order parts
  // of your program. You may use this in your testing as well.
  val endPoints: PartialFunction[Named, String] = {
    case _: Track =&gt; "track.json"
    case _: Album =&gt; "album.json"
    case _: Artist =&gt; "artist.json"
  }

  // use an implicit class. This allows you to add methods
  // to existing classes seamlessly.
  implicit class nrEndpoint(namedRequest: Named) {
    def endpoint: String =
      endPoints apply namedRequest
  }

}

object Spotify {

  // Specify the return type. I was not sure what it was initially.
  def getResponse(req: Named): Req = {

    val params = Map("q" -&gt; req.name)

    val spotifyUrl = host("ws.spotify.com")

    // import and utilise this implicit class
    import endpointResolver.nrEndpoint

    spotifyUrl / "search"/ "1" / req.endpoint &lt;&lt;? params

  }

  val foo = Album("foo")

  // OK is another example of an implicit being used. Use an IDE
  // such as IntelliJ IDEA to navigate through the vast depths
  // of Scala source.
  val songs = Http(getResponse(foo) OK as.String)

}