docs
API
Generated with
docs/scalus/scalus.compiler/scalus.compiler.intrinsics/IntrinsicsUplcConstrList

IntrinsicsUplcConstrList

scalus.compiler.intrinsics.IntrinsicsUplcConstrList
object IntrinsicsUplcConstrList

UplcConstr list intrinsics — thin delegation to UplcConstrListOperations.

The IntrinsicResolver dispatches to these when the list has SumUplcConstr representation. Type parameters are annotated @UplcRepr(TypeVar(Unwrapped)): the inliner substitutes the caller's concrete representation at the inlining site. Every List[_] / Option[_] in the signatures is annotated @UplcRepr(UplcConstr) — under the per-signature annotation regime (no uplcGeneratorPolicy swap), this is how the dispatcher's inline self match { ... } match lands on the UplcConstr code path and how its result stays in UplcConstr form. Simple methods (isEmpty, head, tail) are implemented inline since they're single pattern matches. Complex recursive methods delegate to UplcConstrListOperations (support module whose type params are Unwrapped).

For contains: Eq has known semantics (structural equality), so we use equalsData directly instead of calling the Eq function. Elements are converted to Data via toDefaultTypeVarRepr, then compared with a single equalsData builtin call.

Attributes

Graph
Supertypes
class Object
trait Matchable
class Any
Self type

Members list

Value members

Concrete methods

def append[A](self: List[A], other: List[A]): List[A]
def appendedAll[A](self: List[A], other: List[A]): List[A]
def contains[A](self: List[A], elem: A): Boolean
def deleteFirst[A](self: List[A], elem: A): List[A]
def diff[A](self: List[A], other: List[A]): List[A]
def distinct[A](self: List[A]): List[A]
def drop[A](self: List[A], n: BigInt): List[A]
def dropRight[A](self: List[A], n: BigInt): List[A]
def filter[A](self: List[A], predicate: A => Boolean): List[A]
def filterMap[A, B](self: List[A], predicate: A => Option[B]): List[B]
def find[A](self: List[A], predicate: A => Boolean): Option[A]
def foldLeft[A, B](self: List[A], init: B, combiner: (B, A) => B): B
def foldRight[A, B](self: List[A], init: B, combiner: (A, B) => B): B
def head[A](self: List[A]): A
def indexOf[A](self: List[A], elem: A): BigInt
def init[A](self: List[A]): List[A]
def isEmpty[A](self: List[A]): Boolean
def length[A](self: List[A]): BigInt
def map[A, B](self: List[A], mapper: A => B): List[B]
def prepended[A](self: List[A], elem: A): List[A]
def reverse[A](self: List[A]): List[A]
def sort[A](self: List[A], ord: (A, A) => Order): List[A]
def tail[A](self: List[A]): List[A]

Concrete fields

lazy val sirDeps: List[SIRModuleWithDeps]
lazy val sirModule: Module
Generated with