mpilquist

diff --git a/unitTests/src/test/scala/scodec/examples/TlvExample.scala b/unitTests/src/test/scala/scodec/examples/TlvExample.scala
index 873bf05..b31e727 100644
--- a/unitTests/src/test/scala/scodec/examples/TlvExample.scala
+++ b/unitTests/src/test/scala/scodec/examples/TlvExample.scala
@@ -5,7 +5,7 @@ import scodec.bits._
 import codecs._
 
 class TlvExample extends CodecSuite {
-  // Example of implementing type-length-value encodings using coproducts.
+  // Example of implementing type-length-value encodings.

mpilquist

diff --git a/shared/src/main/scala/scodec/Codec.scala b/shared/src/main/scala/scodec/Codec.scala
index f3086f7..61e3e35 100644
--- a/shared/src/main/scala/scodec/Codec.scala
+++ b/shared/src/main/scala/scodec/Codec.scala
@@ -1,10 +1,10 @@
 package scodec
 
-import shapeless._
-import shapeless.labelled.FieldType
-import shapeless.ops.record._

mpilquist

// Save as ~/.ammonite/predef.sc
// To use fs2 from ammonite repl, type `load.fs2` from repl prompt.
// You'll get all fs2 & cats imports, ContextShift and Timer instances
// for IO, and a globalBlocker

import $plugin.$ivy.`org.typelevel:::kind-projector:0.11.0`

if (!repl.compiler.settings.isScala213)
  repl.load.apply("interp.configureCompiler(_.settings.YpartialUnification.value = true)")

mpilquist

package fs2

import cats.implicits._
import cats.effect.{Resource, Sync}
import cats.effect.concurrent.Ref
import cats.effect.Bracket

final class ResourceProxy[F[_], R](state: Ref[F, Option[(R, F[Unit])]])(
    implicit F: Bracket[F, Throwable]
) {

mpilquist

package scodec.stream.decode

import language.higherKinds

import fs2._
import scodec.{ Attempt, Decoder, DecodeResult, Err }
import scodec.bits.BitVector

trait StreamDecoder3[+A] { self =>

mpilquist

package leopards {

  trait Functor[F[_]] {
    def (fa: F[A]) map[A, B](f: A => B): F[B]
    def (fa: F[A]) void[A]: F[Unit] = fa.map(_ => ())
  }

  delegate for Functor[List] {
    def (fa: List[A]) map[A, B](f: A => B): List[B] =
      fa.map(f)

mpilquist

/* Example of encoding Functor/Applicative/Monad from cats with Dotty 0.15 features.
 * Derived in part from Cats -- see https://github.com/typelevel/cats/blob/master/COPYING for full license & copyright.
 */
package structures

import scala.annotation._

trait Functor[F[_]] {
  def (fa: F[A]) map[A, B](f: A => B): F[B]
  def (fa: F[A]) as[A, B](b: B): F[B] =

mpilquist

-- Unison port of the list index function implemented via state ability (from the Frank Do Be Do Be Do paper)

-- We'll need a collection that supports abilities (Unison's built-in Sequence and Stream are pure)
type List a = nil | cons a (List a)

-- Mapping over a list, polymorphic in ability
lmap : (a -> b) -> List a -> List b
lmap f as = case as of
  List.nil -> List.nil
  List.cons h t -> List.cons (f h) (lmap f t)

mpilquist

// Alternative to sealed abstract case class pattern for Scala 2.12.2+
// Benefits:
//  - 1 final class instead of 1 sealed class + anonymous subclass
//  - portable to Scala 3 regardless of opaque types
//  - less boilerplate

final case class Angle private (toDegrees: Int) {
  // Define our own `copy` method to suppress synthetic one
  // Add private to prevent it from being used
  def copy(degrees: Int = toDegrees): Angle = Angle.fromDegrees(degrees)

mpilquist

➜  scala-2.13.0-M5 ./bin/scala                                                                                                                                 [I]
Welcome to Scala 2.13.0-M5 (OpenJDK 64-Bit Server VM, Java 11.0.1).
Type in expressions for evaluation. Or try :help.

scala> :paste
// Entering paste mode (ctrl-D to finish)

sealed trait Color
case object Red extends Color
case object Blue extends Color