semi

allows semi automatically derive each instance. The derivation might need help when there are fields with type constructor that comes with instances e.g.

scala> case class Foo(bars: List[Bar])
scala> case class Bar(a: String)

scala> cats.derived.semi.show[Foo].show(Foo(List(Bar("a"))))
res1: String = Foo(bars = $colon$colon(head = Bar(a = a), tl$access$1 = Nil.type()))

Note that semi.show didn't respect the native Show[List] instance

You could either derive a Bar instance first

scala> implicit val barShow = cats.derived.semi.show[Bar]

scala> cats.derived.semi.show[Foo].show(Foo(List(Bar("a"))))
res2: String = Foo(bars = List(Bar(a = a)))

Or you can take advantage of a controlled auto derivation

 scala> implicit val fooShow: Show[Foo] = { |
           import cats.derived.auto.show._  |
           cats.derived.semi.show           |
        }
scala> Foo(List(Bar("a"))).show
res3: String = Foo(bars = List(Bar(a = a)))

Linear Supertypes

AnyRef, Any

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def applicative[F[_]](implicit F: Lazy[MkApplicative[F]]): Applicative[F]
def apply[F[_]](implicit F: Lazy[MkApply[F]]): Apply[F]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def consK[F[_]](implicit F: Lazy[MkConsK[F, F]]): ConsK[F]
def empty[A](implicit ev: Lazy[MkEmpty[A]]): Empty[A]
def emptyK[F[_]](implicit F: Lazy[MkEmptyK[F]]): EmptyK[F]
def eq[A](implicit ev: Lazy[MkEq[A]]): Eq[A]
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def foldable[F[_]](implicit F: Lazy[MkFoldable[F]]): Foldable[F]
def functor[F[_]](implicit F: Lazy[MkFunctor[F]]): Functor[F]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hash[A](implicit ev: Lazy[MkHash[A]]): Hash[A]
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def iterable[F[_], A](fa: F[A])(implicit F: MkIterable[F]): Iterable[A]
def monoid[A](implicit ev: Lazy[MkMonoid[A]]): Monoid[A]
def monoidK[F[_]](implicit F: Lazy[MkMonoidK[F]]): MonoidK[F]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def order[A](implicit ev: Lazy[MkOrder[A]]): Order[A]
def partialOrder[A](implicit ev: Lazy[MkPartialOrder[A]]): PartialOrder[A]
def pure[F[_]](implicit F: Lazy[MkPure[F]]): Pure[F]
def semigroup[T](implicit ev: Lazy[MkSemigroup[T]]): Semigroup[T]
def semigroupK[F[_]](implicit F: Lazy[MkSemigroupK[F]]): SemigroupK[F]
def show[A](implicit ev: Lazy[MkShow[A]]): Show[A]
def showPretty[A](implicit ev: Lazy[MkShowPretty[A]]): ShowPretty[A]
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def traverse[F[_]](implicit F: Lazy[MkTraverse[F]]): Traverse[F]
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Doc: package derived

object semi

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def applicative[F[_]](implicit F: Lazy[MkApplicative[F]]): Applicative[F]

def apply[F[_]](implicit F: Lazy[MkApply[F]]): Apply[F]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def consK[F[_]](implicit F: Lazy[MkConsK[F, F]]): ConsK[F]

def empty[A](implicit ev: Lazy[MkEmpty[A]]): Empty[A]

def emptyK[F[_]](implicit F: Lazy[MkEmptyK[F]]): EmptyK[F]

def eq[A](implicit ev: Lazy[MkEq[A]]): Eq[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def foldable[F[_]](implicit F: Lazy[MkFoldable[F]]): Foldable[F]

def functor[F[_]](implicit F: Lazy[MkFunctor[F]]): Functor[F]

final def getClass(): Class[_]

def hash[A](implicit ev: Lazy[MkHash[A]]): Hash[A]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def iterable[F[_], A](fa: F[A])(implicit F: MkIterable[F]): Iterable[A]

def monoid[A](implicit ev: Lazy[MkMonoid[A]]): Monoid[A]

def monoidK[F[_]](implicit F: Lazy[MkMonoidK[F]]): MonoidK[F]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def order[A](implicit ev: Lazy[MkOrder[A]]): Order[A]

def partialOrder[A](implicit ev: Lazy[MkPartialOrder[A]]): PartialOrder[A]

def pure[F[_]](implicit F: Lazy[MkPure[F]]): Pure[F]

def semigroup[T](implicit ev: Lazy[MkSemigroup[T]]): Semigroup[T]

def semigroupK[F[_]](implicit F: Lazy[MkSemigroupK[F]]): SemigroupK[F]

def show[A](implicit ev: Lazy[MkShow[A]]): Show[A]

def showPretty[A](implicit ev: Lazy[MkShowPretty[A]]): ShowPretty[A]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def traverse[F[_]](implicit F: Lazy[MkTraverse[F]]): Traverse[F]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped