Meta

args

args : TypeRepr -> Items TypeReprSource

The arguments a type application applies, in order.

arrow

arrow : TypeRepr -> ArrowSource

Decomposes a function arrow. A curried function is an arrow whose result is another arrow, each with its own row.

import Meta exposing (Arrow(..))

resultIsString =
    $(Meta.lift
        (case Meta.arrow (typeOf (Int -> String)) of
            Arrow parts -> Meta.sameType parts.result (typeOf String)
            NotArrow -> False))

resultIsString

attributes

attributes : Type a -> Attributes -> Items (Attached a)Source

The attributes in a collection whose type is exactly a, type arguments included, in source order. Collections follow reflection visibility: an opaque import hides a type’s metadata.

construct

construct : Ctor -> Items Code -> CodeSource

construct is the other direction, for a method that produces an a.

ctorsIn

ctorsIn : TypeInfo -> Items CtorSource

ctorsIn flattens the two shapes: a record is a single constructor whose fields carry names.

declaredType

declaredType : Code -> TypeReprSource

The declared type of a quoted top-level name. Its quantified type and row variables stay variables, so isVar and sameType can relate them; its schemas are visible as they are where the quote was written. Reading a declaration that is still being checked, or code that is not a reference, stops compilation.

fail

fail : String -> CodeSource

fail stops expansion and reports COMPILE-TIME FAILURE at the splice site.

failAt

failAt : Site -> String -> aSource

Stops compilation with a COMPILE-TIME FAILURE at an attribute’s site.

foldItems

foldItems : (a -> b -> a) -> a -> Items b -> aSource

Combines the items into one value, first to last.

import Meta exposing (Items(..))

Meta.foldItems { total n -> total + n } 0 (Item 1 (Item 2 NoItems)) == 3

head

head : TypeRepr -> TypeReprSource

The type constructor an application applies, or the type itself.

info

info : TypeRepr -> ReflectedSource

The type’s schema, when visible where typeOf was written and without constructor-local hidden types.

isReference

isReference : Code -> BoolSource

Whether the code is a quote of exactly one top-level name, such as `List.map`.

isVar

isVar : TypeRepr -> BoolSource

Whether the type is a type variable.

lambda

lambda : String -> (Code -> Code) -> CodeSource

Give a generator a reference to a local binder and wrap its result in a lambda. The caller supplies a private name; generated bodies can then keep one typed slot per reflected field without generating declarations.

lengthItems

lengthItems : Items a -> IntSource

The number of items.

localFunction

localFunction : String -> Items String -> (Code -> Items Code -> Code) -> (Code -> Code) -> CodeSource

Build a named local function, including self-recursive references, and an expression that uses it. Names must be private and parameters nonempty.

mapItems

mapItems : (a -> b) -> Items a -> Items bSource

Applies a function to every item, keeping their order.

import Meta exposing (Items(..))

Meta.lengthItems (Meta.mapItems { n -> n * 2 } (Item 1 (Item 2 NoItems))) == 2

match

match : TypeInfo -> Code -> (Bound -> Code) -> CodeSource

match builds the exhaustive case over subject’s constructors and binds every field, handing each branch’s bindings to build. Nesting two calls produces the nested case a two-argument method needs.

sameEffect

sameEffect : Effect -> Effect -> BoolSource

Whether two effect applications are the same effect with the same arguments. Names never decide it.

sameType

sameType : TypeRepr -> TypeRepr -> BoolSource

Whether two reflected types are the same type. Names never decide it.

sequence

sequence : Code -> Code -> CodeSource

Sequence a Unit expression before a result without introducing a lambda.

siteOf

siteOf : Code -> SiteSource

Where a piece of code was written, for reporting a failure there with failAt. Code the compiler built reports at the splice site instead.

typeName

typeName : TypeRepr -> StringSource

typeName is for display only. Identity is sameType.