MimIR 0.1
MimIR is my Intermediate Representation
Loading...
Searching...
No Matches
mim::Ext Class Reference

Common base for TExtremum. More...

#include <mim/lattice.h>

Inheritance diagram for mim::Ext:
[legend]

Protected Member Functions

 Ext (Node node, const Def *type)
 
- Protected Member Functions inherited from mim::Def
 Def (World *, Node, const Def *type, Defs ops, flags_t flags)
 Constructor for an immutable Def.
 
 Def (Node, const Def *type, Defs ops, flags_t flags)
 As above but World retrieved from type.
 
 Def (Node, const Def *type, size_t num_ops, flags_t flags)
 Constructor for a mutable Def.
 
virtual ~Def ()=default
 
Sym sym (const char *) const
 
Sym sym (std::string_view) const
 
Sym sym (std::string) const
 

Additional Inherited Members

- Public Member Functions inherited from mim::Def
Worldworld () const noexcept
 
constexpr flags_t flags () const noexcept
 
constexpr u32 gid () const noexcept
 Global id - unique number for this Def.
 
constexpr u32 tid () const noexcept
 Trie id - only used in Trie.
 
constexpr u32 mark () const noexcept
 Used internally by free_vars().
 
constexpr size_t hash () const noexcept
 
constexpr Node node () const noexcept
 
std::string_view node_name () const
 
u32 judge () const noexcept
 
bool is_form () const noexcept
 
bool is_intro () const noexcept
 
bool is_elim () const noexcept
 
bool is_meta () const noexcept
 
const Deftype () const noexcept
 Yields the "raw" type of this Def (maybe nullptr).
 
const Defunfold_type () const
 Yields the type of this Def and builds a new Type (UInc n) if necessary.
 
bool is_term () const
 
const Defarity () const
 
std::optional< nat_tisa_lit_arity () const
 
nat_t as_lit_arity () const
 
template<size_t N = std::dynamic_extent>
constexpr auto ops () const noexcept
 
const Defop (size_t i) const noexcept
 
constexpr size_t num_ops () const noexcept
 
Defset (size_t i, const Def *)
 Successively set from left to right.
 
Defreset (size_t i, const Def *def)
 Successively reset from left to right.
 
Defset (Defs ops)
 Def::set ops all at once.
 
Defreset (Defs ops)
 Def::reset ops all at once.
 
Defunset ()
 Unsets all Def::ops; works even, if not set at all or partially.
 
bool is_set () const
 Yields true if empty or the last op is set.
 
Defs deps () const noexcept
 
const Defdep (size_t i) const noexcept
 
size_t num_deps () const noexcept
 
bool has_dep () const
 
bool has_dep (Dep d) const
 
bool has_dep (unsigned u) const
 
nat_t num_projs () const
 Yields Def::as_lit_arity(), if it is in fact a Lit, or 1 otherwise.
 
nat_t num_tprojs () const
 As above but yields 1, if Flags::scalarize_threshold is exceeded.
 
const Defproj (nat_t a, nat_t i) const
 Similar to World::extract while assuming an arity of a, but also works on Sigmas and Arrays.
 
const Defproj (nat_t i) const
 As above but takes Def::num_projs as arity.
 
const Deftproj (nat_t i) const
 As above but takes Def::num_tprojs.
 
template<nat_t A = std::dynamic_extent, class F>
auto projs (F f) const
 Splits this Def via Def::projections into an Array (if A == std::dynamic_extent) or std::array (otherwise).
 
template<class F>
auto tprojs (F f) const
 
template<class F>
auto projs (nat_t a, F f) const
 
template<nat_t A = std::dynamic_extent>
auto projs () const
 
auto tprojs () const
 
auto projs (nat_t a) const
 
nat_t num_vars () noexcept
 
nat_t num_tvars () noexcept
 
const Defvar (nat_t a, nat_t i) noexcept
 
const Defvar (nat_t i) noexcept
 
const Deftvar (nat_t i) noexcept
 
template<nat_t A = std::dynamic_extent, class F>
auto vars (F f) noexcept
 
template<class F>
auto tvars (F f) noexcept
 
template<nat_t A = std::dynamic_extent>
auto vars () noexcept
 
auto tvars () noexcept
 
template<class F>
auto vars (nat_t a, F f) noexcept
 
auto vars (nat_t a) noexcept
 
const Defvar ()
 Not necessarily a Var: E.g., if the return type is [], this will yield ().
 
