Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 123456]

Nautomaton
CAutomatonBase
CDFANode
CLt
CDFA
CNFANode
CNFA
CRangeCompare
Nmim
Nast
CAnnexInfo
CAST
CNode
CExpr
CDecl
CValDecl
CPtrn
CErrorPtrn
CIdPtrn	dbg: type
CGrpPtrn	If you have x1 x2 x3 x4: T it consists of 3 GrpPtrns and 1 IdPtrn while each GrpPtrn references the last IdPtrn
CAliasPtrn	ptrn as id
CTuplePtrn	(ptrn_0, ..., ptrn_n-1), [ptrn_0, ..., ptrn_n-1], or {ptrn_0, ..., ptrn_n-1}
CErrorExpr
CHoleExpr
CIdExpr	sym
CPrimaryExpr	tag
CLitExpr	tok:type
CDeclExpr	decls e or e where decls if where is true
CTypeExpr	Type level
CRuleExpr	Reform (type of a rule) Rule type
CUnionExpr	t1 ∪ t2
CInjExpr	value inj t1 ∪ t2
CMatchExpr
CArm
CArrowExpr	dom -> codom
CPiExpr	One of:
CDom
CLamExpr	Wraps a LamDecl as Expr
CAppExpr	callee arg
CRetExpr	ret ptrn = callee $ arg; body
CSigmaExpr	Just wraps TuplePtrn as Expr
CTupleExpr	(elem_0, ..., elem_n-1)
CSeqExpr	«dbg: arity; body» or ‹dbg: arity; body›
CExtractExpr	tuple#index
CInsertExpr	ins(tuple, index, value)
CUniqExpr	⦃ expr ⦄
CLetDecl	let ptrn: type = value;
CAxmDecl	axm ptrn: type = value;
CAlias
CRecDecl	.rec dbg: type = body
CLamDecl	One of:
CDom
CCDecl	cfun dbg dom -> codom
CRuleDecl	Rewrite rules rule (x:T, y:T) : x+y => y+x (when ); all meta variables have to be introduced
CImport
CModule
CLexer
CParser	Parses Mim code as AST
CTok
CDummyDecl
CScopes
CEmitter
CS
CR
CAnnexInfo.sym
CAnnexInfo.id
Nplug
Naffine	The affine Plugin
Nphase
CLowerFor	Lowers the for axm to actual control flow in CPS
Nautodiff	The automatic differentiation Plugin
CEval	This pass is the heart of AD
Nclos	The clos Plugin
CClosLit	Wrapper around a Def that can be used to match closures (see isa_clos_lit)
CBranchClosElim
CClos2SJLJ
CClosConvPrep
CLowerTypedClosPrep
CFreeDefAna	Transitively compute free Def's on demand
CClosConv	Performs typed closure conversion
CLowerTypedClos	This pass lowers typed closures to untyped closures
Ndirect	The direct style Plugin
CCPS2DSPhase	Rewrite direct.cps2ds to cps
CDS2CPS	Converts direct style function to cps functions
Nmatrix	The matrix Plugin
CLowerMatrixHighLevelMapRed	Resolves lowering of high level operations into medium/other high-level operations
CLowerMatrixLowLevel	In this phase, we lower all matrix operations and types to the low-level representation using pointers
CLowerMatrixMediumLevel	In this step, we lower map_reduce operations into affine for loops making the iteration scheme explicit
Nmem	The mem Plugin
Npass
CCopyProp	This FPPass is similar to sparse conditional constant propagation (SCCP)
CReshape	The general idea of this Pass is to change the shape of signatures of functions
CSSA	SSA construction algorithm that promotes slots, loads, and stores to SSA values
CInfo
Nphase
CAddMem	This phase adds mems to all lambdas and continuations
Nregex	The regex Plugin
CLowerRegex
Capp_range
Nll
CBB
CEmitter
Nsexpr
CBB
CEmitter
Nlct
CNode	This is an intrusive Link-Cut-Tree
CAxm
CIsANode
CIsA
CEmitter
CHole	This node is a hole in the IR that is inferred by its context later on
CChecker
CSetters	CRTP-based mixin to declare setters for Def::loc & Def::name using a covariant return type
CDef	Base class for all Defs
CVar	A variable introduced by a binder (mutable)
CUniv
CUMax
CUInc
CType
CLit
CNat
CIdx	A built-in constant of type Nat -> *
CProxy
CGlobal
CDriver	Some "global" variables needed all over the place
CImports
CEntry
CFlags	Compiler switches that must be saved and looked up in later phases of compilation
CPi	A dependent function type
CLam	A function
CApp
CBound	Common base for TBound
CTBound	Specific Bound depending on Up
CMerge	Constructs a Meet value
CInj	Constructs a Join value
CSplit	Picks the aspect of a Meet [value](Pick::value) by its [type](Def::type)
CMatch	Scrutinize Match::scrutinee() and dispatch to Match::arms
CExt	Common base for TExtremum
CTExt	Extremum. Either Top (Up) or Bottom
CUniq	A singleton wraps a type into a higher order type
CNest	Builds a nesting tree of all mutables‍/binders
CNode
CChildren
CSiblDeps
CRes	Utility class when folding constants in normalizers
CStage	Common base for Phase and Pass
CPass	All Passes that want to be registered in the PassMan must implement this interface
CPassMan	An optimizer that combines several optimizations in an optimal way
CRWPass	Inherit from this class using CRTP, if your Pass does not need state and a fixed-point iteration
CFPPass	Inherit from this class using CRTP, if you do need a Pass with a state and a fixed-point
CBetaRed	Optimistically performs β-reduction (aka inlining)
CEtaExp	Performs η-expansion: f -> λx.f x, if f is a Lam with more than one user and does not appear in callee position
CEtaRed	Performs η-reduction
CLamSpec
CScalarize	Perform Scalarization (= Argument simplification)
CTailRecElim
CPhase	As opposed to a Pass, a Phase does one thing at a time and does not mix with other Phases
CAnalysis	This Phase will recursively Rewriter::rewrite
CRWPhase	Rewrites the RWPhase::old_world into the RWPhase::new_world and swaps them afterwards
CRepl	Simple Stage that searches for a pattern and replaces it
CReplMan
CReplManPhase
CCleanup	Removes unreachable and dead code by rebuilding the whole World into a new one and swapping them afterwards
CPassManPhase	Wraps a PassMan pipeline as a Phase
CPhaseMan	Organizes several Phases in a a pipeline
CClosedMutPhase	Transitively visits all reachable, closed mutables in the World
CNestPhase	Like ClosedMutPhase but computes a Nest for each NestPhase::visit
CBetaRedPhase	Inlines in post-order all Lams that occur exactly once in the program
CBranchNormalizePhase	Inlines in post-order all Lams that occur exactly once in the program
CEtaExpPhase	This phase takes care that Lamdas appear either only in callee position (Known) or not (Unknown)
CEtaRedPhase	Inlines in post-order all Lams that occur exactly once in the program
CPrefixCleanup
CRetWrap
CSymExprOpt	Symbolic Expression Optimization
CPlugin	Basic info and registration function pointer to be returned from a specific plugin
CAnnex	Holds info about an entity defined within a Plugin (called Annex)
CRewriter	Recurseivly rebuilds part of a program into the provided World w.r.t. Rewriter::map
CVarRewriter	Extends Rewriter for variable substitution
CZonker
CReform	Type formation of a rewrite Rule
CRule	A rewrite rule
CUse	Const Def*erences a user
CUseHash
CUseEq
CScheduler
CProd	Base class for Sigma and Tuple
CSigma	A dependent tuple type
CTuple	Data constructor for a Sigma
CSeq	Base class for Arr and Pack
CArr	A (possibly paramterized) Array
CPack	A (possibly paramterized) Tuple
CExtract	Extracts from a Sigma or Array-typed Extract::tuple the element at position Extract::index
CInsert	Creates a new Tuple / Pack by inserting Insert::value at position Insert::index into Insert::tuple
CSelect	Matches (ff, tt)#cond - where cond is not a Literal
CBranch	Matches (ff, tt)#cond arg where cond is not a Literal
CDispatch	Matches a dispatch through a jump table of the form: (target_0, target_1, ...)#index arg where index is not a Literal
CError
CMsg
CDbg
CFNV1
CFNV1< 4 >
CFNV1< 8 >
CLog	Facility to log what you are doing
CElem	Use with print to output complicated std::ranges::ranges
CStreamFn	Create function-wrapper objects amenable for opeartor<<
CTab	Keeps track of indentation level
CSets
CSet
Citerator
CSpan	This is a thin wrapper for std::span<T, N> with the following additional features:
Cunique_stack
Cunique_queue
CGIDHash
CGIDLt
CVector	This is a thin wrapper for absl::InlinedVector<T, N, A> which is a drop-in replacement for std::vector<T, A>
CWorld	The World represents the whole program and manages creation of MimIR nodes (Defs)
CState
CPOD	Plain Old Data
CScopedLoc
CFreezer	Use to World::freeze and automatically unfreeze at the end of scope
CExternals
CMove.arena
Nstd
Ctuple_size< mim::Span< T, N > >
Ctuple_element< I, mim::Span< T, N > >