MacroUtils

object MacroUtils
class Object
trait Matchable
class Any

Type members

Types

type Fn2Clause[A, B, X] = Quotes ?=> (Expr[A], Expr[B]) => Expr[X]

Value members

Concrete methods

def extractCaseDefs[T, V](e: Expr[T => V])(using q: Quotes): List[CaseDef]
def extractInlineAdtMappingFn[T, V](e: Expr[T => V])(using q: Quotes): List[(Either[Ref, TypeTree], Term)]
def getSingletonValueForType[A : Type](implicit evidence$1: Type[A], Quotes): Option[Expr[A]]
def logAll[A](name: String, as: Iterable[A])(f: A => Any): Unit
def mapByFieldTypes[A : Type, B](f: [C] => (x$1: Type[C]) => B)(implicit evidence$8: Type[A], q: Quotes): Map[TypeRepr, B]
def mergeFn2s[A, B, X, Y](fs: Seq[(A, B) ?=> X], empty: => Either[Expr[X], Expr[Y]], outer: ((A, B) ?=> X) => Expr[Y], merge: (X, X) ?=> X): Expr[Y]
def mkAnonymousMatch[A : Type, B : Type](using q: Quotes)(cases: Seq[CaseDef]): Expr[A => B]
def mkArrayExpr[A : Type](as: Seq[Expr[A]])(implicit evidence$4: Type[A], Quotes): Expr[Array[A]]
def mkArrayExprF[F[_] : Type, A](as: Seq[Expr[F[A]]])(implicit evidence$5: Type[F], Quotes): Expr[Array[F[Any]]]
def mkVectorExpr[A : Type](as: Seq[Expr[A]])(implicit evidence$6: Type[A], Quotes): Expr[Vector[A]]
def mkVectorExprF[F[_] : Type, A](as: Seq[Expr[F[A]]])(implicit evidence$7: Type[F], Quotes): Expr[Vector[F[Any]]]
def needGiven[A : Type](implicit evidence$2: Type[A], Quotes): Expr[A]
def needGivensInTuple[A : Type](implicit evidence$3: Type[A], Quotes): List[Expr[Any]]
def needSingletonValueForType[A](using Type[A])(using Quotes): Expr[A]
def reduceSeq[A, B](as: Seq[A], empty: => B, one: A => B, many: Seq[A] => B): B
def setOfFieldTypes[A : Type](implicit evidence$9: Type[A], q: Quotes): Set[TypeRepr]
def showUnorderedTypes(using q: Quotes)(ts: Set[TypeRepr]): String
def withNonEmptySumTypeTypes[A, B](a: Type[A])(f: [t] => (x$1: Type[t]) => B)(using Quotes): B

Exports

Defined exports

final val CachedGivens: CachedGivens.type
Exported from compiletime
final val NewInstance: NewInstance.type
Exported from compiletime