diffx-core/com.softwaremill.diffx

com.softwaremill.diffx

package com.softwaremill.diffx

Type members

Classlikes

final case class Derived[T](value: T) extends AnyVal
trait Diff[T] extends DiffMacro[T]
Companion:
object
object Diff extends LowPriorityDiff with DiffTupleInstances with DiffxPlatformExtensions with DiffCompanionMacro
Companion:
class
trait DiffCompanionMacro extends DiffMagnoliaDerivation
case class DiffConfiguration(makeIgnored: Diff[Any] => Diff[Any])
Companion:
object
object DiffConfiguration
Companion:
class
case class DiffContext(overrides: Tree[Diff[Any] => Diff[Any]], path: List[ModifyPath], matcherOverrides: Tree[ObjectMatcher[_]])
Companion:
object
object DiffContext
Companion:
class
case class DiffLens[T, U](outer: Diff[T], path: List[ModifyPath])
final class DiffLensMapMatchByOps[C[_, _], K, V, S](lens: DiffLens[S, C[K, V]])
final class DiffLensSeqMatchByOps[C[_], T, S](lens: DiffLens[S, C[T]])
final class DiffLensSetMatchByOps[C[_], T, S](lens: DiffLens[S, C[T]])
trait DiffLensToMapMatchByOps
trait DiffLensToMatchByOps extends DiffLensToMapMatchByOps with DiffLensToSetMatchByOps with DiffLensToSeqMatchByOps
trait DiffLensToSeqMatchByOps
trait DiffLensToSetMatchByOps
trait DiffMacro[T]
final class DiffMapMatchByOps[C[_, _], K, V](diff: Diff[C[K, V]])
sealed trait DiffResult extends Product with Serializable
Companion:
object
object DiffResult
Companion:
class
case class DiffResultAdditional[T](value: T) extends DiffResult
case class DiffResultAdditionalChunk(value: String) extends DiffResult
case class DiffResultChunk(left: String, right: String) extends DiffResult
case class DiffResultIterable(typename: String, items: Map[String, DiffResult]) extends DiffResult
case class DiffResultMap(typename: String, entries: Map[DiffResult, DiffResult]) extends DiffResult
case class DiffResultMissing[T](value: T) extends DiffResult
case class DiffResultMissingChunk(value: String) extends DiffResult
case class DiffResultObject(name: String, fields: Map[String, DiffResult]) extends DiffResult
object DiffResultPrinter
case class DiffResultSet(typename: String, diffs: Set[DiffResult]) extends DiffResult
case class DiffResultString(diffs: List[DiffResult]) extends DiffResult
case class DiffResultStringLine(diffs: List[DiffResult]) extends DiffResult
case class DiffResultStringWord(diffs: List[DiffResult]) extends DiffResult
trait DiffResultTransformer
Companion:
object
object DiffResultTransformer
Companion:
class
case class DiffResultValue[T](left: T, right: T) extends DiffResult
final class DiffSeqMatchByOps[C[_], T](diff: Diff[C[T]])
final class DiffSetMatchByOps[C[_], T](diff: Diff[C[T]])
trait DiffToMapMatchByOps
trait DiffToMatchByOps extends DiffToMapMatchByOps with DiffToSetMatchByOps with DiffToSeqMatchByOps
trait DiffToSeqMatchByOps
trait DiffToSetMatchByOps
trait DiffTupleInstances
implicit class DiffxEachMap[F[_, _], K, V](t: F[K, V])(implicit fac: Factory[(K, V), F[K, V]])
trait DiffxEitherSupport
trait DiffxOptionSupport
trait DiffxPlatformExtensions
trait DiffxSupport extends DiffxEitherSupport with DiffxOptionSupport with DiffLensToMatchByOps with DiffToMatchByOps
Companion:
object
object DiffxSupport
Companion:
class
case class IdenticalValue[T](value: T) extends DiffResult
trait LowPriorityDiff
trait LowPriorityObjectMatcher
trait MapLike[C[_, _]]
Companion:
object
object MapLike
Companion:
class
object ModifyMacro
sealed trait ModifyPath extends Product with Serializable
Companion:
object
object ModifyPath
Companion:
class
trait ObjectMatcher[T]

Defines how the elements within collections are paired

