wolfendale

package wolfendale

import shapeless._
import shapeless.labelled._

import scala.util.{Failure, Success, Try}

trait FromStringMap[A] {
  def apply(data: Map[String, String]): Try[A]
}

wolfendale

implicit val booleanFormatter: Formatter[Boolean] = new Formatter[Boolean] {

  override val format = Some(("format.boolean", Nil))

  override def bind(key: String, data: Map[String, String]): Either[Seq[FormError], Boolean] =
    data.get(key) match {
      case Some(value) => value match {
        case "true" => Right(true)
        case "false" => Right(false)
        case _ => Left(Seq(FormError(key, "error.boolean", Nil)))

wolfendale

package forms

import play.api.data.{FormError, Mapping}
import play.api.data.validation.Constraint

case class EitherMapping[L, R](
    lmapping: Mapping[L],
    rmapping: Mapping[R],
    key: String = "",
    constraints: Seq[Constraint[Either[L, R]]] = Nil

wolfendale

      sealed trait Foobar
      case object Foo extends Foobar
      case object Bar extends Foobar

      case class Baz(foo: Boolean = false, bar: Boolean = false)

      implicit val bazMon: Monoid[Baz] =
        new Monoid[Baz] {
          override def zero: Baz = Baz()
          override def append(f1: Baz, f2: => Baz): Baz =

wolfendale

package wolfendale

trait Enum {
  type Value <: Singleton
}

object Enum {
  trait Aux[A <: Singleton] extends Enum { type Value = A }
}

wolfendale

package wolfendale

case class Person(name: String)

object Typeclasses extends App {

  import Show.Showable

  val tuple = (Person("Michael"), Person("Not Michael"))
  val tuple2 = (Person("Michael"), (Person("Not Michael"), Person("Foo")))

wolfendale

package com.example

import javax.inject.Inject

import play.api.i18n.MessagesApi
import play.api.mvc._

import scala.concurrent.Future

// note: `messagesApi` could be anything, it's just quite likely that your controller

wolfendale

Play this game by pasting the script in http://www.puzzlescript.net/editor.html

wolfendale

package wolfendale.scalacheck.regexp.models

sealed trait Group[A] {

  def intersect(other: Group[A]): Group[A]

  def ++(other: Group[A]): Group[A]

  def --(other: Group[A]): Group[A]
}

wolfendale

  implicit lazy val reads: Reads[CarMotor] = {

    import play.api.libs.json._
    import play.api.libs.functional.syntax._

    (__ \ "engineType").read[String].flatMap {
      case "electric" =>
        Reads.pure(Electric)
      case "engine" => {
        (__ \ "fuel").read[CarFuelType] and