A bottom up approach to category theory: Functors

Contact.scala

case class Contact(name: String, email: String)

Contacts.scala

def byId(id: Long): Option[Contact]
def all: List[Contact]

listMap.scala

def listMap[A, B](f: A => B)(xs: List[A]): List[B] = xs match {
  case Nil => Nil
  case x :: xs => f(x) :: listMap(f)(xs)
}

listMap0.scala

def listMap[A, B](f: A => B, xs: List[A]): List[B] = xs match {
  case Nil => Nil
  case x :: xs => f(x) :: listMap(f, xs)
}

listToJson.scala

def listToJson(contacts: List[Contact]): List[JsObject] = contacts match {
  case Nil => Nil
  case c :: cs =>
    val contactJson = Json.obj(
      "name" -> c.name,
      "email" -> c.email
    )
    contactJson :: listToJson(cs)
}

listToXml.scala

object Application extends Controller {
  def list = Action {
    Ok(<contacts>{ listToXml(Contacts.all) }</contacts>)
  }
  def listToXml(contacts: List[Contact]): List[Node] = contacts match {
    case Nil => Nil
    case c :: cs =>
      val contactXml =
        <contact>
          <name>{ c.name }</name>
          <email>{ c.email }</email>
        </contact>
      contactXml :: listToXml(cs)
  }
}

optionMap.scala

def optionMap[A, B](f: A => B)(maybeA: Option[A]): Option[B] = maybeA match {
  case None => None
  case Some(a) => Some(f(a))
}

read_listAsJson.scala

def listAsJson = Action {
  Ok(Json.toJson(listMap(Contacts.all)(toJson)))
}

def readAsJson(id: Long) = Action {
  optionMap(Contacts.byId(id))(toJson) match {
    case Some(json) => Ok(json)
    case None => NotFound
  }
}

toXml_toJson.scala

def toXml(c: Contact): Node =
  <contact>
    <name>{ c.name }</name>
   <email>{ c.email }</email>
  </contact>

def toJson(c: Contact): JsObject =
  Json.obj(
    "name" -> c.name,
    "email" -> c.email
  )

usingListMap.scala

val listToXml = listMap(toXml) _
val listToJson = listMap(toJson) _