Defines how the elements within collections are paired

Type parameters:
T

type of the collection element

Companion:
object
object ObjectMatcher extends LowPriorityObjectMatcher
Companion:
class
trait SeqLike[C[_]]
Companion:
object
object SeqLike
Companion:
class
trait SetLike[C[_]]
Companion:
object
object SetLike
Companion:
class
case class ShowConfig(left: String => String, right: String => String, missing: String => String, additional: String => String, default: String => String, arrow: String => String, transformer: DiffResultTransformer)
Companion:
object
object ShowConfig
Companion:
class
sealed trait Tree[T]
Companion:
object
object Tree
Companion:
class

Inherited classlikes

implicit class DiffxEach[F[_], T](t: F[T])(implicit f: DiffxFunctor[F, T])
Inherited from:
DiffxOptionSupport
implicit class DiffxEither[T[_, _], L, R](e: T[L, R])(implicit f: DiffxEitherFunctor[T, L, R])
Inherited from:
DiffxEitherSupport
trait DiffxEitherFunctor[T[_, _], L, R]
Inherited from:
DiffxEitherSupport
trait DiffxFunctor[F[_], A]
Inherited from:
DiffxOptionSupport
trait DiffxSubtypeSelector[T]
Inherited from:
DiffxSupport

Inherited types

type FieldPath = List[String]
Inherited from:
DiffxSupport
type MapMatcher[K, V] = ObjectMatcher[MapEntry[K, V]]
Inherited from:
DiffxSupport
type SeqMatcher[T] = ObjectMatcher[SeqEntry[T]]
Inherited from:
DiffxSupport
type SetMatcher[T] = ObjectMatcher[SetEntry[T]]
Inherited from:
DiffxSupport

Value members

Inherited methods

def compare[T](left: T, right: T)(implicit d: Diff[T]): DiffResult
Inherited from:
DiffxSupport

Implicits

Implicits

final implicit def DiffxEachMap[F[_, _], K, V](t: F[K, V])(implicit fac: Factory[(K, V), F[K, V]]): DiffxEachMap[F, K, V]
implicit def traversableDiffxFunctor[F[_], A](implicit fac: Factory[A, F[A]], ev: F[A] => Iterable[A]): DiffxFunctor[F, A]

Inherited implicits

final implicit def DiffxEach[F[_], T](t: F[T])(implicit f: DiffxFunctor[F, T]): DiffxEach[F, T]
Inherited from:
DiffxOptionSupport
final implicit def DiffxEither[T[_, _], L, R](e: T[L, R])(implicit f: DiffxEitherFunctor[T, L, R]): DiffxEither[T, L, R]
Inherited from:
DiffxEitherSupport
implicit def eitherDiffxFunctor[T[_, _], L, R]: DiffxEitherFunctor[Either, L, R]
Inherited from:
DiffxEitherSupport
implicit def lensToMapMatchByOps[C[_, _] : MapLike, K, V, S](diffLens: DiffLens[S, C[K, V]]): DiffLensMapMatchByOps[C, K, V, S]
implicit def lensToSeqMatchByOps[C[_] : SeqLike, T, S](diffLens: DiffLens[S, C[T]]): DiffLensSeqMatchByOps[C, T, S]
implicit def lensToSetMatchByOps[C[_] : SetLike, T, S](diffLens: DiffLens[S, C[T]]): DiffLensSetMatchByOps[C, T, S]
implicit def optionDiffxFunctor[A]: DiffxFunctor[Option, A]
Inherited from:
DiffxOptionSupport
implicit def toMapMatchByOps[C[_, _] : MapLike, K, V](diff: Diff[C[K, V]]): DiffMapMatchByOps[C, K, V]
Inherited from:
DiffToMapMatchByOps
implicit def toSeqMatchByOps[C[_] : SeqLike, T, S](diff: Diff[C[T]]): DiffSeqMatchByOps[C, T]
Inherited from:
DiffToSeqMatchByOps
implicit def toSetMatchByOps[C[_] : SetLike, T](diff: Diff[C[T]]): DiffSetMatchByOps[C, T]
Inherited from:
DiffToSetMatchByOps
implicit def toSubtypeSelector[A](a: A): DiffxSubtypeSelector[A]
Inherited from:
DiffxSupport