const Varhas_var ()
 Only returns not nullptr, if Var of this mutable has ever been created.
 
const Varhas_var () const
 As above if this is a mutable.
 
Muts local_muts () const
 Mutables reachable by following immutable deps(); mut->local_muts() is by definition the set { mut }.
 
Vars local_vars () const
 Vars reachable by following immutable deps().
 
Vars free_vars () const
 Compute a global solution by transitively following mutables as well.
 
Vars free_vars ()
 
Muts users ()
 Set of mutables where this mutable is locally referenced.
 
bool is_open () const
 Has free_vars()?
 
bool is_closed () const
 Has no free_vars()?
 
bool is_external () const
 
void make_external ()
 
void make_internal ()
 
void transfer_external (Def *to)
 
template<class T = Def>
const T * isa_imm () const
 
template<class T = Def>
const T * as_imm () const
 
template<class T = Def, class R>
const T * isa_imm (R(T::*f)() const) const
 
template<class T = Def, bool invert = false>
T * isa_mut () const
 If this is *mut*able, it will cast constness away and perform a dynamic_cast to T.
 
template<class T = Def, bool invert = false>
T * as_mut () const
 Asserts that this is a mutable, casts constness away and performs a static_cast to T.
 
Dbg dbg () const
 
Loc loc () const
 
Sym sym () const
 
std::string unique_name () const
 name + "_" + Def::gid
 
template<bool Ow = false>
const Defset (Loc l) const
 
template<bool Ow = false>
Defset (Loc l)
 
template<bool Ow = false>
const Defset (Sym s) const
 
template<bool Ow = false>
Defset (Sym s)
 
template<bool Ow = false>
const Defset (std::string s) const
 
template<bool Ow = false>
Defset (std::string s)
 
template<bool Ow = false>
const Defset (Loc l, Sym s) const
 
template<bool Ow = false>
Defset (Loc l, Sym s)
 
template<bool Ow = false>
const Defset (Loc l, std::string s) const
 
template<bool Ow = false>
Defset (Loc l, std::string s)
 
template<bool Ow = false>
const Defset (Dbg d) const
 
template<bool Ow = false>
Defset (Dbg d)
 
const Defdebug_prefix (std::string) const
 
const Defdebug_suffix (std::string) const
 
Defstub (World &w, const Def *type)
 
Defstub (const Def *type)
 
const Defrebuild (World &w, const Def *type, Defs ops) const
 Def::rebuilds this Def while using new_op as substitute for its i'th Def::op.
 
const Defrebuild (const Def *type, Defs ops) const
 
virtual const Defimmutabilize ()
 Tries to make an immutable from a mutable.
 
bool is_immutabilizable ()
 
const Defrefine (size_t i, const Def *new_op) const
 
DefVec reduce (const Def *arg) const
 Rewrites Def::ops by substituting this mutable's Var with arg.
 
DefVec reduce (const Def *arg)
 
const Defreduce (size_t i, const Def *arg) const
 As above but only rewrites this->op(i).
 
virtual const Defcheck (size_t, const Def *def)
 
virtual const Defcheck ()
 
const Defzonk () const
 
void dump () const
 
void dump (int max) const
 
void write (int max) const
 
void write (int max, const char *file) const
 
std::ostream & stream (std::ostream &, int max) const
 
void dot (std::ostream &os, uint32_t max=0xFFFFFF, bool types=false) const
 
void dot (const char *file=nullptr, uint32_t max=0xFFFFFF, bool types=false) const
 Same as above but write to file or std::cout if file is nullptr.
 
void dot (const std::string &file, uint32_t max=0xFFFFFF, bool types=false) const
 
- Protected Attributes inherited from mim::Def
Dbg dbg_
 
union { 
 
NormalizeFn normalizer_
 Axiom only: Axioms use this member to store their normalizer.
 
const Axiomaxiom_
 App only: Curried Apps of Axioms use this member to propagate the Axiom.
 
const Varvar_
 Mutable only: Var of a mutable.
 
Worldworld_
 
};  
 
flags_t flags_
 
u8 curry_ = 0
 
u8 trip_ = 0
 

Detailed Description

Common base for TExtremum.

Definition at line 149 of file lattice.h.

Constructor & Destructor Documentation

◆ Ext()

mim::Ext::Ext ( Node node,
const Def * type )
inlineprotected

Definition at line 151 of file lattice.h.

References mim::Def::node(), and mim::Def::type().


The documentation for this class was generated from the following file: