| Cmim::Annex | Holds info about an entity defined within a Plugin (called Annex) |
| Cmim::ast::AnnexInfo | |
| Cmim::ast::AnnexInfo.id | |
| Cmim::ast::AnnexInfo.sym | |
| Cmim::plug::regex::app_range | |
| Cmim::ast::AST | |
| Cautomaton::AutomatonBase< NodeType > | |
| ▼Cautomaton::AutomatonBase< DFANode > | |
| Cautomaton::DFA | |
| ▼Cautomaton::AutomatonBase< NFANode > | |
| Cautomaton::NFA | |
| Cmim::ll::BB | |
| Cmim::BitSet | |
| Cmim::Checker | |
| Cmim::Nest::Node::Children | |
| Cmim::plug::clos::ClosLit | Wrapper around a Def that can be used to match closures (see isa_clos_lit) |
| Cmim::Dbg | |
| Cautomaton::DFANode | |
| Cmim::Dispatch | Matches a dispatch through a jump table of the form: (target_0, target_1, ...)#index arg where index is not a Literal |
| Cmim::Elem< R, F > | Use with print to output complicated std::ranges::ranges |
| Cmim::ast::Emitter | |
| Cmim::Sets< D, N >::Data::Equal | |
| ▼Cstd::exception | |
| Cmim::Error | |
| Cmim::World::Externals | |
| Cmim::Flags | Compiler switches that must be saved and looked up in later phases of compilation |
| Cmim::FNV1< size_t > | |
| Cmim::FNV1< 4 > | |
| Cmim::FNV1< 8 > | |
| Cmim::plug::clos::FreeDefAna | Transitively compute free Def's on demand |
| Cmim::World::Freezer | Use to World::freeze and automatically unfreeze at the end of scope |
| Cmim::GIDHash< T > | |
| Cmim::GIDLt< T > | |
| Cmim::Driver::Imports | |
| Cmim::plug::mem::pass::SSA::Info | |
| ▼Cabsl::InlinedVector | |
| Cmim::Vector< const Def * > | |
| Cmim::Vector< Lattice > | |
| Cmim::Vector< Def * > | |
| Cmim::Vector< Range > | |
| Cmim::Vector< void * > | |
| Cmim::Vector< mim::Sets::Set > | |
| Cmim::Vector< T, N, A > | This is a thin wrapper for absl::InlinedVector<T, N, A> which is a drop-in replacement for std::vector<T, A> |
| ▼Cstd::integral_constant | |
| Cstd::tuple_size< mim::Span< T, N > > | |
| Cmim::Axm::IsA< Id, D > | |
| Cmim::Axm::IsANode< T > | |
| Cmim::Sets< D, N >::Set::iterator | |
| ▼Cfe::Lexer | |
| Cmim::ast::Lexer | |
| Cmim::Log | Facility to log what you are doing |
| Cautomaton::DFANode::Lt | |
| Cmim::World::Move.arena | |
| Cmim::Error::Msg | |
| Cmim::Nest | Builds a nesting tree of all immutables/binders |
| Cautomaton::NFANode | |
| Cmim::lct::Node< P, K > | This is an intrusive Link-Cut-Tree |
| Cmim::Nest::Node | |
| ▼Cfe::Parser | |
| Cmim::ast::Parser | Parses Mim code as AST |
| Cmim::Plugin | Basic info and registration function pointer to be returned from a specific plugin |
| Cmim::World::State::POD | Plain Old Data |
| Cmim::ast::R< T > | |
| Cautomaton::RangeCompare | |
| Cmim::BitSet::reference | |
| Cmim::Res | Utility class when folding constants in normalizers |
| ▼Cmim::Rewriter | Recurseivly rebuilds part of a program into the provided World w.r.t. Rewriter::map |
| Cmim::Analysis | This Phase will recursively Rewriter::rewrite |
| ▼Cmim::RWPhase | Rewrites the RWPhase::old_world into the RWPhase::new_world and swaps them afterwards |
| Cmim::BetaRedPhase | Inlines in post-order all Lams that occur exactly once in the program |
| Cmim::BranchNormalizePhase | Inlines in post-order all Lams that occur exactly once in the program |
| Cmim::Cleanup | Removes unreachable and dead code by rebuilding the whole World into a new one and swapping them afterwards |
| Cmim::EtaExpPhase | This phase takes care that Lamdas appear either only in callee position (Known) or not (Unknown) |
| Cmim::EtaRedPhase | Inlines in post-order all Lams that occur exactly once in the program |
| Cmim::PrefixCleanup | |
| Cmim::ReplManPhase | |
| Cmim::RetWrap | |
| Cmim::SCCP | Sparse Conditional Constant Propagation |
| Cmim::plug::affine::phase::LowerFor | Lowers the for axm to actual control flow in CPS |
| Cmim::plug::matrix::LowerMatrixLowLevel | In this phase, we lower all matrix operations and types to the low-level representation using pointers |
| Cmim::VarRewriter | |
| Cmim::Zonker | |
| ▼Cfe::RuntimeCast | |
| ▼Cmim::Def | Base class for all Defs |
| Cmim::App | |
| Cmim::Axm | |
| ▼Cmim::Bound | Common base for TBound |
| Cmim::TBound< false > | |
| Cmim::TBound< true > | |
| Cmim::TBound< Up > | Specific Bound depending on Up |
| ▼Cmim::Ext | Common base for TExtremum |
| Cmim::TExt< false > | |
| Cmim::TExt< true > | |
| Cmim::TExt< Up > | Extremum. Either Top (Up) or Bottom |
| Cmim::Extract | Extracts from a Sigma or Array-typed Extract::tuple the element at position Extract::index |
| Cmim::Global | |
| Cmim::Hole | This node is a hole in the IR that is inferred by its context later on |
| Cmim::Idx | A built-in constant of type Nat -> * |
| Cmim::Inj | Constructs a Join value |
| Cmim::Insert | Creates a new Tuple / Pack by inserting Insert::value at position Insert::index into Insert::tuple |
| Cmim::Lam | A function |
| Cmim::Lit | |
| Cmim::Match | Scrutinize Match::scrutinee() and dispatch to Match::arms |
| Cmim::Merge | Constructs a Meet value |
| Cmim::Nat | |
| Cmim::Pi | A dependent function type |
| ▼Cmim::Prod | Base class for Sigma and Tuple |
| Cmim::Sigma | A dependent tuple type |
| Cmim::Tuple | Data constructor for a Sigma |
| Cmim::Proxy | |
| Cmim::Reform | Type formation of a rewrite Rule |
| Cmim::Rule | A rewrite rule |
| ▼Cmim::Seq | Base class for Arr and Pack |
| Cmim::Arr | A (possibly paramterized) Array |
| Cmim::Pack | A (possibly paramterized) Tuple |
| Cmim::Split | Picks the aspect of a Meet [value](Pick::value) by its [type](Def::type) |
| Cmim::Type | |
| Cmim::UInc | |
| Cmim::UMax | |
| Cmim::Uniq | A singleton wraps a type into a higher order type |
| Cmim::Univ | |
| Cmim::Var | A variable introduced by a binder (mutable) |
| ▼Cmim::Stage | Common base for Phase and Pass |
| ▼Cmim::Pass | All Passes that want to be registered in the PassMan must implement this interface |
| Cmim::RWPass< P, M > | |
| ▼Cmim::RWPass< BetaRed, Def > | |
| ▼Cmim::FPPass< BetaRed, Def > | |
| Cmim::BetaRed | Optimistically performs β-reduction (aka inlining) |
| ▼Cmim::RWPass< EtaExp, Lam > | |
| ▼Cmim::FPPass< EtaExp, Lam > | |
| Cmim::EtaExp | Performs η-expansion: f -> λx.f x, if f is a Lam with more than one user and does not appear in callee position |
| ▼Cmim::RWPass< EtaRed, Def > | |
| ▼Cmim::FPPass< EtaRed, Def > | |
| Cmim::EtaRed | Performs η-reduction |
| ▼Cmim::RWPass< P, Def > | |
| Cmim::FPPass< P, M > | Inherit from this class using CRTP, if you do need a Pass with a state and a fixed-point |
| ▼Cmim::RWPass< LamSpec, Lam > | |
| Cmim::LamSpec | |
| ▼Cmim::RWPass< Scalarize, Lam > | |
| Cmim::Scalarize | Perform Scalarization (= Argument simplification) |
| ▼Cmim::RWPass< TailRecElim, Lam > | |
| ▼Cmim::FPPass< TailRecElim, Lam > | |
| Cmim::TailRecElim | |
| ▼Cmim::RWPass< Eval, Lam > | |
| Cmim::plug::autodiff::Eval | This pass is the heart of AD |
| ▼Cmim::RWPass< BranchClosElim, Lam > | |
| Cmim::plug::clos::BranchClosElim | |
| ▼Cmim::RWPass< Clos2SJLJ, Lam > | |
| Cmim::plug::clos::Clos2SJLJ | |
| ▼Cmim::RWPass< ClosConvPrep, Lam > | |
| Cmim::plug::clos::ClosConvPrep | |
| ▼Cmim::RWPass< LowerTypedClosPrep, Lam > | |
| ▼Cmim::FPPass< LowerTypedClosPrep, Lam > | |
| Cmim::plug::clos::LowerTypedClosPrep | |
| ▼Cmim::RWPass< CPS2DS, Lam > | |
| Cmim::plug::direct::CPS2DS | This is the second part of ds2cps |
| ▼Cmim::RWPass< DS2CPS, Lam > | |
| Cmim::plug::direct::DS2CPS | Converts direct style function to cps functions |
| ▼Cmim::RWPass< LowerMatrixHighLevelMapRed, Lam > | |
| Cmim::plug::matrix::LowerMatrixHighLevelMapRed | Resolves lowering of high level operations into medium/other high-level operations |
| ▼Cmim::RWPass< LowerMatrixMediumLevel, Lam > | |
| Cmim::plug::matrix::LowerMatrixMediumLevel | In this step, we lower map_reduce operations into affine for loops making the iteration scheme explicit |
| ▼Cmim::RWPass< CopyProp, Lam > | |
| ▼Cmim::FPPass< CopyProp, Lam > | |
| Cmim::plug::mem::pass::CopyProp | This FPPass is similar to sparse conditional constant propagation (SCCP) |
| ▼Cmim::RWPass< Reshape, Lam > | |
| Cmim::plug::mem::pass::Reshape | The general idea of this Pass is to change the shape of signatures of functions |
| ▼Cmim::RWPass< SSA, Lam > | |
| ▼Cmim::FPPass< SSA, Lam > | |
| Cmim::plug::mem::pass::SSA | SSA construction algorithm that promotes slots, loads, and stores to SSA values |
| ▼Cmim::RWPass< LowerRegex, Lam > | |
| Cmim::plug::regex::LowerRegex | |
| Cmim::PassMan | An optimizer that combines several optimizations in an optimal way |
| Cmim::RWPass< P, M > | Inherit from this class using CRTP, if your Pass does not need state and a fixed-point iteration |
| ▼Cmim::Phase | As opposed to a Pass, a Phase does one thing at a time and does not mix with other Phases |
| ▼Cmim::ClosedMutPhase< Lam > | |
| ▼Cmim::NestPhase< Lam > | |
| ▼Cmim::Emitter< std::string, std::string, BB, Emitter > | |
| Cmim::ll::Emitter | |
| Cmim::Emitter< Value, Type, BB, Child > | |
| Cmim::plug::mem::phase::AddMem | This phase adds mems to all lambdas and continuations |
| ▼Cmim::ClosedMutPhase< Def > | |
| Cmim::NestPhase< M > | Like ClosedMutPhase but computes a Nest for each NestPhase::visit |
| Cmim::Analysis | This Phase will recursively Rewriter::rewrite |
| Cmim::ClosedMutPhase< M > | Transitively visits all reachable, closed mutables in the World |
| Cmim::PassManPhase | Wraps a PassMan pipeline as a Phase |
| Cmim::PhaseMan | Organizes several Phases in a a pipeline |
| Cmim::RWPhase | Rewrites the RWPhase::old_world into the RWPhase::new_world and swaps them afterwards |
| Cmim::plug::clos::ClosConv | Performs typed closure conversion |
| Cmim::plug::clos::LowerTypedClos | This pass lowers typed closures to untyped closures |
| ▼Cmim::Repl | Simple Stage that searches for a pattern and replaces it |
| Cmim::ReplMan | |
| ▼Cmim::ast::Node | |
| ▼Cmim::ast::Decl | |
| Cmim::ast::AxmDecl::Alias | |
| Cmim::ast::DummyDecl | |
| ▼Cmim::ast::Ptrn | |
| Cmim::ast::AliasPtrn | ptrn as id |
| Cmim::ast::ErrorPtrn | |
| Cmim::ast::GrpPtrn | If you have x1 x2 x3 x4: T it consists of 3 GrpPtrns and 1 IdPtrn while each GrpPtrn references the last IdPtrn |
| Cmim::ast::IdPtrn | dbg: type |
| Cmim::ast::TuplePtrn | (ptrn_0, ..., ptrn_n-1), [ptrn_0, ..., ptrn_n-1], or {ptrn_0, ..., ptrn_n-1} |
| ▼Cmim::ast::ValDecl | |
| Cmim::ast::AxmDecl | axm ptrn: type = value; |
| Cmim::ast::CDecl | cfun dbg dom -> codom |
| Cmim::ast::LetDecl | let ptrn: type = value; |
| ▼Cmim::ast::RecDecl | .rec dbg: type = body |
| Cmim::ast::LamDecl | One of: |
| Cmim::ast::RuleDecl | Rewrite rules rule (x:T, y:T) : x+y => y+x (when ); all meta variables have to be introduced |
| ▼Cmim::ast::Expr | |
| Cmim::ast::AppExpr | callee arg |
| Cmim::ast::ArrowExpr | dom -> codom |
| Cmim::ast::DeclExpr | decls e or e where decls if where is true |
| Cmim::ast::ErrorExpr | |
| Cmim::ast::ExtractExpr | tuple#index |
| Cmim::ast::HoleExpr | |
| Cmim::ast::IdExpr | sym |
| Cmim::ast::InjExpr | value inj t1 ∪ t2 |
| Cmim::ast::InsertExpr | ins(tuple, index, value) |
| Cmim::ast::LamExpr | Wraps a LamDecl as Expr |
| Cmim::ast::LitExpr | tok:type |
| Cmim::ast::MatchExpr | |
| Cmim::ast::PiExpr | One of: |
| Cmim::ast::PrimaryExpr | tag |
| Cmim::ast::RetExpr | ret ptrn = callee $ arg; body |
| Cmim::ast::SeqExpr | «dbg: arity; body» or ‹dbg: arity; body› |
| Cmim::ast::SigmaExpr | Just wraps TuplePtrn as Expr |
| Cmim::ast::TupleExpr | (elem_0, ..., elem_n-1) |
| Cmim::ast::TypeExpr | Type level |
| Cmim::ast::UnionExpr | t1 ∪ t2 |
| Cmim::ast::UniqExpr | ⦃ expr ⦄ |
| Cmim::ast::Import | |
| Cmim::ast::MatchExpr::Arm | |
| Cmim::ast::Module | |
| ▼Cmim::ast::PiExpr::Dom | |
| Cmim::ast::LamDecl::Dom | |
| Cmim::ast::S | |
| Cmim::Scheduler | |
| Cmim::World::ScopedLoc | |
| Cmim::ast::Scopes | |
| ▼Cmim::Select | Matches (ff, tt)#cond - where cond is not a Literal |
| Cmim::Branch | Matches (ff, tt)#cond arg where cond is not a Literal |
| Cmim::Sets< D, N >::Set | |
| Cmim::Sets< D, N > | |
| Cmim::Setters< P, D > | CRTP-based mixin to declare setters for Def::loc & Def::name using a covariant return type |
| ▼Cmim::Setters< App > | |
| Cmim::App | |
| ▼Cmim::Setters< Arr > | |
| Cmim::Arr | A (possibly paramterized) Array |
| ▼Cmim::Setters< Axm > | |
| Cmim::Axm | |
| ▼Cmim::Setters< Extract > | |
| Cmim::Extract | Extracts from a Sigma or Array-typed Extract::tuple the element at position Extract::index |
| ▼Cmim::Setters< Global > | |
| Cmim::Global | |
| ▼Cmim::Setters< Hole > | |
| Cmim::Hole | This node is a hole in the IR that is inferred by its context later on |
| ▼Cmim::Setters< Idx > | |
| Cmim::Idx | A built-in constant of type Nat -> * |
| ▼Cmim::Setters< Inj > | |
| Cmim::Inj | Constructs a Join value |
| ▼Cmim::Setters< Insert > | |
| Cmim::Insert | Creates a new Tuple / Pack by inserting Insert::value at position Insert::index into Insert::tuple |
| ▼Cmim::Setters< Lam > | |
| Cmim::Lam | A function |
| ▼Cmim::Setters< Lit > | |
| Cmim::Lit | |
| ▼Cmim::Setters< Match > | |
| Cmim::Match | Scrutinize Match::scrutinee() and dispatch to Match::arms |
| ▼Cmim::Setters< Merge > | |
| Cmim::Merge | Constructs a Meet value |
| ▼Cmim::Setters< Nat > | |
| Cmim::Nat | |
| ▼Cmim::Setters< Pack > | |
| Cmim::Pack | A (possibly paramterized) Tuple |
| ▼Cmim::Setters< Pi > | |
| Cmim::Pi | A dependent function type |
| ▼Cmim::Setters< Prod > | |
| Cmim::Prod | Base class for Sigma and Tuple |
| ▼Cmim::Setters< Proxy > | |
| Cmim::Proxy | |
| ▼Cmim::Setters< Reform > | |
| Cmim::Reform | Type formation of a rewrite Rule |
| ▼Cmim::Setters< Rule > | |
| Cmim::Rule | A rewrite rule |
| ▼Cmim::Setters< Seq > | |
| Cmim::Seq | Base class for Arr and Pack |
| ▼Cmim::Setters< Sigma > | |
| Cmim::Sigma | A dependent tuple type |
| ▼Cmim::Setters< Split > | |
| Cmim::Split | Picks the aspect of a Meet [value](Pick::value) by its [type](Def::type) |
| ▼Cmim::Setters< TBound< Up > > | |
| Cmim::TBound< false > | |
| Cmim::TBound< true > | |
| Cmim::TBound< Up > | Specific Bound depending on Up |
| ▼Cmim::Setters< TExt< Up > > | |
| Cmim::TExt< false > | |
| Cmim::TExt< true > | |
| Cmim::TExt< Up > | Extremum. Either Top (Up) or Bottom |
| ▼Cmim::Setters< Tuple > | |
| Cmim::Tuple | Data constructor for a Sigma |
| ▼Cmim::Setters< Type > | |
| Cmim::Type | |
| ▼Cmim::Setters< UInc > | |
| Cmim::UInc | |
| ▼Cmim::Setters< UMax > | |
| Cmim::UMax | |
| ▼Cmim::Setters< Uniq > | |
| Cmim::Uniq | A singleton wraps a type into a higher order type |
| ▼Cmim::Setters< Univ > | |
| Cmim::Univ | |
| ▼Cmim::Setters< Var > | |
| Cmim::Var | A variable introduced by a binder (mutable) |
| Cmim::Nest::Node::SiblDeps< Forward > | |
| ▼Cstd::span | |
| Cmim::Span< const T, N > | |
| Cmim::Span< T, N > | This is a thin wrapper for std::span<T, N> with the following additional features: |
| Cmim::World::State | |
| ▼Cfe::SymPool | |
| Cmim::Driver | Some "global" variables needed all over the place |
| Cmim::Tab | Keeps track of indentation level |
| Cmim::ast::Tok | |
| Cstd::tuple_element< I, mim::Span< T, N > > | |
| Cmim::unique_queue< Set > | |
| Cmim::unique_stack< Set > | |
| Cmim::Use | Const Def*erences a user |
| Cmim::UseEq | |
| Cmim::UseHash | |
| Cmim::detail::w2f_< int > | |
| Cmim::detail::w2f_< 16 > | |
| Cmim::detail::w2f_< 32 > | |
| Cmim::detail::w2f_< 64 > | |
| Cmim::detail::w2s_< int > | |
| Cmim::detail::w2s_< 1 > | See above |
| Cmim::detail::w2s_< 16 > | |
| Cmim::detail::w2s_< 32 > | |
| Cmim::detail::w2s_< 64 > | |
| Cmim::detail::w2s_< 8 > | |
| Cmim::detail::w2u_< int > | |
| Cmim::detail::w2u_< 1 > | Map both signed 1 and unsigned 1 to bool |
| Cmim::detail::w2u_< 16 > | |
| Cmim::detail::w2u_< 32 > | |
| Cmim::detail::w2u_< 64 > | |
| Cmim::detail::w2u_< 8 > | |
| Cmim::World | The World represents the whole program and manages creation of MimIR nodes (Defs) |
| Cconst bool | |
| Cint | |
| Clist< DFANode > | |
| Clist< NFANode > | |
1.13.2