macroUtils/japgolly.microlibs.macro_utils/MacroUtils

MacroUtils

object MacroUtils
class Object
trait Matchable
class Any

Type members

Classlikes

object ExprSet
Companion
class
final class ExprSet[A](using `x$1`: Quotes)
Companion
object
trait Field
object Ops
final case class TypeClassForSumBuilder[-A, +F](ordinal: Expr[A] => Expr[Int], tc: Expr[Int] => Expr[F])

Types

type FieldLookup[F[_]] = Field => Expr[Any] { def apply(f: Field): Expr[F[Type]]; }
type Fn2Clause[A, B, X] = Quotes => (Expr[A], Expr[B]) => Expr[X]

Value members

Concrete methods

def buidTypeClassForSum[F[_], A](m: Expr[SumOf[A]])(f: TypeClassForSumBuilder[A, F[Any]] => Expr[F[A]])(`evidence$12`: Type[F], `evidence$13`: Type[A], Quotes): Expr[F[A]]
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)]
inline def fail(msg: String)(using Quotes): Nothing
def getSingletonValueForType[A](`evidence$1`: Type[A], Quotes): Option[Expr[A]]
def logAll[A](name: String, as: Iterable[A])(f: A => Any): Unit
def mapByFieldTypes[A, B](f: [C] => (x$1: Type[C]) => B)(`evidence$7`: 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 mirrorFields[A, B](m: Expr[Of[A]])(`evidence$6`: Type[A], Quotes): List[Field]
def mkAnonymousMatch[A, B](using q: Quotes)(cases: Seq[CaseDef])(`evidence$14`: Type[A], `evidence$15`: Type[B]): Expr[A => B]
def mkArrayExpr[A](as: Seq[Expr[A]])(`evidence$4`: Type[A], Quotes): Expr[Array[A]]
def mkArrayExprF[F[_], A](as: Seq[Expr[F[A]]])(`evidence$5`: Type[F], Quotes): Expr[Array[F[Any]]]
def needGiven[A](`evidence$2`: Type[A], Quotes): Expr[A]
def needGivensInTuple[A](`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](`evidence$8`: Type[A], q: Quotes): Set[TypeRepr]
def showUnorderedTypes(using q: Quotes)(ts: Set[TypeRepr]): String
def withCachedGivens[A, F[_], B](m: Expr[Of[A]])(use: () => F => Expr[B])(`evidence$9`: Type[A], `evidence$10`: Type[F], `evidence$11`: Type[B], Quotes): Expr[B]
def withNonEmptySumTypeTypes[A, B](a: Type[A])(f: [t] => (x$1: Type[t]) => B)(using Quotes): B