Documentation example is not compiling (ADT, ShapesDerivation)

Hello! I am trying to compile the following example. https://circe.github.io/circe/codecs/adt.html

sealed trait Event

case class Foo(i: Int) extends Event
case class Bar(s: String) extends Event
case class Baz(c: Char) extends Event
case class Qux(values: List[String]) extends Event

Precisely I want to use ShapesDerivation, like here:

import io.circe._ // no such line in example, but had to import it
object ShapesDerivation {
  import io.circe.shapes // not used actually
  import shapeless.{ Coproduct, Generic }

  implicit def encodeAdtNoDiscr[A, Repr <: Coproduct](implicit
    gen: Generic.Aux[A, Repr],
    encodeRepr: Encoder[Repr]
  ): Encoder[A] = encodeRepr.contramap(gen.to)

  implicit def decodeAdtNoDiscr[A, Repr <: Coproduct](implicit
    gen: Generic.Aux[A, Repr],
    decodeRepr: Decoder[Repr]
  ): Decoder[A] = decodeRepr.map(gen.from)

}

Didn’t use or write previous GenericDerivation, so no really need to suppress imports?

And this example

import ShapesDerivation._
import io.circe.parser.decode, io.circe.syntax._
decode[Event]("""{ "i": 1000 }""")
(Foo(100): Event).asJson.noSpaces

Doesn’t compile on line decode[Event]("""{ "i": 1000 }"""), gives two errors:

could not find implicit value for evidence parameter of type io.circe.Decoder[com.example.Event]

and

could not find implicit value for parameter encoder: io.circe.Encoder[com.example.Event]

What else do I need? 🤔 Or may be documentation is a bit out of date?

Version if all libraries I use is 0.11.1.

[travisbrown]

Here’s the minimization that works as expected:

sealed trait Event

case class Foo(i: Int) extends Event
case class Bar(s: String) extends Event
case class Baz(c: Char) extends Event
case class Qux(values: List[String]) extends Event

import io.circe.{ Decoder, Encoder }
import io.circe.generic.auto._, io.circe.shapes._

object ShapesDerivation {
  import shapeless.{ Coproduct, Generic }

  implicit def encodeAdtNoDiscr[A, Repr <: Coproduct](implicit
    gen: Generic.Aux[A, Repr],
    encodeRepr: Encoder[Repr]
  ): Encoder[A] = encodeRepr.contramap(gen.to)

  implicit def decodeAdtNoDiscr[A, Repr <: Coproduct](implicit
    gen: Generic.Aux[A, Repr],
    decodeRepr: Decoder[Repr]
  ): Decoder[A] = decodeRepr.map(gen.from)
}

import ShapesDerivation._

io.circe.parser.decode[Event]("""{ "i": 1000 }""")

[chrisalbright]

@travisbrown I’ll put together some gists and post here. Thanks again.