SYMBOL INDEX (2542 symbols across 188 files)

FILE: compiler/arret_root.rs
  constant ARRET_ROOT_ENV_VAR (line 3) | const ARRET_ROOT_ENV_VAR: &str = "ARRET_ROOT";
  function is_arret_root (line 5) | fn is_arret_root(path: &path::Path) -> bool {
  type InvalidOptionError (line 9) | pub struct InvalidOptionError {
    method invalid_path (line 15) | pub fn invalid_path(&self) -> &path::Path {
  type InvalidEnvVarError (line 20) | pub struct InvalidEnvVarError {
    method env_var_name (line 26) | pub fn env_var_name(&self) -> &'static str {
    method invalid_path (line 31) | pub fn invalid_path(&self) -> &path::Path {
  type FindArretRootError (line 36) | pub enum FindArretRootError {
  function find_arret_root (line 52) | pub fn find_arret_root(

FILE: compiler/codegen/alloc/core.rs
  function init_alloced_box_header (line 14) | fn init_alloced_box_header(
  function gen_stack_alloced_box (line 26) | fn gen_stack_alloced_box<T: boxed::ConstTagged>(
  function gen_heap_alloced_box (line 49) | fn gen_heap_alloced_box<T: boxed::ConstTagged>(
  function gen_alloced_box_with_llvm_type (line 106) | pub fn gen_alloced_box_with_llvm_type<T: boxed::ConstTagged>(
  function gen_alloced_box (line 122) | pub fn gen_alloced_box<T: boxed::ConstTagged>(
  function gen_runtime_heap_alloc (line 144) | fn gen_runtime_heap_alloc(
  function atom_into_active_alloc (line 215) | pub fn atom_into_active_alloc<'op>(

FILE: compiler/codegen/alloc/mod.rs
  type BoxSource (line 15) | pub enum BoxSource {
  type CondPlan (line 22) | pub struct CondPlan<'op> {
  type AllocAtom (line 29) | pub struct AllocAtom<'op> {
  function new (line 39) | fn new(ops_base: &'op [ops::Op]) -> Self {
  function ops (line 46) | pub fn ops(&self) -> &'op [ops::Op] {
  function push_op (line 51) | fn push_op(&mut self) {
  function is_empty (line 55) | fn is_empty(&self) -> bool {
  type ActiveAlloc (line 60) | pub struct ActiveAlloc<'op> {
  function is_empty (line 70) | pub fn is_empty(&self) -> bool {
  function next_box_source (line 74) | pub fn next_box_source(&mut self) -> BoxSource {
  function next_cond_plan (line 78) | pub fn next_cond_plan(&mut self) -> CondPlan<'op> {

FILE: compiler/codegen/alloc/plan.rs
  type AllocInfo (line 8) | struct AllocInfo {
  function op_needs_heap_checkpoint (line 16) | fn op_needs_heap_checkpoint(tcx: &mut TargetCtx, op: &ops::Op) -> bool {
  function op_alloc_info (line 43) | fn op_alloc_info(tcx: &mut TargetCtx, op: &ops::Op) -> Option<AllocInfo> {
  function plan_allocs (line 85) | pub fn plan_allocs<'op>(
  function plan_native_allocs (line 146) | fn plan_native_allocs(ops: &[ops::Op]) -> Vec<AllocAtom<'_>> {
  function empty_ops (line 171) | fn empty_ops() {
  function condless_allocs (line 177) | fn condless_allocs() {
  function non_allocating_cond (line 218) | fn non_allocating_cond() {
  function allocating_cond (line 249) | fn allocating_cond() {

FILE: compiler/codegen/alloc/types.rs
  type PairInput (line 15) | pub struct PairInput {
  type FunThunkInput (line 21) | pub struct FunThunkInput {
  type RecordInput (line 26) | pub struct RecordInput<'rs> {
  function gen_alloc_int (line 31) | pub fn gen_alloc_int(
  function gen_alloc_char (line 49) | pub fn gen_alloc_char(
  function gen_alloc_sym (line 72) | pub fn gen_alloc_sym(
  function gen_alloc_float (line 91) | pub fn gen_alloc_float(
  function gen_alloc_boxed_pair (line 114) | pub fn gen_alloc_boxed_pair(
  function gen_alloc_boxed_fun_thunk (line 149) | pub fn gen_alloc_boxed_fun_thunk(
  function gen_alloc_boxed_record (line 182) | pub fn gen_alloc_boxed_record(

FILE: compiler/codegen/analysis/escape.rs
  type CaptureKind (line 10) | pub enum CaptureKind {
    method capture_for_call_param (line 21) | fn capture_for_call_param(self, return_capture: CaptureKind) -> Captur...
  type Captures (line 32) | pub struct Captures {
    method new (line 37) | pub fn new() -> Captures {
    method add (line 46) | pub fn add(&mut self, reg_id: ops::RegId, capture: CaptureKind) {
    method get (line 60) | pub fn get(&self, reg_id: ops::RegId) -> CaptureKind {
  function infer_param_capture_kind (line 73) | pub fn infer_param_capture_kind(
  function add_static_symbol_call_captures (line 92) | fn add_static_symbol_call_captures(
  type ProgramCaptureCtx (line 111) | struct ProgramCaptureCtx<'of> {
  function add_op_captures (line 120) | fn add_op_captures(&mut self, captures: &mut Captures, ret_type: &RetAbi...
  function captures_for_private_fun_id (line 251) | fn captures_for_private_fun_id(&mut self, private_fun_id: ops::PrivateFu...
  function calc_fun_captures (line 267) | fn calc_fun_captures(&mut self, fun: &ops::Fun) -> Captures {
  type ProgramCaptures (line 278) | pub struct ProgramCaptures {
  function calc_program_captures (line 284) | pub fn calc_program_captures(
  function calc_single_fun_captures (line 311) | fn calc_single_fun_captures(fun: &ops::Fun) -> Captures {
  function infer_param_capture (line 316) | fn infer_param_capture() {
  function empty_fun_captures (line 331) | fn empty_fun_captures() {
  function capture_param_via_ret (line 352) | fn capture_param_via_ret() {
  function capture_param_via_pair (line 373) | fn capture_param_via_pair() {
  function capture_param_via_box_thunk_call (line 407) | fn capture_param_via_box_thunk_call() {
  function capture_param_via_static_symbol_call (line 441) | fn capture_param_via_static_symbol_call() {
  function capture_param_via_cond (line 535) | fn capture_param_via_cond() {

FILE: compiler/codegen/analysis/mod.rs
  type AnalysedMod (line 12) | pub struct AnalysedMod<'of> {
  type AnalysedFun (line 18) | pub struct AnalysedFun<'of> {
  function new (line 24) | pub fn new(
  function private_funs (line 61) | pub fn private_funs(&self) -> impl Iterator<Item = (&ops::PrivateFunId, ...
  function entry_fun (line 65) | pub fn entry_fun(&self) -> &AnalysedFun<'of> {
  function global_interned_names (line 69) | pub fn global_interned_names(&self) -> &BTreeMap<Rc<str>, intern::Intern...

FILE: compiler/codegen/analysis/names.rs
  function add_op_global_interned_names (line 9) | fn add_op_global_interned_names(names: &mut BTreeSet<Rc<str>>, op: &ops:...
  function add_fun_global_interned_names (line 31) | fn add_fun_global_interned_names(fun: &ops::Fun, names: &mut BTreeSet<Rc...
  function calc_program_global_interned_names (line 38) | pub fn calc_program_global_interned_names(
  function simple_global_interned_names (line 69) | fn simple_global_interned_names() {

FILE: compiler/codegen/box_layout.rs
  type BoxLayout (line 17) | pub enum BoxLayout {
    method type_name (line 31) | pub fn type_name(&self) -> &'static [u8] {
    method append_members (line 58) | pub fn append_members(&self, tcx: &mut TargetCtx, members: &mut Vec<LL...
    method from (line 128) | fn from(boxed_abi_type: &BoxedAbiType) -> BoxLayout {

FILE: compiler/codegen/callee.rs
  function gen_static_symbol_entry_point (line 12) | pub fn gen_static_symbol_entry_point(
  function gen_boxed_fun_thunk_entry_point (line 77) | pub fn gen_boxed_fun_thunk_entry_point(
  function callee_takes_task (line 89) | pub fn callee_takes_task(callee: &ops::Callee) -> bool {
  function callee_call_conv (line 97) | pub fn callee_call_conv(mcx: &mut ModCtx<'_, '_, '_>, callee: &ops::Call...

FILE: compiler/codegen/const_gen.rs
  function annotate_private_global (line 16) | pub fn annotate_private_global(llvm_global: LLVMValueRef) {
  function gen_boxed_pair (line 24) | pub fn gen_boxed_pair(
  function gen_boxed_external_str (line 54) | fn gen_boxed_external_str(
  function gen_boxed_inline_str (line 114) | fn gen_boxed_inline_str(
  function gen_boxed_str (line 152) | pub fn gen_boxed_str(
  function gen_boxed_sym (line 163) | pub fn gen_boxed_sym(
  function gen_global_interned_names (line 194) | pub fn gen_global_interned_names<'a>(
  function gen_boxed_int (line 284) | pub fn gen_boxed_int(
  function gen_boxed_float (line 311) | pub fn gen_boxed_float(
  function gen_boxed_char (line 338) | pub fn gen_boxed_char(
  function gen_boxed_nil (line 365) | pub fn gen_boxed_nil(tcx: &mut TargetCtx, mcx: &mut ModCtx<'_, '_, '_>) ...
  function gen_boxed_fun_thunk (line 369) | pub fn gen_boxed_fun_thunk(
  function gen_boxed_record (line 397) | pub fn gen_boxed_record(
  function gen_persistent_vector_leaf (line 497) | fn gen_persistent_vector_leaf(
  function gen_boxed_external_vector (line 537) | fn gen_boxed_external_vector(
  function gen_boxed_inline_vector (line 593) | fn gen_boxed_inline_vector(
  function gen_boxed_vector (line 632) | pub fn gen_boxed_vector(
  function gen_boxed_set (line 650) | pub fn gen_boxed_set(
  function gen_boxed_map (line 693) | pub fn gen_boxed_map(

FILE: compiler/codegen/debug_info.rs
  type DebugInfoBuilder (line 16) | pub struct DebugInfoBuilder<'sl> {
  function new (line 25) | pub fn new(
  function add_compile_unit_metadata (line 51) | fn add_compile_unit_metadata(&mut self, optimised: bool, main_span: Span) {
  function file_metadata (line 84) | pub fn file_metadata(&mut self, file_id: FileId) -> LLVMMetadataRef {
  function placeholder_subroutine_type (line 106) | pub fn placeholder_subroutine_type(
  function add_function_debug_info (line 122) | pub fn add_function_debug_info(
  function finalise (line 178) | pub fn finalise(&mut self) {
  method drop (line 186) | fn drop(&mut self) {

FILE: compiler/codegen/fun_gen.rs
  type FunCtx (line 16) | pub(crate) struct FunCtx {
    method new (line 25) | pub(crate) fn new(
  method drop (line 41) | fn drop(&mut self) {
  function declare_fun (line 48) | pub(crate) fn declare_fun(
  function define_fun (line 75) | pub(crate) fn define_fun(

FILE: compiler/codegen/jit.rs
  function orc_sym_resolve (line 19) | extern "C" fn orc_sym_resolve(name_ptr: *const libc::c_char, jcx_void: *...
  type JitCtx (line 30) | pub struct JitCtx {
    method new (line 48) | pub fn new(optimising: bool) -> JitCtx {
    method compile_fun (line 94) | pub fn compile_fun(
    method add_symbol (line 169) | pub fn add_symbol(&mut self, unmangled_name: &[u8], address: u64) {
    method register_record_struct (line 185) | pub fn register_record_struct(
  type RegisteredRecordStruct (line 40) | pub struct RegisteredRecordStruct {
  method drop (line 205) | fn drop(&mut self) {

FILE: compiler/codegen/math_gen.rs
  type CheckedIntOp (line 11) | pub struct CheckedIntOp {
  constant CHECKED_ADD (line 17) | pub const CHECKED_ADD: CheckedIntOp = CheckedIntOp {
  constant CHECKED_SUB (line 23) | pub const CHECKED_SUB: CheckedIntOp = CheckedIntOp {
  constant CHECKED_MUL (line 29) | pub const CHECKED_MUL: CheckedIntOp = CheckedIntOp {
  function gen_checked_int_math (line 35) | pub(crate) fn gen_checked_int_math(
  function gen_checked_int_rem (line 114) | pub(crate) fn gen_checked_int_rem(
  function gen_checked_int_div (line 153) | pub(crate) fn gen_checked_int_div(
  function gen_float_sqrt (line 240) | pub(crate) fn gen_float_sqrt(

FILE: compiler/codegen/mod.rs
  type GenAbi (line 25) | pub struct GenAbi {
    method thunk_abi (line 32) | pub fn thunk_abi() -> GenAbi {
    method from (line 45) | fn from(ops_abi: &'a OpsAbi) -> GenAbi {
  function initialise_llvm (line 62) | pub fn initialise_llvm(support_cross_compilation: bool) {
  function initialise_test_llvm (line 85) | pub fn initialise_test_llvm() {

FILE: compiler/codegen/mod_gen.rs
  type ModCtx (line 19) | pub struct ModCtx<'am, 'sl, 'interner> {
  type GeneratedMod (line 37) | pub struct GeneratedMod {
  function new (line 50) | fn new(
  function intern_name (line 119) | pub fn intern_name(&mut self, name: &str) -> intern::InternedSym {
  function record_class_id_for_struct (line 133) | pub fn record_class_id_for_struct(
  function add_record_class_id_range_metadata (line 149) | pub fn add_record_class_id_range_metadata(&mut self, record_class_id_llv...
  function llvm_private_fun (line 156) | pub fn llvm_private_fun(&self, private_fun_id: ops::PrivateFunId) -> LLV...
  function get_global_or_insert (line 160) | pub fn get_global_or_insert<F>(
  function get_function_or_insert (line 183) | pub fn get_function_or_insert<F>(
  function optimise_function (line 206) | pub fn optimise_function(&mut self, function: LLVMValueRef) {
  function finalise_record_class_id_range_metadata (line 212) | fn finalise_record_class_id_range_metadata(&mut self, tcx: &mut TargetCt...
  function into_generated_mod (line 250) | fn into_generated_mod(mut self, tcx: &mut TargetCtx) -> GeneratedMod {
  function gen_mod (line 322) | pub fn gen_mod<'am, 'sl, 'interner>(
  method drop (line 342) | fn drop(&mut self) {

FILE: compiler/codegen/op_gen.rs
  function comparison_to_llvm_int_pred (line 18) | fn comparison_to_llvm_int_pred(comparison: Comparison) -> LLVMIntPredica...
  function comparison_to_llvm_real_pred (line 28) | fn comparison_to_llvm_real_pred(comparison: Comparison) -> LLVMRealPredi...
  function gen_int_compare (line 38) | fn gen_int_compare(
  function gen_op (line 60) | fn gen_op(
  function gen_cond_branch (line 1022) | fn gen_cond_branch(
  function gen_cond (line 1050) | fn gen_cond(
  function gen_callee_entry_point (line 1120) | fn gen_callee_entry_point(
  function gen_alloc_atom (line 1140) | pub(crate) fn gen_alloc_atom(

FILE: compiler/codegen/panic_gen.rs
  function gen_panic (line 10) | pub(crate) fn gen_panic(

FILE: compiler/codegen/program.rs
  type OutputType (line 20) | pub enum OutputType {
  type Options (line 29) | pub struct Options<'target> {
  function new (line 36) | pub fn new() -> Options<'static> {
  function with_target_triple (line 44) | pub fn with_target_triple(self, target_triple: Option<&'target str>) -> ...
  function with_llvm_opt (line 51) | pub fn with_llvm_opt(self, llvm_opt: bool) -> Options<'target> {
  function with_output_type (line 55) | pub fn with_output_type(self, output_type: OutputType) -> Options<'targe...
  function output_type (line 62) | pub fn output_type(&self) -> OutputType {
  method default (line 68) | fn default() -> Options<'static> {
  function arret_main_llvm_type (line 73) | fn arret_main_llvm_type(tcx: &mut TargetCtx) -> LLVMTypeRef {
  function c_main_llvm_type (line 86) | fn c_main_llvm_type(tcx: &mut TargetCtx) -> LLVMTypeRef {
  function program_to_module (line 103) | fn program_to_module(
  function target_triple_to_cc_args (line 179) | fn target_triple_to_cc_args(target_triple: &str) -> Vec<&str> {
  function gen_program (line 193) | pub fn gen_program(

FILE: compiler/codegen/range_md.rs
  type Int (line 7) | type Int = i64;
  type IntRangeIter (line 9) | struct IntRangeIter<I>
  type Item (line 20) | type Item = Range<Int>;
  method next (line 22) | fn next(&mut self) -> Option<Range<Int>> {
  function find_int_ranges (line 36) | fn find_int_ranges(input: impl Iterator<Item = Int>) -> impl Iterator<It...
  function int_range_md_node (line 45) | pub fn int_range_md_node(
  function empty (line 66) | fn empty() {
  function single_value (line 72) | fn single_value() {
  function single_range (line 80) | fn single_range() {
  function multi_range (line 88) | fn multi_range() {

FILE: compiler/codegen/record_struct.rs
  constant IS_INLINE_INDEX (line 15) | pub const IS_INLINE_INDEX: u32 = 1;
  constant CONTAINS_GC_REFS_INDEX (line 16) | pub const CONTAINS_GC_REFS_INDEX: u32 = 2;
  constant RECORD_CLASS_ID_INDEX (line 17) | pub const RECORD_CLASS_ID_INDEX: u32 = 3;
  constant DATA_INDEX (line 18) | pub const DATA_INDEX: u32 = 4;
  constant EXTERNAL_COMPACT_LAYOUT_INDEX (line 19) | pub const EXTERNAL_COMPACT_LAYOUT_INDEX: u32 = 5;
  function append_common_internal_members (line 22) | pub fn append_common_internal_members(tcx: &mut TargetCtx, members: &mut...
  type TargetRecordStruct (line 36) | pub struct TargetRecordStruct {
    method from_mir_record_struct (line 44) | pub fn from_mir_record_struct(
  function gen_classmap_classes (line 104) | pub fn gen_classmap_classes(
  function gen_record_field_ptr (line 204) | pub fn gen_record_field_ptr(

FILE: compiler/codegen/target_gen.rs
  function llvm_enum_attr_for_name (line 19) | fn llvm_enum_attr_for_name(
  function llvm_md_kind_id_for_name (line 31) | fn llvm_md_kind_id_for_name(llx: LLVMContextRef, md_name: &str) -> u32 {
  function llvm_i64_md_node (line 35) | fn llvm_i64_md_node(llx: LLVMContextRef, values: &[u64]) -> LLVMMetadata...
  type CachedTypes (line 50) | struct CachedTypes {
  type TargetCtx (line 83) | pub struct TargetCtx {
    method new (line 113) | pub fn new(target_machine: LLVMTargetMachineRef, optimising: bool) -> ...
    method optimising (line 168) | pub fn optimising(&self) -> bool {
    method target_machine (line 172) | pub fn target_machine(&self) -> LLVMTargetMachineRef {
    method target_data (line 176) | pub fn target_data(&self) -> LLVMTargetDataRef {
    method task_llvm_ptr_type (line 180) | pub fn task_llvm_ptr_type(&mut self) -> LLVMTypeRef {
    method global_interned_name_llvm_type (line 193) | pub fn global_interned_name_llvm_type(&mut self) -> LLVMTypeRef {
    method classmap_field_llvm_type (line 211) | pub fn classmap_field_llvm_type(&mut self) -> LLVMTypeRef {
    method classmap_class_llvm_type (line 229) | pub fn classmap_class_llvm_type(&mut self) -> LLVMTypeRef {
    method captures_llvm_type (line 233) | pub fn captures_llvm_type(&mut self) -> LLVMTypeRef {
    method record_class_id_llvm_type (line 237) | pub fn record_class_id_llvm_type(&self) -> LLVMTypeRef {
    method box_header_llvm_type (line 241) | fn box_header_llvm_type(&mut self) -> LLVMTypeRef {
    method shared_str_llvm_type (line 254) | pub fn shared_str_llvm_type(&mut self) -> LLVMTypeRef {
    method boxed_external_str_llvm_type (line 277) | pub fn boxed_external_str_llvm_type(&mut self) -> LLVMTypeRef {
    method boxed_inline_str_llvm_type (line 300) | pub fn boxed_inline_str_llvm_type(&mut self) -> LLVMTypeRef {
    method persistent_vector_leaf_llvm_type (line 322) | pub fn persistent_vector_leaf_llvm_type(&mut self) -> LLVMTypeRef {
    method boxed_external_vector_llvm_type (line 343) | pub fn boxed_external_vector_llvm_type(&mut self) -> LLVMTypeRef {
    method boxed_inline_vector_llvm_type (line 371) | pub fn boxed_inline_vector_llvm_type(&mut self) -> LLVMTypeRef {
    method boxed_abi_to_llvm_struct_type (line 397) | pub fn boxed_abi_to_llvm_struct_type(&mut self, boxed_abi_type: &Boxed...
    method callback_entry_point_llvm_type (line 419) | fn callback_entry_point_llvm_type(
    method callback_llvm_type (line 450) | pub fn callback_llvm_type(&mut self, entry_point_llvm_type: LLVMTypeRe...
    method boxed_abi_to_llvm_ptr_type (line 459) | pub fn boxed_abi_to_llvm_ptr_type(&mut self, boxed_abi_type: &BoxedAbi...
    method abi_to_llvm_type (line 463) | pub fn abi_to_llvm_type(&mut self, abi_type: &AbiType) -> LLVMTypeRef {
    method ret_abi_to_llvm_type (line 481) | fn ret_abi_to_llvm_type(&mut self, ret_abi_type: &RetAbiType) -> LLVMT...
    method fun_abi_to_llvm_type (line 488) | pub fn fun_abi_to_llvm_type(&mut self, fun_abi: &GenAbi) -> LLVMTypeRef {
    method target_record_struct (line 514) | pub fn target_record_struct<'a>(
    method record_struct_llvm_box_type (line 530) | pub fn record_struct_llvm_box_type(
    method ptr_to_singleton_box (line 585) | pub fn ptr_to_singleton_box(
    method llvm_box_header (line 616) | pub fn llvm_box_header(&mut self, header: boxed::Header) -> LLVMValueR...
    method llvm_enum_attr_for_name (line 630) | pub fn llvm_enum_attr_for_name(
    method llvm_md_kind_id_for_name (line 638) | pub fn llvm_md_kind_id_for_name(&mut self, md_name: &str) -> u32 {
    method llvm_boxed_align_attr (line 642) | pub fn llvm_boxed_align_attr(&self) -> LLVMAttributeRef {
    method llvm_noalias_attr (line 646) | pub fn llvm_noalias_attr(&self) -> LLVMAttributeRef {
    method add_invariant_load_metadata (line 650) | pub fn add_invariant_load_metadata(&self, loaded_value: LLVMValueRef) {
    method add_char_codepoint_range_metadata (line 661) | pub fn add_char_codepoint_range_metadata(&mut self, llvm_value: LLVMVa...
    method add_boxed_param_attrs (line 686) | pub fn add_boxed_param_attrs(
    method add_boxed_return_attrs (line 709) | pub fn add_boxed_return_attrs(&mut self, function: LLVMValueRef) {
    method add_boxed_load_metadata (line 721) | pub fn add_boxed_load_metadata(&mut self, loaded_value: LLVMValueRef) {
    method finish_module (line 739) | pub fn finish_module(&mut self, module: LLVMModuleRef) {
  method drop (line 766) | fn drop(&mut self) {

FILE: compiler/codegen/target_machine.rs
  type TripleString (line 6) | enum TripleString {
    method as_ptr (line 12) | fn as_ptr(&self) -> *const libc::c_char {
  method drop (line 21) | fn drop(&mut self) {
  function create_target_machine (line 30) | pub fn create_target_machine(

FILE: compiler/codegen/vector_gen.rs
  function load_boxed_external_vector_len (line 11) | fn load_boxed_external_vector_len(
  function load_boxed_vector_len (line 45) | pub(crate) fn load_boxed_vector_len(
  function load_boxed_inline_vector_member (line 160) | fn load_boxed_inline_vector_member(
  function load_boxed_external_vector_member (line 192) | fn load_boxed_external_vector_member(
  function load_boxed_vector_member (line 270) | pub(crate) fn load_boxed_vector_member(

FILE: compiler/context.rs
  type ModuleImports (line 33) | pub(crate) type ModuleImports = HashMap<ModuleName, Arc<Module>>;
  type LinkedLibrary (line 35) | pub struct LinkedLibrary {
    method target_path (line 41) | pub fn target_path(&self) -> &path::Path {
  type Module (line 49) | pub(crate) struct Module {
    method hash (line 70) | fn hash<H: hash::Hasher>(&self, state: &mut H) {
  method eq (line 62) | fn eq(&self, other: &Self) -> bool {
  type CachedModule (line 75) | type CachedModule = Result<Arc<Module>, Vec<Diagnostic<FileId>>>;
  type UncachedModule (line 76) | type UncachedModule = Result<Module, Vec<Diagnostic<FileId>>>;
  function transitive_deps (line 81) | fn transitive_deps(imports: &ModuleImports) -> HashSet<Arc<Module>> {
  function prims_to_module (line 91) | pub(crate) fn prims_to_module(exports: Exports) -> Module {
  function rfi_library_to_module (line 105) | fn rfi_library_to_module(span: Span, rfi_library: rfi::Library) -> Module {
  type CompileCtx (line 172) | pub struct CompileCtx {
    method new (line 183) | pub fn new(package_paths: PackagePaths, enable_optimisations: bool) ->...
    method package_paths (line 213) | pub fn package_paths(&self) -> &PackagePaths {
    method enable_optimisations (line 217) | pub fn enable_optimisations(&self) -> bool {
    method source_loader (line 221) | pub fn source_loader(&self) -> &SourceLoader {
    method rfi_loader (line 225) | pub(crate) fn rfi_loader(&self) -> &rfi::Loader {
    method get_module_by_name (line 234) | fn get_module_by_name(&self, span: Span, module_name: ModuleName) -> C...
    method source_file_to_module (line 251) | pub(crate) fn source_file_to_module(&self, source_file: &SourceFile) -...
    method imports_for_data (line 262) | pub(crate) fn imports_for_data<'a>(
    method data_to_module (line 299) | fn data_to_module(&self, data: &[Datum]) -> UncachedModule {

FILE: compiler/hir/destruc.rs
  type Destruc (line 9) | pub enum Destruc<P: hir::Phase> {
  type List (line 15) | pub struct List<P: hir::Phase> {
  function new (line 21) | pub fn new(fixed: Vec<Destruc<P>>, rest: Option<Box<Scalar<P>>>) -> List...
  function fixed (line 25) | pub fn fixed(&self) -> &Vec<Destruc<P>> {
  function rest (line 29) | pub fn rest(&self) -> &Option<Box<Scalar<P>>> {
  type Scalar (line 35) | pub struct Scalar<P: hir::Phase> {
  function new (line 43) | pub fn new(local_id: Option<hir::LocalId>, source_name: DataStr, ty: P::...
  function local_id (line 51) | pub fn local_id(&self) -> &Option<hir::LocalId> {
  function source_name (line 55) | pub fn source_name(&self) -> &DataStr {
  function ty (line 59) | pub fn ty(&self) -> &P::DeclType {
  function subst_list_destruc (line 64) | pub fn subst_list_destruc(
  function subst_scalar_destruc (line 81) | pub fn subst_scalar_destruc(
  function subst_destruc (line 103) | pub fn subst_destruc(
  function poly_for_list_destruc (line 115) | pub fn poly_for_list_destruc(list: &List<hir::Inferred>) -> ty::List<ty:...
  function poly_for_destruc (line 126) | pub fn poly_for_destruc(destruc: &Destruc<hir::Inferred>) -> ty::Ref<ty:...

FILE: compiler/hir/error.rs
  type ExpectedSym (line 17) | pub struct ExpectedSym {
  type PolyArgIsNotTy (line 23) | pub struct PolyArgIsNotTy {
  type PolyArgIsNotPure (line 30) | pub struct PolyArgIsNotPure {
  type ExpectedPolyPurityArg (line 36) | pub struct ExpectedPolyPurityArg {
  type ErrorKind (line 42) | pub enum ErrorKind {
  type Error (line 109) | pub struct Error {
    method new (line 117) | pub fn new(span: Span, kind: ErrorKind) -> Error {
    method kind (line 124) | pub fn kind(&self) -> &ErrorKind {
    method from_module_io (line 128) | pub fn from_module_io(span: Span, path: &path::Path, error: &io::Error...
    method with_macro_invocation_span (line 135) | pub fn with_macro_invocation_span(self, span: Span) -> Error {
    method fmt (line 632) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 639) | fn from(err: SyntaxError) -> Error {
  type Result (line 114) | pub type Result<T, E = Error> = result::Result<T, E>;
  function from (line 144) | fn from(error: Error) -> Diagnostic<FileId> {
  function from (line 645) | fn from(error: Error) -> Vec<Error> {

FILE: compiler/hir/exports.rs
  type Exports (line 9) | pub type Exports = HashMap<DataStr, Binding>;
  function prims_exports (line 11) | pub fn prims_exports() -> Exports {
  function tys_exports (line 18) | pub fn tys_exports() -> Exports {

FILE: compiler/hir/import/filter.rs
  type Result (line 7) | type Result<T> = result::Result<T, Vec<Error>>;
  function apply_filter (line 9) | fn apply_filter(filter: ParsedFilter, exports: &Exports) -> Result<Expor...
  function filter_imported_exports (line 72) | pub fn filter_imported_exports(

FILE: compiler/hir/import/mod.rs
  function try_extract_import_set (line 15) | pub fn try_extract_import_set(datum: &Datum) -> Option<&[Datum]> {
  function collect_imported_module_names (line 30) | pub fn collect_imported_module_names<'a>(
  type Result (line 74) | type Result<T> = result::Result<T, Vec<Error>>;
  function exports_for_import_set (line 76) | fn exports_for_import_set(datum: &str) -> Result<Exports> {
  function assert_exports_prim (line 93) | fn assert_exports_prim(exports: &Exports, name: &'static str, expected_p...
  function basic_import (line 108) | fn basic_import() {
  function package_not_found (line 117) | fn package_not_found() {
  function only_filter (line 127) | fn only_filter() {
  function exclude_filter (line 142) | fn exclude_filter() {
  function rename_filter (line 157) | fn rename_filter() {
  function prefix_filter (line 172) | fn prefix_filter() {
  function prefixed_filter (line 181) | fn prefixed_filter() {

FILE: compiler/hir/import/parse.rs
  type Result (line 10) | type Result<T> = result::Result<T, Error>;
  type ParsedImportSet (line 12) | pub enum ParsedImportSet {
    method into_spanned_module_name (line 18) | pub fn into_spanned_module_name(self) -> (Span, ModuleName) {
    method spanned_module_name (line 25) | pub fn spanned_module_name(&self) -> (Span, &ModuleName) {
    method module_name (line 32) | pub fn module_name(&self) -> &ModuleName {
  type ParsedFilter (line 37) | pub enum ParsedFilter {
  function parse_module_name (line 44) | fn parse_module_name(span: Span, name: &[Datum]) -> Result<ModuleName> {
  function parse_filter (line 64) | fn parse_filter(
  function parse_import_set (line 147) | pub fn parse_import_set(import_set_datum: &Datum) -> Result<ParsedImport...

FILE: compiler/hir/loader.rs
  type PackagePath (line 12) | pub struct PackagePath {
  type PackagePaths (line 18) | pub struct PackagePaths {
    method empty (line 23) | pub fn empty() -> PackagePaths {
    method with_stdlib (line 30) | pub fn with_stdlib(arret_root_dir: &path::Path, target_triple: Option<...
    method test_paths (line 51) | pub fn test_paths(target_triple: Option<&str>) -> PackagePaths {
    method add_package (line 56) | pub fn add_package(&mut self, package_name: &str, path: PackagePath) {
  type ModuleName (line 62) | pub struct ModuleName {
    method new (line 75) | pub fn new(package_name: DataStr, path: Vec<DataStr>, terminal_name: D...
    method is_rfi (line 83) | pub fn is_rfi(&self) -> bool {
    method terminal_name (line 87) | pub fn terminal_name(&self) -> &DataStr {
  type LoadedModule (line 69) | pub enum LoadedModule {
  function load_module_by_name (line 92) | pub fn load_module_by_name(
  function load_stdlib_module (line 144) | fn load_stdlib_module(name: &'static str) -> Result<LoadedModule> {
  function load_stdlib_base (line 152) | fn load_stdlib_base() {
  function load_stdlib_rust (line 163) | fn load_stdlib_rust() {
  function load_stdlib_missing (line 177) | fn load_stdlib_missing() {

FILE: compiler/hir/lowering.rs
  type LoweredModule (line 34) | pub struct LoweredModule {
  type DeferredDef (line 42) | struct DeferredDef {
  type DeferredExport (line 49) | struct DeferredExport {
  type DeferredModulePrim (line 54) | enum DeferredModulePrim {
    method with_macro_invocation_span (line 60) | fn with_macro_invocation_span(self, span: Span) -> DeferredModulePrim {
  type LoweredReplDatum (line 71) | pub(crate) enum LoweredReplDatum {
  function lower_user_compile_error (line 83) | fn lower_user_compile_error(span: Span, arg_iter: NsDataIter) -> Error {
  function lower_macro (line 94) | fn lower_macro(
  function lower_defmacro (line 130) | fn lower_defmacro(scope: &mut Scope<'_>, span: Span, mut arg_iter: NsDat...
  function lower_letmacro (line 144) | fn lower_letmacro(
  function lower_type (line 153) | fn lower_type(scope: &mut Scope<'_>, self_datum: NsDatum, ty_datum: NsDa...
  function lower_deftype (line 161) | fn lower_deftype(scope: &mut Scope<'_>, span: Span, mut arg_iter: NsData...
  function lower_lettype (line 172) | fn lower_lettype(
  function lower_defrecord (line 181) | fn lower_defrecord(scope: &mut Scope<'_>, span: Span, mut arg_iter: NsDa...
  function lower_letrecord (line 192) | fn lower_letrecord(
  function lower_ident_destruc (line 202) | fn lower_ident_destruc(
  function lower_scalar_destruc (line 221) | fn lower_scalar_destruc(
  function lower_list_destruc (line 244) | fn lower_list_destruc(
  function lower_destruc (line 263) | fn lower_destruc(
  function lower_let_like (line 291) | fn lower_let_like<B, C, O>(
  function lower_body (line 334) | fn lower_body(
  function lower_let (line 362) | fn lower_let(
  function lower_fun (line 390) | fn lower_fun(
  function lower_expr_prim_apply (line 460) | fn lower_expr_prim_apply(
  function lower_expr_apply (line 503) | fn lower_expr_apply(
  function lower_recur (line 531) | fn lower_recur(
  function lower_expr (line 556) | fn lower_expr(lia: &LocalIdAlloc, scope: &Scope<'_>, datum: NsDatum) -> ...
  function lower_module_prim_apply (line 621) | fn lower_module_prim_apply(
  function lower_module_def (line 669) | fn lower_module_def(
  function insert_import_bindings (line 710) | fn insert_import_bindings(
  function lower_data (line 737) | pub(crate) fn lower_data(
  function resolve_deferred_def (line 826) | fn resolve_deferred_def(
  function lower_repl_datum (line 847) | pub(crate) fn lower_repl_datum(
  function import_statement_for_module (line 898) | fn import_statement_for_module(names: &[&'static str]) -> Datum {
  function module_for_str (line 915) | fn module_for_str(data_str: &str) -> Result<LoweredModule> {
  function expr_for_str (line 959) | pub fn expr_for_str(data_str: &str) -> Expr<Lowered> {
  function self_quoting_bool (line 982) | fn self_quoting_bool() {
  function self_quoting_empty_list (line 991) | fn self_quoting_empty_list() {
  function quoted_datum_shorthand (line 1000) | fn quoted_datum_shorthand() {
  function quoted_datum_explicit (line 1009) | fn quoted_datum_explicit() {
  function self_evaluating_keyword (line 1018) | fn self_evaluating_keyword() {
  function wildcard_let (line 1027) | fn wildcard_let() {
  function empty_fn (line 1048) | fn empty_fn() {
  function empty_fn_with_purity (line 1068) | fn empty_fn_with_purity() {
  function empty_fn_with_ret_ty (line 1089) | fn empty_fn_with_ret_ty() {
  function fixed_expr_apply (line 1111) | fn fixed_expr_apply() {
  function rest_expr_apply (line 1131) | fn rest_expr_apply() {
  function recur_expr (line 1151) | fn recur_expr() {
  function if_expr (line 1173) | fn if_expr() {
  function expand_trivial_macro (line 1192) | fn expand_trivial_macro() {
  function mutual_module_def (line 1203) | fn mutual_module_def() {
  function type_predicate (line 1215) | fn type_predicate() {
  function equality_predicate (line 1224) | fn equality_predicate() {

FILE: compiler/hir/macros/expander.rs
  type ExpandCursor (line 13) | struct ExpandCursor<'data, 'links> {
  type ExpandCtx (line 21) | struct ExpandCtx<'scope, 'parent> {
  function new (line 28) | fn new(scope: &'scope mut Scope<'parent>, module_id: Option<ModuleId>) -...
  function expand_ident (line 36) | fn expand_ident(
  function expand_zero_or_more (line 80) | fn expand_zero_or_more(
  function expand_slice (line 111) | fn expand_slice(
  function expand_list (line 137) | fn expand_list(
  function expand_datum (line 151) | fn expand_datum(
  function expand_rule (line 169) | pub fn expand_rule<'scope, 'parent, 'data>(

FILE: compiler/hir/macros/linker.rs
  type TemplateIdent (line 13) | pub enum TemplateIdent {
  type VarLinks (line 26) | pub struct VarLinks {
    method subpattern_index (line 34) | pub fn subpattern_index(&self) -> usize {
    method template_ident (line 39) | pub fn template_ident(&self, i: usize) -> &TemplateIdent {
    method subtemplates (line 44) | pub fn subtemplates(&self) -> &[VarLinks] {
  type FoundVars (line 50) | struct FoundVars<'data> {
  function new (line 57) | fn new(span: Span) -> Self {
  type FindVarsInputType (line 68) | enum FindVarsInputType {
  type FindVarsCtx (line 73) | struct FindVarsCtx<'data> {
  type FindVarsResult (line 78) | type FindVarsResult = result::Result<(), Error>;
  function new (line 81) | fn new(input_type: FindVarsInputType) -> Self {
  function visit_ident (line 98) | fn visit_ident(
  function visit_zero_or_more (line 126) | fn visit_zero_or_more(
  function visit_datum (line 138) | fn visit_datum(
  function visit_seq (line 155) | fn visit_seq(
  function visit_list (line 188) | fn visit_list(
  function visit_set (line 209) | fn visit_set(
  function link_template_ident (line 230) | fn link_template_ident(
  function link_found_vars (line 251) | fn link_found_vars(
  function link_rule_vars (line 323) | pub fn link_rule_vars(

FILE: compiler/hir/macros/matcher.rs
  type MatchData (line 7) | pub struct MatchData<'data> {
  function new (line 14) | fn new() -> MatchData<'data> {
  function var (line 21) | pub fn var(&self, i: usize) -> &'data NsDatum {
  function subpattern (line 25) | pub fn subpattern(&self, i: usize) -> &[MatchData<'data>] {
  type MatchCtx (line 30) | struct MatchCtx<'data> {
  type Result (line 34) | type Result<T> = result::Result<T, ()>;
  function new (line 37) | fn new() -> Self {
  function match_ident (line 43) | fn match_ident(&mut self, pattern_ident: &'data Ident, arg: &'data NsDat...
  function match_datum (line 55) | fn match_datum(&mut self, pattern: &'data NsDatum, arg: &'data NsDatum) ...
  function match_zero_or_more (line 79) | fn match_zero_or_more(&mut self, pattern: &'data NsDatum, args: &'data [...
  function match_slice (line 104) | fn match_slice(&mut self, mut patterns: &'data [NsDatum], mut args: &'da...
  function visit_rule (line 144) | fn visit_rule(
  function match_rule (line 157) | pub fn match_rule<'data>(

FILE: compiler/hir/macros/mod.rs
  type Rule (line 18) | pub struct Rule {
  type Macro (line 26) | pub struct Macro {
    method new (line 31) | pub fn new(rules: Box<[Rule]>) -> Arc<Self> {
  function starts_with_zero_or_more (line 36) | fn starts_with_zero_or_more(data: &[NsDatum]) -> bool {
  function get_escaped_ident (line 43) | fn get_escaped_ident(data: &[NsDatum]) -> Option<&Ident> {
  function lower_macro_rule_datum (line 54) | fn lower_macro_rule_datum(
  function lower_macro_rules (line 97) | pub fn lower_macro_rules(
  function expand_macro (line 110) | pub fn expand_macro<'s, 'p>(

FILE: compiler/hir/mod.rs
  type DeclTy (line 34) | pub enum DeclTy {
    method from (line 40) | fn from(ty: Ty<ty::Poly>) -> Self {
    method from (line 46) | fn from(poly: ty::Ref<ty::Poly>) -> Self {
  type DeclPurity (line 56) | pub enum DeclPurity {
    method from (line 62) | fn from(poly: purity::Ref) -> Self {
    method from (line 69) | fn from(purity: purity::Purity) -> Self {
  type Phase (line 74) | pub trait Phase: Clone + std::cmp::PartialEq + std::fmt::Debug {
    type Purity (line 84) | type Purity = purity::Ref;
    type DeclType (line 85) | type DeclType = ty::Ref<ty::Poly>;
    type ResultType (line 86) | type ResultType = ty::Ref<ty::Poly>;
    type TyArgs (line 87) | type TyArgs = ty::ty_args::TyArgs<ty::Poly>;
    type Purity (line 93) | type Purity = DeclPurity;
    type DeclType (line 94) | type DeclType = DeclTy;
    type ResultType (line 95) | type ResultType = ();
    type TyArgs (line 96) | type TyArgs = ();
  type Inferred (line 82) | pub struct Inferred {}
  type Lowered (line 91) | pub struct Lowered {}
  type Fun (line 100) | pub struct Fun<P: Phase> {
  type Cond (line 116) | pub struct Cond<P: Phase> {
  type Let (line 124) | pub struct Let<P: Phase> {
  type App (line 132) | pub struct App<P: Phase> {
  type Recur (line 141) | pub struct Recur<P: Phase> {
  type FieldAccessor (line 148) | pub struct FieldAccessor {
  type Expr (line 155) | pub struct Expr<P: Phase> {
  function from (line 161) | fn from(datum: Datum) -> Expr<Lowered> {
  type ExprKind (line 167) | pub enum ExprKind<P: Phase> {
  function from (line 192) | fn from(kind: ExprKind<Lowered>) -> Expr<Lowered> {
  type Def (line 201) | pub struct Def<P: Phase> {

FILE: compiler/hir/ns.rs
  type Ident (line 11) | pub struct Ident {
    method new (line 17) | pub fn new(ns_id: NsId, data_name: DataStr) -> Ident {
    method ns_id (line 21) | pub fn ns_id(&self) -> NsId {
    method name (line 25) | pub fn name(&self) -> &DataStr {
    method into_name (line 29) | pub fn into_name(self) -> DataStr {
    method is_underscore (line 33) | pub fn is_underscore(&self) -> bool {
    method is_ellipsis (line 37) | pub fn is_ellipsis(&self) -> bool {
    method is_ampersand (line 41) | pub fn is_ampersand(&self) -> bool {
    method with_ns_id (line 45) | pub fn with_ns_id(&self, new_ns_id: NsId) -> Ident {
  type NsDatum (line 54) | pub enum NsDatum {
    method map_syntax_data (line 69) | fn map_syntax_data(vs: &[Datum]) -> Box<[NsDatum]> {
    method from_syntax_datum (line 73) | pub fn from_syntax_datum(value: &Datum) -> NsDatum {
    method map_nsdata (line 99) | fn map_nsdata(vs: Box<[NsDatum]>) -> Box<[Datum]> {
    method into_syntax_datum (line 106) | pub fn into_syntax_datum(self) -> Datum {
    method span (line 128) | pub fn span(&self) -> Span {
    method description (line 144) | pub fn description(&self) -> &'static str {
  type NsDataIter (line 174) | pub type NsDataIter = vec::IntoIter<NsDatum>;

FILE: compiler/hir/records.rs
  type LoweredRecordCons (line 15) | enum LoweredRecordCons {
  function lower_record_field_decl (line 20) | fn lower_record_field_decl(scope: &Scope<'_>, field_datum: NsDatum) -> R...
  function lower_record_cons_decl (line 53) | fn lower_record_cons_decl<F>(cons_datum: NsDatum, error_kind_cons: F) ->...
  function lower_record (line 81) | pub fn lower_record(

FILE: compiler/hir/scope.rs
  type Binding (line 17) | pub enum Binding {
    method description (line 32) | pub fn description(&self) -> &'static str {
    method import_from (line 46) | pub fn import_from(&self, module_id: ModuleId) -> Binding {
  type SpannedBinding (line 55) | pub struct SpannedBinding {
  type Scope (line 60) | pub struct Scope<'parent> {
  function root_ns_id (line 68) | pub fn root_ns_id() -> NsId {
  function new_with_entries (line 73) | pub fn new_with_entries<I>(entries: I) -> Scope<'static>
  function root (line 97) | pub fn root() -> Scope<'static> {
  function new_with_primitives (line 104) | pub fn new_with_primitives() -> Scope<'static> {
  function child (line 116) | pub fn child(&'parent self) -> Scope<'parent> {
  function get_datum (line 127) | pub fn get_datum<'a>(&'a self, datum: &NsDatum) -> Option<&'a Binding> {
  function get (line 136) | pub fn get<'a>(&'a self, ident: &Ident) -> Option<&'a Binding> {
  function get_or_err (line 147) | pub fn get_or_err<'a>(&'a self, span: Span, ident: &Ident) -> Result<&'a...
  function insert_binding (line 153) | pub fn insert_binding(
  function insert_bindings (line 163) | pub fn insert_bindings<I>(&mut self, span: Span, new_bindings: I) -> Res...
  function replace_binding (line 193) | pub fn replace_binding(&mut self, span: Span, ident: Ident, binding: Bin...
  function insert_local (line 203) | pub fn insert_local(
  function bound_idents (line 213) | pub fn bound_idents(&self) -> impl Iterator<Item = &Ident> {
  function alloc_ns_id (line 220) | pub fn alloc_ns_id(&mut self) -> NsId {
  function into_exported_bindings (line 227) | pub fn into_exported_bindings(self) -> HashMap<Ident, SpannedBinding> {
  function import_bindings (line 231) | pub fn import_bindings(

FILE: compiler/hir/types.rs
  type TyCons (line 20) | pub enum TyCons {
  type PolymorphicVar (line 32) | pub enum PolymorphicVar {
  type LoweredPolymorphicVar (line 39) | struct LoweredPolymorphicVar {
  function lower_polymorphic_var (line 44) | fn lower_polymorphic_var(scope: &Scope<'_>, tvar_datum: NsDatum) -> Resu...
  function lower_list_cons (line 122) | fn lower_list_cons(scope: &Scope<'_>, mut arg_iter: NsDataIter) -> Resul...
  function lower_fun_cons (line 137) | fn lower_fun_cons(
  function lower_ty_cons_apply (line 162) | fn lower_ty_cons_apply(
  function lower_record_ty_cons_purity_arg (line 213) | fn lower_record_ty_cons_purity_arg(
  function lower_record_ty_cons_apply (line 231) | fn lower_record_ty_cons_apply(
  function lower_literal_vec (line 297) | fn lower_literal_vec(literal_data: Vec<NsDatum>) -> Result<Vec<ty::Ref<t...
  function lower_literal (line 301) | fn lower_literal(datum: NsDatum) -> Result<ty::Ref<ty::Poly>> {
  function lower_ident (line 318) | fn lower_ident(scope: &Scope<'_>, span: Span, ident: &Ident) -> Result<t...
  function lower_polymorphic_poly (line 327) | fn lower_polymorphic_poly(
  function lower_poly_data_iter (line 363) | fn lower_poly_data_iter(
  function lower_poly (line 408) | pub fn lower_poly(scope: &Scope<'_>, datum: NsDatum) -> Result<ty::Ref<t...
  function bind_polymorphic_vars (line 416) | fn bind_polymorphic_vars(
  function lower_polymorphic_var_set (line 441) | pub fn lower_polymorphic_var_set(
  function lower_polymorphic_var_list (line 472) | pub fn lower_polymorphic_var_list(
  function try_lower_purity (line 490) | pub fn try_lower_purity(scope: &Scope<'_>, datum: &NsDatum) -> Option<pu...
  constant TY_EXPORTS (line 521) | pub const TY_EXPORTS: &[(&str, Binding)] = &[
  function push_list_parts (line 560) | fn push_list_parts<M: ty::Pm>(list_parts: &mut Vec<String>, list_ref: &t...
  function str_for_bounds (line 572) | fn str_for_bounds(bound_pvars: &[purity::PVarId], bound_tvars: &[ty::TVa...
  function str_for_record_poly_arg (line 589) | fn str_for_record_poly_arg<M: ty::Pm>(
  function str_for_ty (line 603) | fn str_for_ty<M: ty::Pm>(ty: &Ty<M>) -> String {
  function str_for_ty_ref (line 716) | pub fn str_for_ty_ref<M: ty::Pm>(ty_ref: &ty::Ref<M>) -> String {
  function str_for_purity (line 723) | pub fn str_for_purity(purity: &purity::Ref) -> String {
  function poly_for_str (line 732) | pub fn poly_for_str(datum_str: &str) -> ty::Ref<ty::Poly> {
  function tvar_bounded_by (line 757) | pub fn tvar_bounded_by(bound: ty::Ref<ty::Poly>) -> ty::Ref<ty::Poly> {
  function assert_ty_for_str (line 770) | fn assert_ty_for_str(expected: Ty<ty::Poly>, datum_str: &str) {
  function assert_exact_str_repr (line 780) | fn assert_exact_str_repr(datum_str: &str) {
  function true_literal (line 785) | fn true_literal() {
  function false_literal (line 793) | fn false_literal() {
  function sym_literal (line 801) | fn sym_literal() {
  function keyword_literal (line 809) | fn keyword_literal() {
  function empty_list_literal (line 820) | fn empty_list_literal() {
  function quoted_list_literal (line 828) | fn quoted_list_literal() {
  function empty_vector_literal (line 841) | fn empty_vector_literal() {
  function vector_literal (line 849) | fn vector_literal() {
  function ty_ref (line 861) | fn ty_ref() {
  function fixed_list_cons (line 869) | fn fixed_list_cons() {
  function rest_list_cons (line 882) | fn rest_list_cons() {
  function vectorof_cons (line 895) | fn vectorof_cons() {
  function vector_cons (line 905) | fn vector_cons() {
  function pure_fun (line 917) | fn pure_fun() {
  function impure_fun (line 931) | fn impure_fun() {
  function fixed_fun (line 945) | fn fixed_fun() {
  function rest_impure_fun (line 959) | fn rest_impure_fun() {
  function top_impure_fun (line 973) | fn top_impure_fun() {
  function type_predicate (line 982) | fn type_predicate() {
  function equality_predicate (line 990) | fn equality_predicate() {
  function set_cons (line 998) | fn set_cons() {
  function map_cons (line 1008) | fn map_cons() {
  function merged_union_cons (line 1019) | fn merged_union_cons() {
  function simpifying_str_for_ty_ref (line 1027) | fn simpifying_str_for_ty_ref() {
  function polymorphic_fun_str (line 1035) | fn polymorphic_fun_str() {
  function singleton_record_type (line 1040) | fn singleton_record_type() {
  function poly_record_type (line 1058) | fn poly_record_type() {

FILE: compiler/hir/util.rs
  function try_take_rest_arg (line 10) | pub fn try_take_rest_arg(data_iter: &mut NsDataIter) -> Option<NsDatum> {
  function expect_arg_count (line 29) | pub fn expect_arg_count(
  function expect_one_arg (line 44) | pub fn expect_one_arg(span: Span, mut iter: NsDataIter) -> Result<NsDatu...
  function expect_spanned_ns_ident (line 49) | pub fn expect_spanned_ns_ident(datum: NsDatum, usage: &'static str) -> R...
  function expect_ns_ident (line 66) | pub fn expect_ns_ident(datum: NsDatum, usage: &'static str) -> Result<Id...
  function expect_spanned_ident (line 70) | pub fn expect_spanned_ident<'a>(
  function expect_ident (line 92) | pub fn expect_ident<'a>(datum: &'a Datum, usage: &'static str) -> Result...

FILE: compiler/hir/var_id.rs
  type LocalId (line 10) | pub struct LocalId(NonZeroU32);
  type ExportId (line 14) | pub struct ExportId(ModuleId, LocalId);
    method new (line 17) | pub fn new(module_id: ModuleId, local_id: LocalId) -> Self {
    method module_id (line 21) | pub fn module_id(self) -> ModuleId {
    method local_id (line 25) | pub fn local_id(self) -> LocalId {
  type LocalIdAlloc (line 30) | pub struct LocalIdAlloc {
    method new (line 35) | pub fn new() -> Self {
    method alloc (line 42) | pub fn alloc(&self) -> LocalId {
    method alloc_mut (line 47) | pub fn alloc_mut(&mut self) -> LocalId {

FILE: compiler/hir/visitor.rs
  function visit_exprs (line 4) | pub fn visit_exprs<'a, P: hir::Phase, F>(expr: &'a hir::Expr<P>, visitor...

FILE: compiler/id_type.rs
  type ArcId (line 125) | pub struct ArcId<T> {
  function new (line 130) | pub fn new(value: T) -> Self {
  method clone (line 138) | fn clone(&self) -> Self {
  type Target (line 146) | type Target = T;
  function deref (line 148) | fn deref(&self) -> &T {
  method eq (line 154) | fn eq(&self, other: &Self) -> bool {
  function hash (line 162) | fn hash<H: hash::Hasher>(&self, state: &mut H) {
  method partial_cmp (line 168) | fn partial_cmp(&self, other: &ArcId<T>) -> Option<std::cmp::Ordering> {
  method cmp (line 174) | fn cmp(&self, other: &ArcId<T>) -> std::cmp::Ordering {
  function fmt (line 180) | fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: compiler/lib.rs
  type EvaluableProgram (line 38) | pub struct EvaluableProgram {
  function include_imports (line 45) | fn include_imports(
  function program_to_evaluable (line 71) | pub fn program_to_evaluable(

FILE: compiler/mir/app_purity.rs
  function resolve_ref_to_purity (line 7) | fn resolve_ref_to_purity(
  function fun_app_purity (line 24) | pub fn fun_app_purity(

FILE: compiler/mir/arg_list.rs
  type LoadedArgList (line 12) | pub struct LoadedArgList {
  function build_load_arg_list_value (line 26) | pub fn build_load_arg_list_value(
  function build_save_arg_list_to_regs (line 87) | pub fn build_save_arg_list_to_regs<'a>(

FILE: compiler/mir/builder.rs
  type Builder (line 7) | pub struct Builder {
    method new (line 50) | pub fn new() -> Builder {
    method alloc_local (line 54) | pub fn alloc_local(&mut self) -> BuiltReg {
    method push_reg (line 58) | pub fn push_reg<F, P>(&mut self, span: Span, kind_cons: F, kind_param:...
    method push (line 75) | pub fn push(&mut self, span: Span, kind: OpKind) {
    method append (line 79) | pub fn append(&mut self, ops: impl IntoIterator<Item = Op>) {
    method into_ops (line 83) | pub fn into_ops(self) -> Box<[Op]> {
    method push_cond (line 87) | pub fn push_cond<T, F>(
    method cast_boxed (line 122) | pub fn cast_boxed(
    method cast_boxed_cond (line 142) | pub fn cast_boxed_cond(
  type BuiltReg (line 12) | pub enum BuiltReg {
    method into_reg_id (line 18) | pub fn into_reg_id(self) -> RegId {
    method is_const (line 24) | pub fn is_const(self) -> bool {
    method fmt (line 39) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method from (line 33) | fn from(built_reg: BuiltReg) -> RegId {
  method default (line 158) | fn default() -> Builder {
  type TryToBuilder (line 163) | pub trait TryToBuilder {
    method try_to_builder (line 164) | fn try_to_builder(&mut self) -> Option<&mut Builder>;
    method try_to_builder (line 168) | fn try_to_builder(&mut self) -> Option<&mut Builder> {
    method try_to_builder (line 174) | fn try_to_builder(&mut self) -> Option<&mut Builder> {

FILE: compiler/mir/costing.rs
  type OpCost (line 4) | pub type OpCost = u32;
  type OpCostFactor (line 7) | pub type OpCostFactor = f32;
  function cost_for_op_category (line 13) | pub fn cost_for_op_category(category: ops::OpCategory) -> OpCost {
  function cost_for_op (line 35) | fn cost_for_op(op: &ops::Op) -> OpCost {
  function cost_for_ops (line 67) | pub fn cost_for_ops<'o>(ops: impl Iterator<Item = &'o ops::Op>) -> OpCost {

FILE: compiler/mir/env_values.rs
  type Values (line 13) | type Values = Box<[(hir::LocalId, Value)]>;
  type CapturesRepr (line 17) | enum CapturesRepr {
  type EnvValues (line 25) | pub struct EnvValues {
    method empty (line 32) | pub fn empty() -> EnvValues {
  function can_reference_local_regs (line 41) | fn can_reference_local_regs(value: &Value) -> bool {
  function calculate_env_values (line 60) | pub fn calculate_env_values(
  function save_to_captures_reg (line 116) | pub fn save_to_captures_reg(
  function load_from_current_fun (line 163) | pub fn load_from_current_fun(
  function load_from_env_param (line 177) | pub fn load_from_env_param(

FILE: compiler/mir/equality.rs
  type EqualityResult (line 19) | pub enum EqualityResult {
    method from_bool_reg (line 25) | fn from_bool_reg(reg: BuiltReg) -> EqualityResult {
  method from (line 31) | fn from(er: EqualityResult) -> Value {
  function runtime_compare (line 40) | fn runtime_compare(
  function build_native_compare (line 83) | fn build_native_compare<F>(
  function build_record_equality (line 108) | fn build_record_equality(
  function build_bool_equality (line 210) | fn build_bool_equality(
  function values_statically_equal (line 280) | pub fn values_statically_equal(
  function eval_equality (line 353) | pub fn eval_equality(

FILE: compiler/mir/error.rs
  type Panic (line 11) | pub struct Panic {
    method new (line 17) | pub fn new(span: Span, message: String) -> Panic {
    method fmt (line 77) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Error (line 26) | pub enum Error {
    method with_macro_invocation_span (line 37) | pub fn with_macro_invocation_span(self, span: Span) -> Error {
  type Result (line 34) | pub type Result<T> = result::Result<T, Error>;
  function from (line 49) | fn from(error: Error) -> Self {
  function from (line 69) | fn from(error: Error) -> Self {

FILE: compiler/mir/eval_hir.rs
  type RustFunKey (line 38) | struct RustFunKey {
  type ArretFunKey (line 44) | struct ArretFunKey {
  type EvaledRecordClass (line 50) | pub struct EvaledRecordClass {
  type EvalHirCtx (line 56) | pub struct EvalHirCtx {
    method new (line 199) | pub fn new(optimising: bool) -> EvalHirCtx {
    method destruc_scalar (line 223) | fn destruc_scalar<F>(
    method destruc_list (line 235) | fn destruc_list<F>(
    method destruc_value (line 256) | fn destruc_value<F>(
    method destruc_source_name (line 272) | fn destruc_source_name(destruc: &hir::destruc::Destruc<hir::Inferred>)...
    method eval_local_ref (line 281) | fn eval_local_ref(&self, fcx: &FunCtx<'_>, local_id: hir::LocalId) -> ...
    method eval_do (line 298) | fn eval_do(
    method eval_let (line 311) | fn eval_let(
    method eval_lit (line 327) | fn eval_lit(&mut self, literal: &Datum) -> Value {
    method synthetic_funs (line 331) | pub(super) fn synthetic_funs(&mut self) -> &mut SyntheticFuns {
    method build_arret_fun_app (line 335) | pub(super) fn build_arret_fun_app(
    method inline_arret_fun_app (line 409) | pub(super) fn inline_arret_fun_app(
    method eval_arret_fun_app (line 449) | fn eval_arret_fun_app(
    method eval_ty_pred_app (line 477) | fn eval_ty_pred_app(
    method eval_eq_pred_app (line 490) | fn eval_eq_pred_app(
    method eval_record_cons_app (line 506) | fn eval_record_cons_app(
    method eval_field_accessor_app (line 524) | fn eval_field_accessor_app(
    method rust_fun_to_jit_boxed (line 540) | pub fn rust_fun_to_jit_boxed(&mut self, rust_fun: Arc<rfi::Fun>) -> Gc...
    method jit_thunk_for_rust_fun (line 551) | fn jit_thunk_for_rust_fun(&mut self, rust_fun: &rfi::Fun) -> boxed::Th...
    method register_rust_fun_with_jit (line 580) | pub fn register_rust_fun_with_jit(&mut self, rust_fun: &rfi::Fun) {
    method id_for_rust_fun (line 593) | fn id_for_rust_fun(
    method rust_fun_to_thunk_reg (line 618) | pub fn rust_fun_to_thunk_reg(
    method rust_fun_to_callback_reg (line 642) | pub fn rust_fun_to_callback_reg(
    method call_native_fun (line 667) | fn call_native_fun<F>(span: Span, block: F) -> Result<Value>
    method eval_rust_fun_app (line 687) | fn eval_rust_fun_app(
    method eval_const_fun_thunk_app (line 774) | fn eval_const_fun_thunk_app(
    method build_reg_fun_thunk_app (line 802) | fn build_reg_fun_thunk_app(
    method eval_value_app (line 855) | fn eval_value_app(
    method eval_app (line 908) | fn eval_app(
    method eval_recur (line 974) | fn eval_recur(
    method eval_cond (line 1111) | fn eval_cond(
    method build_cond_branch (line 1139) | fn build_cond_branch(
    method build_cond (line 1153) | fn build_cond(
    method eval_arret_fun (line 1282) | fn eval_arret_fun(
    method arret_fun_to_jit_boxed (line 1302) | pub fn arret_fun_to_jit_boxed(
    method jit_thunk_for_arret_fun (line 1322) | fn jit_thunk_for_arret_fun(&mut self, arret_fun: &value::ArretFun) -> ...
    method id_for_arret_fun (line 1350) | fn id_for_arret_fun(
    method evaled_record_class_for_cons (line 1375) | pub fn evaled_record_class_for_cons(
    method cons_for_jit_record_class_id (line 1414) | pub fn cons_for_jit_record_class_id(
    method arret_fun_to_thunk_reg (line 1421) | pub fn arret_fun_to_thunk_reg(
    method arret_fun_to_callback_reg (line 1459) | pub fn arret_fun_to_callback_reg(
    method ops_for_arret_fun (line 1488) | pub(super) fn ops_for_arret_fun(
    method ops_for_callback_to_thunk_adapter (line 1587) | fn ops_for_callback_to_thunk_adapter(
    method thunk_reg_to_callback_reg (line 1629) | pub fn thunk_reg_to_callback_reg(
    method jit_boxed_to_fun_value (line 1661) | pub fn jit_boxed_to_fun_value(&self, boxed_thunk: Gc<boxed::FunThunk>)...
    method visit_module_defs (line 1665) | pub fn visit_module_defs<'a>(
    method consume_module_defs (line 1693) | pub fn consume_module_defs(
    method should_collect (line 1721) | pub fn should_collect(&self) -> bool {
    method collect_garbage (line 1726) | pub fn collect_garbage(&mut self) {
    method eval_expr_with_source_name (line 1759) | fn eval_expr_with_source_name(
    method eval_expr (line 1800) | pub fn eval_expr(
    method consume_expr_with_source_name (line 1809) | fn consume_expr_with_source_name(
    method consume_expr (line 1824) | pub fn consume_expr(
    method eval_main_fun (line 1834) | pub fn eval_main_fun(&mut self, main_export_id: hir::ExportId) -> Resu...
    method into_built_program (line 1856) | pub fn into_built_program(mut self, main_export_id: hir::ExportId) -> ...
    method value_to_const (line 1885) | pub fn value_to_const(&mut self, value: &Value) -> Option<Gc<boxed::An...
  type TailCallCtx (line 78) | struct TailCallCtx {
  type RecurSelf (line 83) | struct RecurSelf<'af> {
  type FunCtx (line 90) | pub struct FunCtx<'rs> {
  function new (line 105) | pub fn new(module_id: Option<ModuleId>) -> FunCtx<'static> {
  function monomorphise (line 117) | pub fn monomorphise(&self, poly: &ty::Ref<ty::Poly>) -> ty::Ref<ty::Mono> {
  type BuiltCondBranch (line 122) | struct BuiltCondBranch {
  type BuiltProgram (line 127) | pub struct BuiltProgram {
    method is_empty (line 134) | pub fn is_empty(&self) -> bool {
  type ApplyArgs (line 146) | pub(super) struct ApplyArgs<'tyargs> {
  function merge_apply_purity_into_scope (line 151) | fn merge_apply_purity_into_scope(
  function merge_apply_ty_args_into_scope (line 172) | fn merge_apply_ty_args_into_scope(
  method as_heap (line 1892) | fn as_heap(&self) -> &boxed::Heap {
  method as_heap_mut (line 1896) | fn as_heap_mut(&mut self) -> &mut boxed::Heap {
  method as_interner (line 1902) | fn as_interner(&self) -> &Interner {

FILE: compiler/mir/inliner.rs
  constant MAX_INLINE_DEPTH (line 21) | const MAX_INLINE_DEPTH: usize = 16;
  type ApplyCookie (line 27) | pub struct ApplyCookie {
    method new (line 33) | pub fn new(heap: &Heap, arret_fun: &value::ArretFun, arg_list_value: &...
  type ApplyStack (line 44) | pub struct ApplyStack {
    method new (line 49) | pub fn new() -> ApplyStack {
    method with_apply_cookie (line 53) | fn with_apply_cookie(&self, apply_cookie: ApplyCookie) -> ApplyStack {
  function inline_preference_factor_for_value (line 75) | fn inline_preference_factor_for_value(arg_value: &Value) -> OpCostFactor {
  function inline_preference_factor_for_arg_list_value (line 94) | fn inline_preference_factor_for_arg_list_value(arg_list_value: &Value) -...
  function inline_preference_factor_for_env_values (line 107) | fn inline_preference_factor_for_env_values(env_values: &EnvValues) -> Op...
  function calc_inline_preference_factor (line 116) | fn calc_inline_preference_factor(
  function hash_value (line 128) | fn hash_value<H: Hasher>(heap: &Heap, value: &Value, state: &mut H) {
  function hash_for_arg_list_value (line 192) | fn hash_for_arg_list_value(heap: &Heap, arg_list_value: &Value) -> u64 {
  function cond_inline (line 217) | pub(super) fn cond_inline<'a>(

FILE: compiler/mir/intrinsic/bitwise.rs
  function fold_bitwise_operands (line 16) | fn fold_bitwise_operands<O>(
  function bit_shift_op (line 51) | fn bit_shift_op<O>(
  function bit_and (line 90) | pub fn bit_and(
  function bit_or (line 107) | pub fn bit_or(
  function bit_xor (line 124) | pub fn bit_xor(
  function bit_not (line 141) | pub fn bit_not(
  function bit_shift_left (line 161) | pub fn bit_shift_left(
  function bit_shift_right (line 176) | pub fn bit_shift_right(
  function unsigned_bit_shift_right (line 191) | pub fn unsigned_bit_shift_right(

FILE: compiler/mir/intrinsic/list.rs
  function length (line 11) | pub fn length(
  function cons (line 57) | pub fn cons(
  function repeat (line 71) | pub fn repeat(

FILE: compiler/mir/intrinsic/math.rs
  function fold_float_operands (line 40) | fn fold_float_operands<F>(
  function fold_num_operands (line 70) | fn fold_num_operands<I, F>(
  function reduce_operands (line 132) | fn reduce_operands<I, F>(
  function reduce_assoc_operands (line 165) | fn reduce_assoc_operands<I, F>(
  function add (line 194) | pub fn add(
  function mul (line 212) | pub fn mul(
  function sub (line 230) | pub fn sub(
  function div (line 269) | pub fn div(
  function int_division_op (line 321) | fn int_division_op<CI, UI>(
  function quot (line 370) | pub fn quot(
  function rem (line 386) | pub fn rem(
  function sqrt (line 402) | pub fn sqrt(

FILE: compiler/mir/intrinsic/mod.rs
  type BuildOutcome (line 40) | pub enum BuildOutcome {

FILE: compiler/mir/intrinsic/num_utils.rs
  type NumOperand (line 14) | pub enum NumOperand {
    method try_from_value (line 23) | pub fn try_from_value(
  function num_value_to_float_reg (line 44) | pub fn num_value_to_float_reg(
  function try_value_to_i64 (line 121) | pub fn try_value_to_i64(value: Value) -> Option<i64> {

FILE: compiler/mir/intrinsic/number.rs
  function build_operand_pair_compare (line 19) | fn build_operand_pair_compare(
  function build_operand_iter_compare (line 80) | fn build_operand_iter_compare(
  function compare_operand_list (line 129) | fn compare_operand_list(
  function int (line 155) | pub fn int(
  function float (line 172) | pub fn float(
  function num_lt (line 189) | pub fn num_lt(
  function num_le (line 204) | pub fn num_le(
  function num_eq (line 219) | pub fn num_eq(
  function num_gt (line 234) | pub fn num_gt(
  function num_ge (line 249) | pub fn num_ge(

FILE: compiler/mir/intrinsic/panics.rs
  function panics (line 11) | pub fn panics(

FILE: compiler/mir/intrinsic/partial_print.rs
  type PartialPrint (line 11) | pub enum PartialPrint {
    method into_arg_list_value (line 18) | pub fn into_arg_list_value(self, ehx: &mut EvalHirCtx) -> Value {
  function partial_pretty_print (line 32) | pub fn partial_pretty_print(

FILE: compiler/mir/intrinsic/print.rs
  function print (line 14) | pub fn print(
  function print_str (line 29) | pub fn print_str(

FILE: compiler/mir/intrinsic/testing.rs
  function ideal_polymorph_abi_for_arret_fun (line 16) | fn ideal_polymorph_abi_for_arret_fun(arret_fun: &value::ArretFun) -> Pol...
  function add_ops_categories (line 27) | fn add_ops_categories<'a>(
  function op_category_to_string (line 41) | fn op_category_to_string(category: ops::OpCategory) -> &'static str {
  function fn_op_categories (line 60) | pub fn fn_op_categories(

FILE: compiler/mir/intrinsic/vector.rs
  function vector_length (line 13) | pub fn vector_length(
  function vector_ref (line 48) | pub fn vector_ref(

FILE: compiler/mir/mod.rs
  type Expr (line 29) | type Expr = hir::Expr<hir::Inferred>;

FILE: compiler/mir/ops.rs
  type CallConv (line 18) | pub enum CallConv {
  type OpsAbi (line 31) | pub struct OpsAbi {
    method thunk_abi (line 38) | pub fn thunk_abi() -> OpsAbi {
  type StaticSymbol (line 53) | pub struct StaticSymbol {
  type Callee (line 64) | pub enum Callee {
  type RecordStruct (line 74) | pub struct RecordStruct {
    method new (line 82) | pub fn new(source_name: DataStr, field_abi_types: Box<[abitype::AbiTyp...
  type RecordStructId (line 79) | pub type RecordStructId = ArcId<RecordStruct>;
  type CallOp (line 91) | pub struct CallOp {
  type TailCallOp (line 98) | pub struct TailCallOp {
  type BoxPairOp (line 104) | pub struct BoxPairOp {
  type BoxFunThunkOp (line 111) | pub struct BoxFunThunkOp {
  type BoxRecordOp (line 117) | pub struct BoxRecordOp {
  type LoadBoxedRecordFieldOp (line 123) | pub struct LoadBoxedRecordFieldOp {
  type LoadBoxedVectorMemberOp (line 130) | pub struct LoadBoxedVectorMemberOp {
  type CastBoxedOp (line 138) | pub struct CastBoxedOp {
  type RegPhi (line 144) | pub struct RegPhi {
  type CondOp (line 151) | pub struct CondOp {
  type BinaryOp (line 159) | pub struct BinaryOp {
  type CompareOp (line 165) | pub struct CompareOp {
  type LoadBoxedTypeTagOp (line 172) | pub struct LoadBoxedTypeTagOp {
  type LoadBoxedListLenOp (line 178) | pub struct LoadBoxedListLenOp {
  type MakeCallbackOp (line 184) | pub struct MakeCallbackOp {
  type ShiftOp (line 190) | pub struct ShiftOp {
  type Comparison (line 196) | pub enum Comparison {
  type OpKind (line 205) | pub enum OpKind {
    method output_reg (line 320) | pub fn output_reg(&self) -> Option<RegId> {
    method add_input_regs (line 405) | pub fn add_input_regs(&self, coll: &mut impl Extend<RegId>) {
    method const_output (line 586) | pub fn const_output(&self) -> bool {
    method has_side_effects (line 595) | pub fn has_side_effects(&self) -> bool {
    method is_terminator (line 610) | pub fn is_terminator(&self) -> bool {
    method category (line 615) | pub fn category(&self) -> OpCategory {
  type OpCategory (line 304) | pub enum OpCategory {
  type Op (line 709) | pub struct Op {
    method new (line 715) | pub fn new(span: Span, kind: OpKind) -> Op {
    method span (line 719) | pub fn span(&self) -> Span {
    method kind (line 723) | pub fn kind(&self) -> &OpKind {
    method from (line 744) | fn from(op_kind: OpKind) -> Self {
  type Fun (line 728) | pub struct Fun {
  function output_reg (line 750) | fn output_reg() {
  function has_side_effects (line 759) | fn has_side_effects() {
  function const_output (line 794) | fn const_output() {
  function ret_input_regs (line 818) | fn ret_input_regs() {
  function cond_input_regs (line 829) | fn cond_input_regs() {

FILE: compiler/mir/optimise/duplicate_alloc_ops.rs
  function visit_simple_alloc_op_kind (line 5) | fn visit_simple_alloc_op_kind(
  function remove_branch_redundant_alloc_ops (line 23) | fn remove_branch_redundant_alloc_ops(
  function remove_redundant_alloc_ops (line 58) | pub fn remove_redundant_alloc_ops(ops: &mut [ops::Op]) {
  function test_box_different_native_regs (line 70) | fn test_box_different_native_regs() {
  function test_box_same_native_regs (line 96) | fn test_box_same_native_regs() {
  function test_reboxing (line 127) | fn test_reboxing() {
  function test_cond_branch (line 157) | fn test_cond_branch() {

FILE: compiler/mir/optimise/mod.rs
  function optimise_fun (line 7) | pub fn optimise_fun(fun: ops::Fun) -> ops::Fun {
  function optimise_inlined_fun (line 18) | pub fn optimise_inlined_fun(ops: Box<[ops::Op]>, return_value: &Value) -...

FILE: compiler/mir/optimise/unused_ops.rs
  function remove_unused_cond_ops (line 6) | fn remove_unused_cond_ops(
  function remove_unused_branch_ops (line 57) | fn remove_unused_branch_ops(
  function remove_unused_fun_ops (line 94) | pub fn remove_unused_fun_ops(ops: Box<[ops::Op]>) -> Box<[ops::Op]> {
  function add_value_used_regs (line 101) | fn add_value_used_regs(value: &Value, used_regs: &mut HashSet<ops::RegId...
  function remove_unused_value_ops (line 134) | pub fn remove_unused_value_ops(ops: Box<[ops::Op]>, value: &Value) -> Bo...
  function empty_ops (line 146) | fn empty_ops() {
  function simple_unused (line 152) | fn simple_unused() {
  function fully_used_cond (line 175) | fn fully_used_cond() {
  function partially_used_cond (line 208) | fn partially_used_cond() {
  function output_only_cond (line 256) | fn output_only_cond() {
  function output_unused_cond (line 305) | fn output_unused_cond() {
  function fully_unused_cond (line 344) | fn fully_unused_cond() {

FILE: compiler/mir/polymorph.rs
  type PolymorphAbi (line 12) | pub struct PolymorphAbi {
    method thunk_abi (line 23) | pub fn thunk_abi() -> PolymorphAbi {
    method param_ty_ref (line 36) | pub fn param_ty_ref<M: ty::Pm>(&self) -> ty::List<M> {
    method from (line 61) | fn from(abi_type: callback::EntryPointAbiType) -> Self {
  function from (line 75) | fn from(polymorph_abi: PolymorphAbi) -> Self {
  function polymorph_abi_for_list_ty (line 91) | pub fn polymorph_abi_for_list_ty<M: ty::Pm>(
  function polymorph_abi_param_ty_ref (line 124) | fn polymorph_abi_param_ty_ref() {

FILE: compiler/mir/printer.rs
  function span_to_human_location (line 15) | fn span_to_human_location(source_loader: Option<&SourceLoader>, span: Sp...
  function private_fun_to_string (line 30) | fn private_fun_to_string(
  function callee_to_string (line 41) | fn callee_to_string(
  function callee_to_gen_abi (line 55) | fn callee_to_gen_abi(
  function box_pair_op_to_string (line 66) | fn box_pair_op_to_string(
  function box_fun_thunk_op_to_string (line 81) | fn box_fun_thunk_op_to_string(
  function box_record_op_to_string (line 95) | fn box_record_op_to_string(
  function comparison_to_str (line 116) | fn comparison_to_str(comparison: ops::Comparison) -> &'static str {
  function print_cond_branch (line 126) | fn print_cond_branch(
  function print_branch (line 146) | fn print_branch(
  function print_fun (line 881) | pub fn print_fun(
  function print_program (line 926) | pub fn print_program(

FILE: compiler/mir/record_field.rs
  function load_record_field (line 12) | pub fn load_record_field(

FILE: compiler/mir/ret_value.rs
  function build_value_ret (line 14) | pub fn build_value_ret(
  function ret_reg_to_value (line 43) | pub fn ret_reg_to_value(ret_reg: BuiltReg, ret_abi: abitype::RetAbiType)...

FILE: compiler/mir/rust_fun.rs
  function rust_fun_purity_upper_bound (line 16) | pub fn rust_fun_purity_upper_bound(rust_fun: &rfi::Fun) -> Purity {
  function build_rust_fun_app (line 28) | pub fn build_rust_fun_app(
  function ops_for_rust_fun (line 91) | pub fn ops_for_rust_fun(

FILE: compiler/mir/specific_abi_type.rs
  constant ANY_BOXED_ABI_TYPE (line 9) | const ANY_BOXED_ABI_TYPE: abitype::BoxedAbiType = abitype::BoxedAbiType:...
  constant TOP_RECORD_BOXED_ABI_TYPE (line 11) | const TOP_RECORD_BOXED_ABI_TYPE: abitype::BoxedAbiType =
  function specific_boxed_abi_type_for_type_tag (line 14) | fn specific_boxed_abi_type_for_type_tag(type_tag: TypeTag) -> &'static a...
  function specific_abi_type_for_type_tag (line 36) | fn specific_abi_type_for_type_tag(type_tag: TypeTag) -> abitype::AbiType {
  function specific_boxed_abi_type_for_type_tags (line 48) | fn specific_boxed_abi_type_for_type_tags(
  function specific_boxed_abi_type_for_ty_ref (line 68) | pub fn specific_boxed_abi_type_for_ty_ref<M: ty::Pm>(
  function specific_abi_type_for_type_tags (line 74) | fn specific_abi_type_for_type_tags(possible_type_tags: TypeTagSet) -> ab...
  function specific_abi_type_for_ty_ref (line 88) | pub fn specific_abi_type_for_ty_ref<M: ty::Pm>(ty_ref: &ty::Ref<M>) -> a...
  function specific_ret_abi_type_for_ty_ref (line 116) | pub fn specific_ret_abi_type_for_ty_ref<M: ty::Pm>(ty_ref: &ty::Ref<M>) ...
  function specific_type_for_values (line 124) | fn specific_type_for_values<'v, F, T>(
  function specific_boxed_abi_type_for_values (line 141) | pub fn specific_boxed_abi_type_for_values<'v>(
  function specific_abi_type_for_values (line 148) | pub fn specific_abi_type_for_values<'v>(
  function specific_abi_type_for_value (line 155) | pub fn specific_abi_type_for_value(value: &Value) -> abitype::AbiType {
  function assert_abi_type_for_str (line 166) | fn assert_abi_type_for_str(abi_type: abitype::AbiType, ty_str: &'static ...
  function test_specific_abi_type_for_ty_ref (line 172) | fn test_specific_abi_type_for_ty_ref() {

FILE: compiler/mir/tagset.rs
  constant INNER_BITS (line 8) | const INNER_BITS: u8 = 32;
  type Inner (line 9) | type Inner = u32;
  type TypeTagSet (line 12) | pub struct TypeTagSet(Inner);
    method new (line 16) | pub fn new() -> TypeTagSet {
    method all (line 20) | pub fn all() -> TypeTagSet {
    method is_empty (line 24) | pub fn is_empty(self) -> bool {
    method len (line 28) | pub fn len(self) -> usize {
    method insert (line 32) | pub fn insert(&mut self, type_tag: TypeTag) {
    method is_subset (line 38) | pub fn is_subset(self, superset: Self) -> bool {
    method is_disjoint (line 42) | pub fn is_disjoint(self, other: Self) -> bool {
    method intersection (line 46) | pub fn intersection(self, other: Self) -> TypeTagSet {
    method union (line 50) | pub fn union(self, other: Self) -> TypeTagSet {
    method contains (line 54) | pub fn contains(self, type_tag: TypeTag) -> bool {
    method into_iter (line 62) | pub fn into_iter(self) -> impl Iterator<Item = TypeTag> {
    method fmt (line 71) | fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::E...
    method from (line 79) | fn from(type_tag: TypeTag) -> TypeTagSet {
    method from (line 90) | fn from(ty_ref: &'a ty::Ref<M>) -> TypeTagSet {
    method from (line 129) | fn from(boxed_abi_type: &'a abitype::BoxedAbiType) -> TypeTagSet {
    method from (line 146) | fn from(abi_type: &'a abitype::AbiType) -> TypeTagSet {
    method from (line 162) | fn from(abi_type: abitype::AbiType) -> TypeTagSet {
    method from_iter (line 168) | fn from_iter<I: IntoIterator<Item = TypeTag>>(iter: I) -> TypeTagSet {
    method from_iter (line 178) | fn from_iter<I: IntoIterator<Item = &'a TypeTag>>(iter: I) -> TypeTagS...
    type Output (line 184) | type Output = Self;
    method bitor (line 186) | fn bitor(self, rhs: Self) -> Self {
    type Output (line 192) | type Output = Self;
    method bitand (line 194) | fn bitand(self, rhs: Self) -> Self {
  function basic_operations (line 206) | fn basic_operations() {
  function set_into_iter (line 238) | fn set_into_iter() {
  function from_ty_ref (line 261) | fn from_ty_ref() {

FILE: compiler/mir/typred.rs
  function type_tags_for_test_ty (line 20) | fn type_tags_for_test_ty(test_ty: &ty::pred::TestTy) -> TypeTagSet {
  function build_load_type_tag (line 48) | fn build_load_type_tag(
  function build_is_type_tag (line 67) | fn build_is_type_tag(
  function eval_tagged_ty_pred (line 85) | fn eval_tagged_ty_pred(
  function eval_record_ty_pred (line 150) | fn eval_record_ty_pred(
  function eval_ty_pred (line 285) | pub fn eval_ty_pred(

FILE: compiler/mir/value/arret_fun.rs
  type ArretFunConsts (line 14) | struct ArretFunConsts {
  type ArretFun (line 23) | pub struct ArretFun {
    method new (line 29) | pub fn new(
    method id (line 48) | pub fn id(&self) -> ArretFunId {
    method module_id (line 55) | pub fn module_id(&self) -> Option<ModuleId> {
    method source_name (line 59) | pub fn source_name(&self) -> &Option<DataStr> {
    method env_ty_args (line 63) | pub fn env_ty_args(&self) -> &TyArgs<ty::Mono> {
    method env_values (line 67) | pub fn env_values(&self) -> &EnvValues {
    method env_values_mut (line 71) | pub fn env_values_mut(&mut self) -> &mut EnvValues {
    method fun_expr (line 75) | pub fn fun_expr(&self) -> &hir::Fun<hir::Inferred> {
    method with_env_values (line 79) | pub fn with_env_values(&self, env_values: EnvValues) -> ArretFun {
    method has_multiple_usages (line 90) | pub fn has_multiple_usages(&self) -> bool {

FILE: compiler/mir/value/build_reg.rs
  type RestLen (line 15) | enum RestLen {
  function const_to_reg (line 20) | fn const_to_reg(
  function list_to_reg (line 257) | fn list_to_reg(
  function record_to_reg (line 352) | fn record_to_reg(
  function record_field_value_to_const_reg (line 393) | fn record_field_value_to_const_reg(
  function reg_to_boxed_reg (line 419) | pub fn reg_to_boxed_reg(
  function boxed_to_bool (line 490) | fn boxed_to_bool(
  function reg_to_reg (line 532) | fn reg_to_reg(
  function thunk_reg_to_reg (line 575) | fn thunk_reg_to_reg(
  function arret_fun_to_reg (line 591) | fn arret_fun_to_reg(
  function rust_fun_to_reg (line 612) | fn rust_fun_to_reg(
  function value_to_reg (line 633) | pub fn value_to_reg(

FILE: compiler/mir/value/from_reg.rs
  function reg_to_value_with_constraints (line 13) | fn reg_to_value_with_constraints<M>(
  function reg_to_value (line 57) | pub fn reg_to_value<M>(
  function refine_reg_value_with_arret_ty (line 76) | pub fn refine_reg_value_with_arret_ty<M>(

FILE: compiler/mir/value/list.rs
  type ListValueLen (line 11) | pub enum ListValueLen {
    method lower_bound (line 17) | pub fn lower_bound(&self) -> usize {
    type Output (line 26) | type Output = ListValueLen;
    method add (line 28) | fn add(self, other: ListValueLen) -> ListValueLen {
  function list_value_len (line 39) | pub fn list_value_len(value: &Value) -> ListValueLen {
  type UnsizedListIterator (line 77) | pub struct UnsizedListIterator {
    method new (line 83) | pub fn new(value: Value) -> Self {
    method next_unchecked (line 95) | pub fn next_unchecked(&mut self, b: &mut impl TryToBuilder, span: Span...
    method into_rest (line 142) | pub fn into_rest(self) -> Value {
    method build_rest_next (line 146) | fn build_rest_next(
  type SizedListIterator (line 169) | pub struct SizedListIterator {
    method try_new (line 175) | pub fn try_new(value: &Value) -> Option<Self> {
    method next (line 187) | pub fn next(&mut self, b: &mut impl TryToBuilder, span: Span) -> Optio...
    method into_rest (line 197) | pub fn into_rest(self) -> Value {
    method len (line 201) | pub fn len(&self) -> usize {
    method is_empty (line 205) | pub fn is_empty(&self) -> bool {
  function list_len (line 220) | fn list_len() {
  function const_unsized_list_iter (line 290) | fn const_unsized_list_iter() {
  function fixed_list_value_unsized_iter (line 316) | fn fixed_list_value_unsized_iter() {

FILE: compiler/mir/value/mod.rs
  type RegValue (line 26) | pub struct RegValue {
    method new (line 34) | pub fn new(reg: BuiltReg, abi_type: abitype::AbiType) -> RegValue {
  type Value (line 45) | pub enum Value {
    method unsized_list_iter (line 61) | pub fn unsized_list_iter(&self) -> list::UnsizedListIterator {
    method into_unsized_list_iter (line 65) | pub fn into_unsized_list_iter(self) -> list::UnsizedListIterator {
    method try_sized_list_iter (line 69) | pub fn try_sized_list_iter(&self) -> Option<list::SizedListIterator> {
    method from (line 75) | fn from(boxed_ref: Gc<T>) -> Self {
    method from (line 81) | fn from(reg_value: RegValue) -> Self {
  function visit_value_root (line 86) | pub fn visit_value_root(strong_pass: &mut boxed::collect::StrongPass, va...

FILE: compiler/mir/value/plan_phi.rs
  function plan_phi_abi_type (line 6) | pub fn plan_phi_abi_type(lhs: &Value, rhs: &Value) -> abitype::AbiType {

FILE: compiler/mir/value/synthetic_fun.rs
  type ExprParam (line 18) | struct ExprParam {
  function wrap_poly_expr_in_arret_fun (line 23) | fn wrap_poly_expr_in_arret_fun(
  function wrap_mono_expr_in_arret_fun (line 97) | fn wrap_mono_expr_in_arret_fun(
  function new_eq_pred_arret_fun (line 114) | fn new_eq_pred_arret_fun(span: Span) -> value::ArretFun {
  function new_ty_pred_arret_fun (line 140) | fn new_ty_pred_arret_fun(span: Span, test_ty: ty::pred::TestTy) -> value...
  function new_record_cons_arret_fun (line 160) | fn new_record_cons_arret_fun(span: Span, cons: &record::ConsId) -> value...
  function new_field_accessor_arret_fun (line 193) | fn new_field_accessor_arret_fun(
  type SyntheticFuns (line 231) | pub struct SyntheticFuns {
    method new (line 239) | pub fn new() -> Self {
    method eq_pred_arret_fun (line 248) | pub fn eq_pred_arret_fun(&mut self) -> &value::ArretFun {
    method ty_pred_arret_fun (line 253) | pub fn ty_pred_arret_fun(&mut self, test_ty: ty::pred::TestTy) -> &val...
    method record_cons_arret_fun (line 259) | pub fn record_cons_arret_fun(&mut self, cons: &record::ConsId) -> &val...
    method field_accessor_arret_fun (line 265) | pub fn field_accessor_arret_fun(

FILE: compiler/mir/value/to_const.rs
  function record_to_const (line 12) | fn record_to_const(
  function list_to_const (line 96) | pub fn list_to_const(
  function value_to_const (line 126) | pub fn value_to_const(ehx: &mut EvalHirCtx, value: &Value) -> Option<Gc<...

FILE: compiler/mir/value/types.rs
  type TypeHint (line 21) | pub enum TypeHint {
  type FoundRecordConses (line 36) | enum FoundRecordConses<'a> {
  function find_record_conses_for_ty_ref (line 43) | fn find_record_conses_for_ty_ref<M>(ty_ref: &ty::Ref<M>) -> FoundRecordC...
  function type_hint_for_ty_ref (line 79) | pub fn type_hint_for_ty_ref<M>(ty_ref: &ty::Ref<M>) -> TypeHint
  function known_record_cons_for_value (line 102) | pub fn known_record_cons_for_value<'a>(
  function known_vector_len_for_value (line 123) | pub fn known_vector_len_for_value(value: &Value) -> Option<usize> {
  function type_hint_for_value (line 139) | pub fn type_hint_for_value(ehx: &EvalHirCtx, value: &Value) -> TypeHint {
  function possible_type_tags_for_value (line 155) | pub fn possible_type_tags_for_value(value: &Value) -> TypeTagSet {
  function value_with_arret_ty (line 184) | pub fn value_with_arret_ty<F>(
  function test_find_record_conses_for_ty_ref (line 212) | fn test_find_record_conses_for_ty_ref() {

FILE: compiler/mir/vector_member.rs
  function vector_member_type (line 9) | fn vector_member_type(vector_value: &Value) -> &abitype::BoxedAbiType {
  function load_vector_member (line 24) | pub fn load_vector_member(

FILE: compiler/promise.rs
  type Inner (line 5) | struct Inner<T>
  type Completer (line 14) | struct Completer<T>
  function set (line 26) | pub fn set(self, new_value: T) {
  type Promise (line 40) | struct Promise<T>
  function value (line 52) | pub fn value(&self) -> T {
  function promise (line 67) | fn promise<T>() -> (Completer<T>, Promise<T>)
  function completed (line 85) | fn completed<T>(value: T) -> Promise<T>
  type PromiseMap (line 100) | pub struct PromiseMap<K, V>
  function new (line 114) | pub fn new(values: impl IntoIterator<Item = (K, V)>) -> Self {
  function get_or_insert_with (line 124) | pub fn get_or_insert_with<F>(&self, key: K, func: F) -> V

FILE: compiler/repl.rs
  type EvalKind (line 26) | pub enum EvalKind {
  type EvaledExprValue (line 37) | pub struct EvaledExprValue {
  type EvaledLine (line 52) | pub enum EvaledLine {
  type ReplEngine (line 69) | struct ReplEngine<'ccx> {
  function new (line 80) | fn new(ccx: &'ccx CompileCtx) -> Self {
  function bound_names (line 93) | fn bound_names(&self) -> Vec<DataStr> {
  function visit_module_tree (line 107) | fn visit_module_tree(
  function eval_line (line 131) | fn eval_line(
  type ReplCtx (line 255) | pub struct ReplCtx {
    method new (line 267) | pub fn new(ccx: Arc<CompileCtx>) -> Self {
    method send_line (line 295) | pub fn send_line(&self, input: String, kind: EvalKind) -> Result<(), E...
    method receive_result (line 304) | pub fn receive_result(&self) -> Result<EvaledLine, Vec<Diagnostic<File...
  type EngineDisconnected (line 261) | pub struct EngineDisconnected;
  function eval_line_sync (line 313) | fn eval_line_sync(
  function assert_defs (line 322) | fn assert_defs(rcx: &mut ReplCtx, line: &'static str) {
  function assert_empty (line 331) | fn assert_empty(rcx: &mut ReplCtx, line: &'static str) {
  function assert_expr (line 338) | fn assert_expr(
  function basic_session (line 365) | fn basic_session() {

FILE: compiler/reporting.rs
  type LocTrace (line 9) | pub struct LocTrace {
    method new (line 15) | pub fn new(origin: Span, macro_invocation: Option<Span>) -> LocTrace {
    method with_macro_invocation (line 22) | pub fn with_macro_invocation(self, macro_invocation: Span) -> LocTrace {
    method origin (line 29) | pub fn origin(&self) -> Span {
    method macro_invocation (line 33) | pub fn macro_invocation(&self) -> Option<Span> {
    method label_macro_invocation (line 37) | pub fn label_macro_invocation(&self, mut diagnostic: Diagnostic<FileId...
    method from (line 52) | fn from(span: Span) -> LocTrace {
  function errors_to_diagnostics (line 60) | pub fn errors_to_diagnostics<E: Into<Diagnostic<FileId>>>(
  function diagnostic_for_syntax_error (line 70) | pub fn diagnostic_for_syntax_error(error: &arret_syntax::error::Error) -...
  function new_primary_label (line 99) | pub fn new_primary_label(span: Span, message: impl Into<String>) -> Labe...
  function new_secondary_label (line 103) | pub fn new_secondary_label(span: Span, message: impl Into<String>) -> La...
  function emit_diagnostics_to_stderr (line 111) | pub fn emit_diagnostics_to_stderr(

FILE: compiler/rfi/mod.rs
  type Library (line 18) | pub struct Library {
    method fmt (line 25) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Fun (line 31) | pub struct Fun {
    method intrinsic_name (line 48) | pub fn intrinsic_name(&self) -> Option<&'static str> {
    method span (line 52) | pub fn span(&self) -> Span {
    method arret_fun_type (line 56) | pub fn arret_fun_type(&self) -> &ty::Fun {
    method symbol (line 60) | pub fn symbol(&self) -> &'static str {
    method entry_point (line 64) | pub fn entry_point(&self) -> usize {
    method takes_task (line 68) | pub fn takes_task(&self) -> bool {
    method params (line 72) | pub fn params(&self) -> &'static [abitype::ParamAbiType] {
    method has_rest (line 76) | pub fn has_rest(&self) -> bool {
    method ret (line 80) | pub fn ret(&self) -> &'static abitype::RetAbiType {
  type Loader (line 85) | pub struct Loader {
    method new (line 151) | pub fn new() -> Loader {
    method process_rust_fun (line 157) | fn process_rust_fun(
    method load (line 249) | pub fn load(
  function ensure_types_compatible (line 93) | fn ensure_types_compatible<T>(
  type LibType (line 119) | enum LibType {
  function build_rfi_lib_path (line 124) | fn build_rfi_lib_path(base: &path::Path, package_name: &str, lib_type: L...
  function binding_fun_to_poly_type (line 347) | fn binding_fun_to_poly_type(rust_fun: &'static binding::RustFun) -> Resu...
  function assert_valid_binding_fun (line 356) | fn assert_valid_binding_fun(rust_fun: &'static binding::RustFun) {
  function assert_binding_fun_error (line 360) | fn assert_binding_fun_error(expected_kind: &ErrorKind, rust_fun: &'stati...
  function exact_rust_fun (line 368) | fn exact_rust_fun() {
  function inexact_rust_fun_with_rest (line 384) | fn inexact_rust_fun_with_rest() {
  function void_rust_fun (line 402) | fn void_rust_fun() {
  function diverging_fun (line 418) | fn diverging_fun() {
  function polymorphic_rust_fun (line 431) | fn polymorphic_rust_fun() {
  function incompatible_polymorphic_rust_fun (line 447) | fn incompatible_polymorphic_rust_fun() {
  function unbound_arret_type (line 466) | fn unbound_arret_type() {
  function non_fun_type (line 483) | fn non_fun_type() {
  function non_list_rust_rest_param (line 500) | fn non_list_rust_rest_param() {
  function mismatched_fixed_param_count (line 517) | fn mismatched_fixed_param_count() {
  function incompatible_fixed_param_type (line 541) | fn incompatible_fixed_param_type() {
  function incompatible_ret_type (line 560) | fn incompatible_ret_type() {

FILE: compiler/source.rs
  constant EMPTY_SPAN (line 11) | pub const EMPTY_SPAN: Span = Span::new(None, 0, 0);
  type SourceText (line 14) | pub enum SourceText {
    method as_ref (line 20) | fn as_ref(&self) -> &str {
    method from (line 29) | fn from(s: Arc<str>) -> Self {
    method from (line 35) | fn from(s: String) -> Self {
    method from (line 41) | fn from(s: &'static str) -> Self {
  type SourceFile (line 46) | pub struct SourceFile {
    method file_id (line 53) | pub fn file_id(&self) -> FileId {
    method source (line 57) | pub fn source(&self) -> &'_ str {
    method parsed (line 61) | pub fn parsed(&self) -> Result<&[Datum], arret_syntax::error::Error> {
    method fmt (line 70) | fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
  type ReportableFile (line 75) | struct ReportableFile {
    method name (line 82) | fn name(&self) -> String {
    method source (line 86) | fn source(&self) -> &str {
    method line_index (line 90) | fn line_index(&self, offset: usize) -> usize {
    method line_range (line 100) | fn line_range(&self, line_index: usize) -> Option<Range<usize>> {
  type SourceLoader (line 114) | pub struct SourceLoader {
    method new (line 119) | pub fn new() -> Self {
    method load_path (line 124) | pub fn load_path(&self, path: &path::Path) -> Result<SourceFile, io::E...
    method load_string (line 134) | pub fn load_string(&self, filename: OsString, source: impl Into<Source...
    method reserve (line 162) | pub fn reserve(&self, additional: usize) {
    method files (line 169) | pub fn files(&self) -> ReportableFiles<'_> {
  type ReportableFiles (line 176) | pub struct ReportableFiles<'a> {
  function get_file (line 181) | fn get_file(&self, file_id: FileId) -> Option<&ReportableFile> {
  type CodespanResult (line 186) | type CodespanResult<T> = Result<T, CodespanError>;
  type FileId (line 189) | type FileId = FileId;
  type Source (line 190) | type Source = &'a str;
  type Name (line 191) | type Name = String;
  function name (line 193) | fn name(&self, file_id: FileId) -> CodespanResult<String> {
  function source (line 199) | fn source(&self, file_id: FileId) -> CodespanResult<&str> {
  function line_index (line 205) | fn line_index(&self, file_id: FileId, offset: usize) -> CodespanResult<u...
  function line_range (line 211) | fn line_range(&self, file_id: FileId, line_index: usize) -> CodespanResu...

FILE: compiler/tests/integration.rs
  type RunOutput (line 19) | struct RunOutput {
  type RunType (line 25) | enum RunType {
    method expected_output (line 31) | fn expected_output(&self) -> &RunOutput {
  type TestType (line 40) | enum TestType {
  type ExpectedSpan (line 47) | enum ExpectedSpan {
    method matches (line 53) | fn matches(&self, actual_file_id: FileId, actual_range: Range<usize>) ...
  type ExpectedDiagnostic (line 70) | struct ExpectedDiagnostic {
    method matches (line 77) | fn matches(&self, actual: &Diagnostic<FileId>) -> bool {
    method to_error_diagnostic (line 93) | fn to_error_diagnostic(&self) -> Diagnostic<FileId> {
  function take_severity (line 118) | fn take_severity(marker_string: &str) -> (Severity, &str) {
  function severity_name (line 134) | fn severity_name(severity: Severity) -> &'static str {
  function extract_expected_diagnostics (line 144) | fn extract_expected_diagnostics(
  function unexpected_diag_to_error_diagnostic (line 204) | fn unexpected_diag_to_error_diagnostic(unexpected_diag: Diagnostic<FileI...
  function exit_with_run_output_difference (line 230) | fn exit_with_run_output_difference(
  function result_for_single_test (line 271) | fn result_for_single_test(
  function run_single_pass_test (line 381) | fn run_single_pass_test(
  function run_single_compile_fail_test (line 396) | fn run_single_compile_fail_test(
  function run_single_test (line 450) | fn run_single_test(ccx: &CompileCtx, input_path: &path::Path, test_type:...
  function entry_is_arret_source (line 465) | fn entry_is_arret_source(entry: &fs::DirEntry) -> bool {
  function read_or_empty_vec (line 473) | fn read_or_empty_vec(filename: &path::Path) -> Result<Vec<u8>, io::Error> {
  function entry_to_compile_test_tuple (line 481) | fn entry_to_compile_test_tuple(
  function entry_to_run_test_tuple (line 494) | fn entry_to_run_test_tuple<RT>(
  function integration (line 520) | fn integration() {

FILE: compiler/ty/conv_abi.rs
  function type_tag_to_ty (line 8) | fn type_tag_to_ty<M: ty::Pm>(type_tag: boxed::TypeTag) -> Ty<M> {
  type ConvertableAbiType (line 32) | pub trait ConvertableAbiType {
    method to_ty_ref (line 33) | fn to_ty_ref<M: ty::Pm>(&self) -> ty::Ref<M>;
    method to_rust_str (line 34) | fn to_rust_str(&self) -> String;
    method to_ty_ref (line 38) | fn to_ty_ref<M: ty::Pm>(&self) -> ty::Ref<M> {
    method to_rust_str (line 52) | fn to_rust_str(&self) -> String {
    method to_ty_ref (line 68) | fn to_ty_ref<M: ty::Pm>(&self) -> ty::Ref<M> {
    method to_rust_str (line 94) | fn to_rust_str(&self) -> String {
    method to_ty_ref (line 113) | fn to_ty_ref<M: ty::Pm>(&self) -> ty::Ref<M> {
    method to_rust_str (line 123) | fn to_rust_str(&self) -> String {
    method to_ty_ref (line 135) | fn to_ty_ref<M: ty::Pm>(&self) -> ty::Ref<M> {
    method to_rust_str (line 139) | fn to_rust_str(&self) -> String {
    method to_ty_ref (line 155) | fn to_ty_ref<M: ty::Pm>(&self) -> ty::Ref<M> {
    method to_rust_str (line 171) | fn to_rust_str(&self) -> String {
  function pair_abi_type (line 195) | fn pair_abi_type() {
  function bool_abi_type (line 210) | fn bool_abi_type() {
  function nil_abi_type (line 223) | fn nil_abi_type() {
  function callback_abi_type (line 236) | fn callback_abi_type() {
  function captured_int_abi_type (line 257) | fn captured_int_abi_type() {

FILE: compiler/ty/datum.rs
  function ty_ref_for_datum (line 6) | pub fn ty_ref_for_datum<M: ty::Pm>(datum: &Datum) -> ty::Ref<M> {
  function assert_poly_for_str (line 40) | fn assert_poly_for_str(ty_str: &str, datum_str: &str) {
  function trivial_types (line 48) | fn trivial_types() {
  function bool_literal (line 56) | fn bool_literal() {
  function sym_literal (line 62) | fn sym_literal() {
  function fixed_list (line 67) | fn fixed_list() {
  function fixed_vec (line 73) | fn fixed_vec() {
  function fixed_set (line 79) | fn fixed_set() {
  function fixed_map (line 85) | fn fixed_map() {

FILE: compiler/ty/intersect.rs
  type Error (line 15) | pub enum Error {
  type Result (line 19) | type Result<S> = result::Result<S, Error>;
  function flatten_ref_intersect (line 24) | fn flatten_ref_intersect<M: ty::Pm>(ref1: &ty::Ref<M>, ref2: &ty::Ref<M>...
  function unify_list (line 46) | fn unify_list(
  function intersect_union_iter (line 60) | fn intersect_union_iter<'a, M, I>(lefts: &[ty::Ref<M>], rights: I) -> Re...
  function intersect_ty_ref_iter (line 85) | fn intersect_ty_ref_iter<'a, M, I>(mut ty_refs: I) -> Result<ty::Ref<M>>
  function intersect_record_field_purities (line 102) | fn intersect_record_field_purities<M: ty::Pm>(
  function intersect_record_field_ty_refs (line 127) | fn intersect_record_field_ty_refs<M: ty::Pm>(
  function intersect_record_instance (line 152) | fn intersect_record_instance<M: ty::Pm>(
  function non_subty_intersect (line 201) | fn non_subty_intersect<M: ty::Pm>(
  function intersect_list (line 319) | pub fn intersect_list<M: ty::Pm>(list1: &ty::List<M>, list2: &ty::List<M...
  function intersect_ty_refs (line 342) | pub fn intersect_ty_refs<M: ty::Pm>(
  function intersect_purity_refs (line 370) | pub fn intersect_purity_refs(purity1: &purity::Ref, purity2: &purity::Re...
  function assert_disjoint_poly (line 385) | fn assert_disjoint_poly(poly1: &ty::Ref<ty::Poly>, poly2: &ty::Ref<ty::P...
  function assert_merged_poly (line 392) | fn assert_merged_poly(
  function assert_disjoint (line 411) | fn assert_disjoint(ty_str1: &str, ty_str2: &str) {
  function assert_merged (line 418) | fn assert_merged(expected_str: &str, ty_str1: &str, ty_str2: &str) {
  function assert_disjoint_iter (line 426) | fn assert_disjoint_iter(ty_strs: &[&str]) {
  function assert_merged_iter (line 435) | fn assert_merged_iter(expected_str: &str, ty_strs: &[&str]) {
  function disjoint_types (line 443) | fn disjoint_types() {
  function simple_subtypes (line 448) | fn simple_subtypes() {
  function union_types (line 455) | fn union_types() {
  function intersect_types (line 466) | fn intersect_types() {
  function map_types (line 484) | fn map_types() {
  function set_types (line 494) | fn set_types() {
  function list_types (line 504) | fn list_types() {
  function vec_types (line 517) | fn vec_types() {
  function top_fun_types (line 524) | fn top_fun_types() {
  function fun_types (line 530) | fn fun_types() {
  function ty_pred_types (line 540) | fn ty_pred_types() {
  function eq_pred_types (line 548) | fn eq_pred_types() {
  function unbounded_poly_var (line 555) | fn unbounded_poly_var() {
  function bounded_poly_vars (line 587) | fn bounded_poly_vars() {
  function polymorphic_funs (line 608) | fn polymorphic_funs() {
  function intersect_iter (line 631) | fn intersect_iter() {
  function record_instances (line 639) | fn record_instances() {

FILE: compiler/ty/is_a.rs
  function top_fun_is_a (line 9) | fn top_fun_is_a(sub_top_fun: &ty::TopFun, par_top_fun: &ty::TopFun) -> b...
  function list_is_a (line 14) | fn list_is_a<M: ty::Pm>(sub_list: &ty::List<M>, par_list: &ty::List<M>) ...
  function record_field_is_a (line 37) | fn record_field_is_a<F, R>(variance: Variance, is_a: &F, sub: &R, par: &...
  function record_instance_is_a (line 48) | fn record_instance_is_a<M: ty::Pm>(
  function monomorphic_fun_is_a (line 75) | fn monomorphic_fun_is_a(sub_fun: &ty::Fun, par_fun: &ty::Fun) -> bool {
  function fun_is_a (line 81) | fn fun_is_a(sub_fun: &ty::Fun, par_fun: &ty::Fun) -> bool {
  function ty_is_a (line 90) | fn ty_is_a<M: ty::Pm>(
  function tvar_is_bounded_by (line 202) | fn tvar_is_bounded_by(sub_tvar: &ty::TVarId, parent_tvar: &ty::TVarId) -...
  function purity_ref_is_a (line 213) | fn purity_ref_is_a(sub: &purity::Ref, parent: &purity::Ref) -> bool {
  function inst_polymorphic_fun (line 219) | fn inst_polymorphic_fun(sub_fun: &ty::Fun, par_top_fun: &ty::TopFun) -> ...
  function ty_ref_is_a (line 229) | pub fn ty_ref_is_a<M: ty::Pm>(sub: &ty::Ref<M>, parent: &ty::Ref<M>) -> ...
  function ty_refs_equivalent (line 275) | pub fn ty_refs_equivalent<M: ty::Pm>(ty_ref1: &ty::Ref<M>, ty_ref2: &ty:...
  function purity_refs_equivalent (line 282) | pub fn purity_refs_equivalent(purity_ref1: &purity::Ref, purity_ref2: &p...
  function sym_types (line 294) | fn sym_types() {
  function set_types (line 311) | fn set_types() {
  function map_types (line 324) | fn map_types() {
  function union_types (line 341) | fn union_types() {
  function intersect_types (line 366) | fn intersect_types() {
  function any_and_never_types (line 410) | fn any_and_never_types() {
  function list_types (line 423) | fn list_types() {
  function vec_types (line 449) | fn vec_types() {
  function num_types (line 467) | fn num_types() {
  function fun_types (line 481) | fn fun_types() {
  function ty_pred_types (line 496) | fn ty_pred_types() {
  function eq_pred_type (line 519) | fn eq_pred_type() {
  function bool_types (line 537) | fn bool_types() {
  function poly_bool_types (line 548) | fn poly_bool_types() {
  function unbounded_poly_vars (line 559) | fn unbounded_poly_vars() {
  function bounded_poly_vars (line 571) | fn bounded_poly_vars() {
  function related_poly_bounds (line 595) | fn related_poly_bounds() {
  function polymorphic_funs (line 613) | fn polymorphic_funs() {
  function polymorphic_purity_funs (line 682) | fn polymorphic_purity_funs() {
  function distinct_record_cons_instances (line 694) | fn distinct_record_cons_instances() {
  function same_cons_record_instances (line 727) | fn same_cons_record_instances() {

FILE: compiler/ty/list_iter.rs
  type ListIterator (line 6) | pub struct ListIterator<'list, M: ty::Pm> {
  function new (line 12) | pub fn new(list: &'list ty::List<M>) -> ListIterator<'list, M> {
  function try_new_from_ty_ref (line 19) | pub fn try_new_from_ty_ref(ty_ref: &'list ty::Ref<M>) -> Option<ListIter...
  function fixed_len (line 26) | pub fn fixed_len(&self) -> usize {
  function has_rest (line 30) | pub fn has_rest(&self) -> bool {
  function tail_type (line 34) | pub fn tail_type(self) -> ty::List<M> {
  function collect_rest (line 38) | pub fn collect_rest(self) -> ty::Ref<M> {
  type Item (line 50) | type Item = &'list ty::Ref<M>;
  method next (line 52) | fn next(&mut self) -> Option<&'list ty::Ref<M>> {

FILE: compiler/ty/mod.rs
  type TVar (line 26) | pub struct TVar {
    method new (line 36) | pub fn new(span: Span, source_name: DataStr, bound: Ref<Poly>) -> TVar...
    method span (line 44) | pub fn span(&self) -> Span {
    method source_name (line 48) | pub fn source_name(&self) -> &str {
    method bound (line 52) | pub fn bound(&self) -> &Ref<Poly> {
  type TVarId (line 32) | pub type TVarId = ArcId<TVar>;
  type TVars (line 33) | pub type TVars = Vec<TVarId>;
  type Pm (line 58) | pub trait Pm: PartialEq + Clone + Copy + Sized + fmt::Debug {
    method resolve_ref_to_ty (line 60) | fn resolve_ref_to_ty(ty_ref: &Ref<Self>) -> &Ty<Self>;
    method resolve_ref_to_ty (line 66) | fn resolve_ref_to_ty(ty_ref: &Ref<Mono>) -> &Ty<Mono> {
    method resolve_ref_to_ty (line 77) | fn resolve_ref_to_ty(ty_ref: &Ref<Poly>) -> &Ty<Poly> {
  type Mono (line 64) | pub enum Mono {}
  type Poly (line 75) | pub struct Poly {}
  type Ref (line 86) | pub enum Ref<M: Pm> {
  function try_to_fixed (line 93) | pub fn try_to_fixed(&self) -> Option<&Ty<M>> {
  function from_vec (line 104) | pub fn from_vec(mut members: Vec<Self>) -> Self {
  function find_member (line 115) | pub fn find_member<'a, F, T>(&'a self, f: F) -> Option<T>
  function resolve_to_ty (line 130) | pub fn resolve_to_ty(&self) -> &Ty<M> {
  function is_never (line 134) | pub fn is_never(&self) -> bool {
  function as_ty (line 140) | pub fn as_ty(&self) -> &Ty<Mono> {
  function into_ty (line 149) | pub fn into_ty(self) -> Ty<Mono> {
  function from (line 160) | fn from(ty: Ty<M>) -> Self {
  function from (line 166) | fn from(tvar: TVarId) -> Self {
  type Ty (line 172) | pub enum Ty<M: Pm> {
  function unit (line 209) | pub fn unit() -> Ty<M> {
  function never (line 214) | pub fn never() -> Ty<M> {
  function is_never (line 219) | pub fn is_never(&self) -> bool {
  type Map (line 225) | pub struct Map<M: Pm> {
  function new (line 231) | pub fn new(key: Ref<M>, value: Ref<M>) -> Map<M> {
  function key (line 235) | pub fn key(&self) -> &Ref<M> {
  function value (line 239) | pub fn value(&self) -> &Ref<M> {
  function from (line 245) | fn from(map: Map<M>) -> Self {
  function from (line 251) | fn from(map: Map<M>) -> Self {
  type List (line 257) | pub struct List<M: Pm> {
  function new (line 264) | pub fn new(fixed: Box<[Ref<M>]>, rest: Ref<M>) -> List<M> {
  function new_uniform (line 272) | pub fn new_uniform(rest: Ref<M>) -> List<M> {
  function new_tuple (line 280) | pub fn new_tuple(fixed: Box<[Ref<M>]>) -> List<M> {
  function empty (line 288) | pub fn empty() -> List<M> {
  function fixed (line 292) | pub fn fixed(&self) -> &[Ref<M>] {
  function rest (line 299) | pub fn rest(&self) -> &Ref<M> {
  function size_range (line 303) | pub fn size_range(&self) -> Range<usize> {
  function has_disjoint_arity (line 311) | pub fn has_disjoint_arity(&self, other: &Self) -> bool {
  function is_empty (line 319) | pub fn is_empty(&self) -> bool {
  function has_rest (line 324) | pub fn has_rest(&self) -> bool {
  function from (line 330) | fn from(list: List<M>) -> Self {
  function from (line 336) | fn from(list: List<M>) -> Self {
  type TopFun (line 342) | pub struct TopFun {
    method new (line 349) | pub fn new(purity: purity::Ref, ret: Ref<Poly>) -> TopFun {
    method new_for_pred (line 354) | pub fn new_for_pred() -> TopFun {
    method purity (line 358) | pub fn purity(&self) -> &purity::Ref {
    method ret (line 362) | pub fn ret(&self) -> &Ref<Poly> {
  function from (line 368) | fn from(top_fun: TopFun) -> Self {
  function from (line 374) | fn from(top_fun: TopFun) -> Self {
  type Fun (line 380) | pub struct Fun {
    method new (line 388) | pub fn new(pvars: purity::PVars, tvars: TVars, top_fun: TopFun, params...
    method new_mono (line 398) | pub fn new_mono(params: List<Poly>, purity: purity::Ref, ret: Ref<Poly...
    method new_for_main (line 408) | pub fn new_for_main() -> Fun {
    method new_for_ty_pred (line 420) | pub fn new_for_ty_pred() -> Fun {
    method new_for_eq_pred (line 433) | pub fn new_for_eq_pred() -> Fun {
    method pvars (line 442) | pub fn pvars(&self) -> &[purity::PVarId] {
    method tvars (line 446) | pub fn tvars(&self) -> &[TVarId] {
    method top_fun (line 450) | pub fn top_fun(&self) -> &TopFun {
    method purity (line 454) | pub fn purity(&self) -> &purity::Ref {
    method params (line 458) | pub fn params(&self) -> &List<Poly> {
    method ret (line 462) | pub fn ret(&self) -> &Ref<Poly> {
    method has_polymorphic_vars (line 466) | pub fn has_polymorphic_vars(&self) -> bool {
    method with_polymorphic_vars (line 470) | pub fn with_polymorphic_vars(self, pvars: purity::PVars, tvars: TVars)...
  function from (line 480) | fn from(fun: Fun) -> Self {
  function from (line 486) | fn from(fun: Fun) -> Self {

FILE: compiler/ty/pred.rs
  type TestTy (line 9) | pub enum TestTy {
    method match_subject_ref (line 28) | pub fn match_subject_ref<M: ty::Pm>(&self, ty_ref: &ty::Ref<M>) -> Opt...
    method to_ty (line 108) | pub fn to_ty(&self) -> Ty<ty::Poly> {
    method fmt (line 140) | fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::E...
  function assert_test_ty_will_match (line 167) | fn assert_test_ty_will_match(test_ty: &TestTy, subject_ref: impl Into<ty...
  function assert_test_ty_may_match (line 176) | fn assert_test_ty_may_match(test_ty: &TestTy, subject_ref: impl Into<ty:...
  function assert_test_ty_wont_match (line 185) | fn assert_test_ty_wont_match(test_ty: &TestTy, subject_ref: impl Into<ty...
  function assert_trivial_test_ty (line 194) | fn assert_trivial_test_ty(expected_ty: Ty<ty::Poly>, test_ty: TestTy) {
  function sym_test_ty (line 208) | fn sym_test_ty() {
  function str_test_ty (line 217) | fn str_test_ty() {
  function bool_test_ty (line 222) | fn bool_test_ty() {
  function num_test_ty (line 231) | fn num_test_ty() {
  function int_test_ty (line 241) | fn int_test_ty() {
  function float_test_ty (line 250) | fn float_test_ty() {
  function char_test_ty (line 259) | fn char_test_ty() {
  function list_test_ty (line 264) | fn list_test_ty() {
  function vector_test_ty (line 269) | fn vector_test_ty() {
  function set_test_ty (line 278) | fn set_test_ty() {
  function map_test_ty (line 283) | fn map_test_ty() {
  function fun_test_ty (line 291) | fn fun_test_ty() {
  function nil_test_ty (line 300) | fn nil_test_ty() {
  function top_record_test_ty (line 309) | fn top_record_test_ty() {
  function record_class_test_ty (line 334) | fn record_class_test_ty() {
  function union_subject_ref (line 374) | fn union_subject_ref() {
  function intersect_subject_ref (line 396) | fn intersect_subject_ref() {

FILE: compiler/ty/props.rs
  function ty_has_subtypes (line 6) | fn ty_has_subtypes<M: ty::Pm>(ty: &Ty<M>) -> bool {
  function has_subtypes (line 58) | pub fn has_subtypes<M: ty::Pm>(ty_ref: &ty::Ref<M>) -> bool {
  function ty_is_literal (line 65) | fn ty_is_literal<M: ty::Pm>(ty: &Ty<M>) -> bool {
  function is_literal (line 74) | pub fn is_literal<M: ty::Pm>(ty_ref: &ty::Ref<M>) -> bool {
  function str_has_subtypes (line 90) | fn str_has_subtypes(datum_str: &str) -> bool {
  function str_is_literal (line 95) | fn str_is_literal(datum_str: &str) -> bool {
  function poly_subtypes (line 101) | fn poly_subtypes() {
  function poly_literal (line 137) | fn poly_literal() {
  function mono_record_type (line 168) | fn mono_record_type() {
  function poly_record_type (line 185) | fn poly_record_type() {

FILE: compiler/ty/purity.rs
  type Purity (line 7) | pub enum Purity {
  type PVar (line 13) | pub struct PVar {
    method new (line 22) | pub fn new(span: Span, source_name: DataStr) -> PVarId {
    method span (line 26) | pub fn span(&self) -> Span {
    method source_name (line 30) | pub fn source_name(&self) -> &str {
  type PVarId (line 18) | pub type PVarId = ArcId<PVar>;
  type PVars (line 19) | pub type PVars = Vec<PVarId>;
  type Ref (line 36) | pub enum Ref {
    method from (line 42) | fn from(purity: Purity) -> Self {
    method from (line 48) | fn from(pvar: PVarId) -> Self {

FILE: compiler/ty/record.rs
  type Field (line 14) | pub struct Field {
    method new (line 21) | pub fn new(span: Span, name: DataStr, ty_ref: ty::Ref<ty::Poly>) -> Se...
    method span (line 26) | pub fn span(&self) -> Span {
    method name (line 34) | pub fn name(&self) -> &DataStr {
    method ty_ref (line 39) | pub fn ty_ref(&self) -> &ty::Ref<ty::Poly> {
    method accessor_fun_type (line 44) | pub fn accessor_fun_type(&self, cons_id: &ConsId) -> ty::Fun {
  type PolyParam (line 62) | pub enum PolyParam {
    method variance (line 75) | pub fn variance(&self) -> Variance {
  type Cons (line 92) | pub struct Cons {
    method new (line 101) | pub fn new(
    method span (line 118) | pub fn span(&self) -> Span {
    method ty_cons_name (line 126) | pub fn ty_cons_name(&self) -> &DataStr {
    method value_cons_name (line 131) | pub fn value_cons_name(&self) -> &DataStr {
    method poly_params (line 136) | pub fn poly_params(&self) -> &[PolyParam] {
    method is_singleton (line 146) | pub fn is_singleton(&self) -> bool {
    method fields (line 151) | pub fn fields(&self) -> &[Field] {
    method identity_ty_args (line 156) | pub fn identity_ty_args(&self) -> TyArgs<ty::Poly> {
    method value_cons_fun_type (line 180) | pub fn value_cons_fun_type(cons_id: &ConsId) -> ty::Fun {
  type ConsId (line 199) | pub type ConsId = ArcId<Cons>;
  function from (line 202) | fn from(cons_id: ConsId) -> Self {
  function from (line 208) | fn from(cons_id: ConsId) -> Self {
  type Instance (line 214) | pub struct Instance<M: ty::Pm> {
  function new (line 220) | pub fn new(cons: ConsId, ty_args: TyArgs<M>) -> Self {
  function cons (line 225) | pub fn cons(&self) -> &ConsId {
  function ty_args (line 232) | pub fn ty_args(&self) -> &TyArgs<M> {
  function from (line 238) | fn from(instance: Instance<M>) -> Self {
  function from (line 244) | fn from(instance: Instance<M>) -> Self {

FILE: compiler/ty/select.rs
  type Error (line 11) | pub enum Error<'vars> {
  type SelectCtx (line 23) | pub struct SelectCtx<'vars> {
  function new (line 32) | pub fn new(
  function add_evidence_top_fun (line 44) | fn add_evidence_top_fun(&mut self, target_top_fun: &ty::TopFun, evidence...
  function add_evidence_fun (line 49) | fn add_evidence_fun(&mut self, target_top_fun: &ty::TopFun, evidence_fun...
  function add_evidence_record (line 68) | fn add_evidence_record(
  function add_evidence_list (line 88) | fn add_evidence_list(
  function add_evidence_never (line 115) | fn add_evidence_never(&mut self, target_ty: &Ty<ty::Poly>) {
  function add_evidence_ty (line 139) | fn add_evidence_ty(
  function add_var_evidence (line 208) | fn add_var_evidence(&mut self, tvar: &ty::TVarId, evidence_poly: &ty::Re...
  function add_evidence (line 223) | pub fn add_evidence(
  function add_evidence_purity (line 237) | pub fn add_evidence_purity(
  function into_poly_ty_args (line 261) | pub fn into_poly_ty_args(mut self) -> TyArgs<ty::Poly> {
  function into_complete_poly_ty_args (line 286) | pub fn into_complete_poly_ty_args(mut self) -> Result<TyArgs<ty::Poly>, ...
  type TestScope (line 319) | struct TestScope {
    method new (line 327) | fn new(polymorphic_str: &str) -> TestScope {
    method poly_for_str (line 353) | fn poly_for_str(&self, poly_str: &str) -> ty::Ref<ty::Poly> {
    method purity_for_str (line 360) | fn purity_for_str(&self, poly_str: &str) -> purity::Ref {
    method select_ctx (line 367) | fn select_ctx(&self) -> SelectCtx<'_> {
  function assert_unselected_type (line 372) | fn assert_unselected_type(ctx: &SelectCtx<'_>, poly_var: &ty::Ref<ty::Po...
  function assert_selected_type (line 382) | fn assert_selected_type(
  function assert_unselected_purity (line 396) | fn assert_unselected_purity(ctx: &SelectCtx<'_>, poly_var: &purity::Ref) {
  function assert_selected_purity (line 406) | fn assert_selected_purity(
  function trivial_tvar (line 424) | fn trivial_tvar() {
  function poly_conflicing_tvar (line 439) | fn poly_conflicing_tvar() {
  function set_types (line 458) | fn set_types() {
  function map_types (line 472) | fn map_types() {
  function fixed_list_types (line 488) | fn fixed_list_types() {
  function listof_types (line 504) | fn listof_types() {
  function listof_from_fixed_list (line 518) | fn listof_from_fixed_list() {
  function listof_from_list_union (line 532) | fn listof_from_list_union() {
  function fixed_vector_types (line 546) | fn fixed_vector_types() {
  function vectorof_types (line 562) | fn vectorof_types() {
  function vectorof_from_fixed_vector (line 576) | fn vectorof_from_fixed_vector() {
  function union_types (line 590) | fn union_types() {
  function bounded_union_types (line 604) | fn bounded_union_types() {
  function top_fun_types (line 627) | fn top_fun_types() {
  function top_fun_purities (line 641) | fn top_fun_purities() {
  function top_fun_from_fun (line 662) | fn top_fun_from_fun() {
  function top_fun_from_poly_fun (line 676) | fn top_fun_from_poly_fun() {
  function top_fun_from_ty_pred (line 694) | fn top_fun_from_ty_pred() {
  function top_fun_from_eq_pred (line 708) | fn top_fun_from_eq_pred() {
  function fun_types (line 719) | fn fun_types() {
  function fun_purities (line 736) | fn fun_purities() {
  function fun_purity_conflict (line 751) | fn fun_purity_conflict() {
  function fun_type_from_ty_pred (line 771) | fn fun_type_from_ty_pred() {
  function fun_type_from_eq_pred (line 784) | fn fun_type_from_eq_pred() {
  function ty_pred_purity (line 797) | fn ty_pred_purity() {

FILE: compiler/ty/subst.rs
  function subst_ty_ref_slice (line 7) | fn subst_ty_ref_slice<S>(stx: &S, inputs: &[ty::Ref<S::InputPM>]) -> Box...
  function subst_list (line 14) | fn subst_list<S>(stx: &S, list: &ty::List<S::InputPM>) -> ty::List<S::Ou...
  function subst_record_instance (line 24) | fn subst_record_instance<S>(
  function subst_top_fun (line 51) | fn subst_top_fun<S>(stx: &S, top_fun: &ty::TopFun) -> ty::TopFun
  function subst_fun (line 63) | fn subst_fun<S>(stx: &S, fun: &ty::Fun) -> ty::Fun
  function subst_ty (line 78) | fn subst_ty<S>(stx: &S, ty: &Ty<S::InputPM>) -> Ty<S::OutputPM>
  type Substitution (line 113) | trait Substitution {
    method subst_purity_ref (line 118) | fn subst_purity_ref(&self, poly: &purity::Ref) -> purity::Ref;
    method subst_ty_ref (line 119) | fn subst_ty_ref(&self, input: &ty::Ref<Self::InputPM>) -> ty::Ref<Self...
    method as_poly_subst (line 120) | fn as_poly_subst(&self) -> &Self::AsPolySubst;
    type InputPM (line 124) | type InputPM = ty::Poly;
    type OutputPM (line 125) | type OutputPM = ty::Poly;
    type AsPolySubst (line 126) | type AsPolySubst = Self;
    method subst_purity_ref (line 128) | fn subst_purity_ref(&self, poly: &purity::Ref) -> purity::Ref {
    method subst_ty_ref (line 141) | fn subst_ty_ref(&self, poly: &ty::Ref<ty::Poly>) -> ty::Ref<ty::Poly> {
    method as_poly_subst (line 154) | fn as_poly_subst(&self) -> &Self {
    type InputPM (line 162) | type InputPM = ty::Poly;
    type OutputPM (line 163) | type OutputPM = ty::Poly;
    type AsPolySubst (line 164) | type AsPolySubst = Self;
    method subst_purity_ref (line 166) | fn subst_purity_ref(&self, poly: &purity::Ref) -> purity::Ref {
    method subst_ty_ref (line 170) | fn subst_ty_ref(&self, poly: &ty::Ref<ty::Poly>) -> ty::Ref<ty::Poly> {
    method as_poly_subst (line 174) | fn as_poly_subst(&self) -> &Self {
    type InputPM (line 192) | type InputPM = ty::Mono;
    type OutputPM (line 193) | type OutputPM = ty::Poly;
    type AsPolySubst (line 194) | type AsPolySubst = PolyIdentity;
    method subst_purity_ref (line 196) | fn subst_purity_ref(&self, poly: &purity::Ref) -> purity::Ref {
    method subst_ty_ref (line 200) | fn subst_ty_ref(&self, mono: &ty::Ref<ty::Mono>) -> ty::Ref<ty::Poly> {
    method as_poly_subst (line 204) | fn as_poly_subst(&self) -> &PolyIdentity {
    type InputPM (line 224) | type InputPM = ty::Poly;
    type OutputPM (line 225) | type OutputPM = ty::Mono;
    type AsPolySubst (line 226) | type AsPolySubst = PartialMonomorphise<'tyargs>;
    method subst_purity_ref (line 228) | fn subst_purity_ref(&self, poly: &purity::Ref) -> purity::Ref {
    method subst_ty_ref (line 245) | fn subst_ty_ref(&self, poly: &ty::Ref<ty::Poly>) -> ty::Ref<ty::Mono> {
    method as_poly_subst (line 262) | fn as_poly_subst(&self) -> &PartialMonomorphise<'tyargs> {
    type InputPM (line 272) | type InputPM = ty::Poly;
    type OutputPM (line 273) | type OutputPM = ty::Poly;
    type AsPolySubst (line 274) | type AsPolySubst = Self;
    method subst_purity_ref (line 276) | fn subst_purity_ref(&self, poly: &purity::Ref) -> purity::Ref {
    method subst_ty_ref (line 289) | fn subst_ty_ref(&self, poly: &ty::Ref<ty::Poly>) -> ty::Ref<ty::Poly> {
    method as_poly_subst (line 302) | fn as_poly_subst(&self) -> &Self {
  type PolyIdentity (line 159) | struct PolyIdentity {}
  type MonoToPoly (line 179) | struct MonoToPoly {
    method new (line 184) | fn new() -> MonoToPoly {
  type Monomorphise (line 209) | struct Monomorphise<'tyargs> {
  function new (line 215) | fn new(mta: &'tyargs TyArgs<ty::Mono>) -> Monomorphise<'tyargs> {
  type PartialMonomorphise (line 267) | struct PartialMonomorphise<'tyargs> {
  function subst_poly (line 307) | pub fn subst_poly(pta: &TyArgs<ty::Poly>, poly: &ty::Ref<ty::Poly>) -> t...
  function subst_poly_fun (line 311) | pub fn subst_poly_fun(pta: &TyArgs<ty::Poly>, fun: &ty::Fun) -> ty::Fun {
  function subst_purity (line 315) | pub fn subst_purity(pta: &TyArgs<ty::Poly>, purity: &purity::Ref) -> pur...
  function monomorphise (line 319) | pub fn monomorphise(mta: &TyArgs<ty::Mono>, poly: &ty::Ref<ty::Poly>) ->...
  function monomorphise_purity (line 324) | pub fn monomorphise_purity(mta: &TyArgs<ty::Mono>, poly: &purity::Ref) -...
  function monomorphise_list (line 329) | pub fn monomorphise_list(mta: &TyArgs<ty::Mono>, poly: &ty::List<ty::Pol...

FILE: compiler/ty/subtract.rs
  function subtract_ref_iters (line 4) | fn subtract_ref_iters<'a, I, M>(minuend_iter: I, subtrahend_ref: &ty::Re...
  function subtract_tys (line 14) | fn subtract_tys<M: ty::Pm>(
  function subtract_ty_refs (line 70) | pub fn subtract_ty_refs<M: ty::Pm>(
  function assert_subtraction (line 111) | fn assert_subtraction(expected_str: &str, minuend_str: &str, subrahend_s...
  function trivial_subtraction (line 121) | fn trivial_subtraction() {
  function bool_subtraction (line 127) | fn bool_subtraction() {
  function num_subtraction (line 133) | fn num_subtraction() {
  function union_subtraction (line 139) | fn union_subtraction() {
  function list_subtraction (line 149) | fn list_subtraction() {
  function poly_substraction (line 154) | fn poly_substraction() {
  function poly_record_type (line 183) | fn poly_record_type() {

FILE: compiler/ty/ty_args.rs
  type TyArgs (line 9) | pub struct TyArgs<M: ty::Pm> {
  function new (line 15) | pub fn new(
  function empty (line 25) | pub fn empty() -> Self {
  function pvar_purities (line 32) | pub fn pvar_purities(&self) -> &HashMap<purity::PVarId, purity::Ref> {
  function tvar_types (line 36) | pub fn tvar_types(&self) -> &HashMap<ty::TVarId, ty::Ref<M>> {
  function from_upper_bound (line 43) | pub fn from_upper_bound(pvars: &[purity::PVarId], tvars: &[ty::TVarId]) ...

FILE: compiler/ty/unify.rs
  type UnifiedTy (line 23) | enum UnifiedTy<M: ty::Pm> {
  type UnifiedList (line 37) | pub enum UnifiedList<M: ty::Pm> {
  function unify_ty_refs (line 42) | fn unify_ty_refs<M: ty::Pm>(ref1: &ty::Ref<M>, ref2: &ty::Ref<M>) -> Uni...
  function try_list_to_exact_pair (line 56) | fn try_list_to_exact_pair<M: ty::Pm>(list: &ty::List<M>) -> Option<&ty::...
  function union_push (line 67) | fn union_push<M: ty::Pm>(output_members: &mut Vec<ty::Ref<M>>, new_membe...
  function union_extend (line 88) | fn union_extend<M, I>(existing_members: Vec<ty::Ref<M>>, new_members: I)...
  function unify_top_fun (line 102) | fn unify_top_fun<M: ty::Pm>(top_fun1: &ty::TopFun, top_fun2: &ty::TopFun...
  function unify_fun (line 109) | fn unify_fun<M: ty::Pm>(fun1: &ty::Fun, fun2: &ty::Fun) -> UnifiedTy<M> {
  function unify_record_field_purities (line 130) | fn unify_record_field_purities<M: ty::Pm>(
  function unify_record_field_ty_refs (line 155) | fn unify_record_field_ty_refs<M: ty::Pm>(
  function unify_record_instance (line 183) | fn unify_record_instance<M: ty::Pm>(
  function unify_ty (line 238) | fn unify_ty<M: ty::Pm>(
  function unify_purity_refs (line 360) | pub fn unify_purity_refs(purity1: &purity::Ref, purity2: &purity::Ref) -...
  function unify_to_ty_ref (line 377) | pub fn unify_to_ty_ref<M: ty::Pm>(ty_ref1: &ty::Ref<M>, ty_ref2: &ty::Re...
  function unify_ty_ref_iter (line 385) | pub fn unify_ty_ref_iter<M, I>(new_members: I) -> ty::Ref<M>
  function unify_list (line 393) | pub fn unify_list<M: ty::Pm>(list1: &ty::List<M>, list2: &ty::List<M>) -...
  function assert_discerned (line 437) | fn assert_discerned(ty_str1: &str, ty_str2: &str) {
  function assert_merged (line 444) | fn assert_merged(expected_str: &str, ty_str1: &str, ty_str2: &str) {
  function assert_merged_iter (line 457) | fn assert_merged_iter(expected_str: &str, ty_strs: &[&str]) {
  function disjoint_types (line 465) | fn disjoint_types() {
  function two_sym_types (line 470) | fn two_sym_types() {
  function literal_sym_and_any_sym (line 475) | fn literal_sym_and_any_sym() {
  function two_bool_types (line 480) | fn two_bool_types() {
  function num_types (line 485) | fn num_types() {
  function top_fun_types (line 492) | fn top_fun_types() {
  function fun_types (line 497) | fn fun_types() {
  function ty_pred_types (line 509) | fn ty_pred_types() {
  function eq_pred_type (line 517) | fn eq_pred_type() {
  function set_types (line 524) | fn set_types() {
  function map_types (line 530) | fn map_types() {
  function union_types (line 539) | fn union_types() {
  function unify_iter (line 571) | fn unify_iter() {
  function list_types (line 587) | fn list_types() {
  function vec_types (line 603) | fn vec_types() {
  function polymorphic_funs (line 609) | fn polymorphic_funs() {
  function purity_refs (line 631) | fn purity_refs() {
  function related_poly_bounds (line 666) | fn related_poly_bounds() {
  function record_instances (line 692) | fn record_instances() {

FILE: compiler/ty/var_usage.rs
  type Variance (line 17) | pub enum Variance {
    type Output (line 27) | type Output = Variance;
    method mul (line 40) | fn mul(self, rhs: Variance) -> Variance {
    method bitand_assign (line 55) | fn bitand_assign(&mut self, rhs: Variance) {
  type VarUsages (line 63) | pub struct VarUsages {
    method new (line 176) | pub fn new() -> Self {
    method add_poly_usages (line 180) | pub fn add_poly_usages(&mut self, poly_ref: &ty::Ref<ty::Poly>) {
    method pvar_variance (line 184) | pub fn pvar_variance(&self, pvar: &purity::PVarId) -> Option<Variance> {
    method tvar_variance (line 188) | pub fn tvar_variance(&self, tvar: &ty::TVarId) -> Option<Variance> {
  function visit_list (line 68) | fn visit_list(var_usages: &mut VarUsages, polarity: Variance, list: &ty:...
  function visit_top_fun (line 76) | fn visit_top_fun(var_usages: &mut VarUsages, polarity: Variance, top_fun...
  function visit_ty (line 80) | fn visit_ty(var_usages: &mut VarUsages, polarity: Variance, poly_ty: &Ty...
  function visit_purity (line 147) | fn visit_purity(var_usages: &mut VarUsages, polarity: Variance, purity_r...
  function visit_poly (line 160) | fn visit_poly(var_usages: &mut VarUsages, polarity: Variance, poly_ref: ...
  function test_variance_mul (line 201) | fn test_variance_mul() {
  function convariant_usage (line 219) | fn convariant_usage() {
  function contravariant_usage (line 229) | fn contravariant_usage() {
  function invariant_usage (line 250) | fn invariant_usage() {

FILE: compiler/typeck/dce.rs
  function expr_can_side_effect (line 9) | pub fn expr_can_side_effect(expr: &hir::Expr<hir::Inferred>) -> bool {
  function pure_app_expr (line 59) | fn pure_app_expr() {
  function impure_app_expr (line 83) | fn impure_app_expr() {

FILE: compiler/typeck/destruc.rs
  function type_for_decl_list_destruc (line 7) | pub fn type_for_decl_list_destruc(
  function type_for_decl_destruc (line 39) | pub fn type_for_decl_destruc(
  function visit_scalar_locals (line 58) | fn visit_scalar_locals<F>(scalar: &destruc::Scalar<hir::Lowered>, visito...
  function visit_locals (line 70) | pub fn visit_locals<F>(

FILE: compiler/typeck/error.rs
  type WantedArity (line 14) | pub struct WantedArity {
    method new (line 20) | pub fn new(fixed_len: usize, has_rest: bool) -> WantedArity {
    method fmt (line 29) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type IsNotRetTy (line 39) | pub struct IsNotRetTy {
    method new (line 46) | pub fn new(
  type ErrorKind (line 60) | pub enum ErrorKind {
  type Error (line 77) | pub struct Error {
    method new (line 83) | pub fn new(span: Span, kind: ErrorKind) -> Error {
    method new_with_loc_trace (line 87) | pub fn new_with_loc_trace(loc_trace: LocTrace, kind: ErrorKind) -> Err...
    method kind (line 91) | pub fn kind(&self) -> &ErrorKind {
    method with_macro_invocation_span (line 95) | pub fn with_macro_invocation_span(self, span: Span) -> Error {
  function from (line 104) | fn from(error: Error) -> Self {
  function from (line 254) | fn from(error: Error) -> Self {
  method fmt (line 262) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: compiler/typeck/infer.rs
  type Result (line 23) | type Result<T> = result::Result<T, Error>;
  type InferredNode (line 26) | pub struct InferredNode {
    method is_divergent (line 34) | fn is_divergent(&self) -> bool {
    method into_expr (line 38) | pub fn into_expr(self) -> hir::Expr<hir::Inferred> {
    method result_ty (line 42) | pub fn result_ty(&self) -> &ty::Ref<ty::Poly> {
  type NodeBool (line 48) | enum NodeBool {
  type VarTypeCond (line 53) | struct VarTypeCond {
    method with_when (line 60) | fn with_when(self, when: NodeBool) -> VarTypeCond {
    method into_inverted (line 64) | fn into_inverted(self) -> VarTypeCond {
  type FunApp (line 82) | struct FunApp {
  type VarType (line 88) | enum VarType {
  type PurityVar (line 110) | enum PurityVar {
    method into_poly (line 155) | fn into_poly(self) -> purity::Ref {
  type RetExprResultUse (line 116) | struct RetExprResultUse<'a> {
  type ResultUse (line 125) | enum ResultUse<'a> {
  function required_type (line 140) | fn required_type(&self) -> &'a ty::Ref<ty::Poly> {
  function is_used (line 149) | fn is_used(&self) -> bool {
  type InputDef (line 163) | enum InputDef {
  type InferredLocals (line 168) | pub type InferredLocals = HashMap<hir::LocalId, ty::Ref<ty::Poly>>;
  type InferredModuleVars (line 169) | pub type InferredModuleVars = HashMap<ModuleId, Arc<InferredLocals>>;
  type InferredModule (line 171) | pub struct InferredModule {
  type RecursiveDefsCtx (line 176) | struct RecursiveDefsCtx<'types> {
  function try_to_bool (line 191) | fn try_to_bool(poly: &ty::Ref<ty::Poly>) -> Option<bool> {
  function unify_app_purity (line 198) | fn unify_app_purity(pv: &mut PurityVar, app_purity: &purity::Ref) {
  function error_kind_for_type_error (line 205) | fn error_kind_for_type_error(
  function ensure_is_a (line 239) | fn ensure_is_a(
  function member_type_for_poly_list (line 257) | fn member_type_for_poly_list(
  function keep_exprs_for_side_effects (line 290) | fn keep_exprs_for_side_effects(
  function new (line 314) | fn new(
  function new_local_ref_node (line 357) | fn new_local_ref_node(
  function insert_free_ty (line 392) | fn insert_free_ty(&mut self, initial_type: ty::Ref<ty::Poly>) -> FreeTyId {
  function visit_lit (line 396) | fn visit_lit(&mut self, result_use: &ResultUse<'_>, datum: Datum) -> Res...
  function with_type_conds_applied (line 413) | fn with_type_conds_applied<F, R>(
  function visit_cond (line 453) | fn visit_cond(
  function visit_ty_pred (line 573) | fn visit_ty_pred(
  function visit_eq_pred (line 591) | fn visit_eq_pred(&self, result_use: &ResultUse<'_>, span: Span) -> Resul...
  function visit_record_cons (line 604) | fn visit_record_cons(
  function visit_field_accessor (line 622) | fn visit_field_accessor(
  function type_for_free_ref (line 642) | fn type_for_free_ref(
  function visit_export_ref (line 659) | fn visit_export_ref(
  function visit_local_ref (line 681) | fn visit_local_ref(
  function visit_do (line 726) | fn visit_do(
  function visit_fun (line 791) | fn visit_fun(
  function visit_fun_app (line 948) | fn visit_fun_app(
  function visit_recur (line 1127) | fn visit_recur(
  function visit_fixed_ty_pred_app (line 1219) | fn visit_fixed_ty_pred_app(
  function visit_rest_ty_pred_app (line 1312) | fn visit_rest_ty_pred_app(
  function visit_fixed_eq_pred_app (line 1381) | fn visit_fixed_eq_pred_app(
  function visit_app (line 1550) | fn visit_app(
  function visit_let (line 1635) | fn visit_let(
  function visit_rust_fun (line 1693) | fn visit_rust_fun(
  function visit_expr_with_self_local_id (line 1714) | fn visit_expr_with_self_local_id(
  function visit_expr (line 1756) | fn visit_expr(
  function destruc_scalar_value (line 1765) | fn destruc_scalar_value(
  function destruc_rest_value (line 1792) | fn destruc_rest_value(
  function destruc_list_value (line 1822) | fn destruc_list_value(
  function destruc_value (line 1845) | fn destruc_value(
  function visit_def (line 1863) | fn visit_def(&mut self, hir_def: hir::Def<hir::Lowered>) -> Result<hir::...
  function recurse_into_def_id (line 1909) | fn recurse_into_def_id(&mut self, def_id: InputDefId) -> Result<()> {
  function into_inferred_module (line 1924) | fn into_inferred_module(mut self) -> result::Result<InferredModule, Vec<...
  function ensure_main_type (line 1963) | pub fn ensure_main_type(
  function infer_module (line 1998) | pub fn infer_module(
  function infer_repl_expr (line 2005) | pub fn infer_repl_expr(
  function type_for_expr (line 2021) | fn type_for_expr(
  function assert_type_for_expr (line 2034) | fn assert_type_for_expr(ty_str: &str, expr_str: &str) {
  function assert_constrained_type_for_expr (line 2041) | fn assert_constrained_type_for_expr(expected_ty_str: &str, expr_str: &st...
  function assert_type_error (line 2049) | fn assert_type_error(err: &Error, expr_str: &str) {
  function literal_expr (line 2055) | fn literal_expr() {
  function do_expr (line 2060) | fn do_expr() {
  function cond_expr (line 2069) | fn cond_expr() {
  function fun_expr (line 2080) | fn fun_expr() {
  function app_types (line 2129) | fn app_types() {
  function recur_expr (line 2163) | fn recur_expr() {
  function app_purity (line 2188) | fn app_purity() {
  function impure_app_within_pure (line 2200) | fn impure_app_within_pure() {
  function too_many_args (line 2213) | fn too_many_args() {
  function not_enough_args (line 2223) | fn not_enough_args() {
  function list_destruc (line 2233) | fn list_destruc() {
  function var_ref (line 2242) | fn var_ref() {
  function ty_pred (line 2247) | fn ty_pred() {
  function eq_pred (line 2255) | fn eq_pred() {

FILE: driver/main.rs
  constant ARRET_FILE_EXTENSION (line 11) | const ARRET_FILE_EXTENSION: &str = ".arret";
  function input_arg_to_source_file (line 13) | fn input_arg_to_source_file(
  function main (line 33) | fn main() {

FILE: driver/subcommand/compile.rs
  constant MIR_OUTPUT_TYPE (line 10) | const MIR_OUTPUT_TYPE: arret_compiler::OutputType = arret_compiler::Outp...
  function try_compile_input_file (line 12) | fn try_compile_input_file(
  function compile_input_file (line 50) | pub fn compile_input_file(

FILE: driver/subcommand/eval.rs
  function try_eval_input_file (line 7) | fn try_eval_input_file(
  function eval_input_file (line 22) | pub fn eval_input_file(ccx: &CompileCtx, input_file: &arret_compiler::So...

FILE: driver/subcommand/repl/arret_helper.rs
  constant UNBOUND_COMPLETIONS (line 13) | const UNBOUND_COMPLETIONS: &[&str] = &[
  type ArretHelper (line 25) | pub struct ArretHelper {
    method new (line 46) | pub fn new(mut bound_names: Vec<DataStr>) -> ArretHelper {
    type Candidate (line 57) | type Candidate = String;
    method complete (line 59) | fn complete(
    type Hint (line 107) | type Hint = String;
    method hint (line 109) | fn hint(&self, line: &str, pos: usize, _: &rustyline::Context<'_>) -> ...
    method highlight (line 147) | fn highlight<'l>(&self, line: &'l str, _pos: usize) -> Cow<'l, str> {
    method highlight_prompt (line 175) | fn highlight_prompt<'b, 's: 'b, 'p: 'b>(
    method highlight_hint (line 184) | fn highlight_hint<'h>(&self, hint: &'h str) -> Cow<'h, str> {
    method highlight_char (line 198) | fn highlight_char(&self, line: &str, _pos: usize) -> bool {
    method validate (line 208) | fn validate(
  function sorted_strings_prefixed_by (line 29) | fn sorted_strings_prefixed_by<'a, T: AsRef<str>>(
  function assert_sorted_strings_prefixed_by (line 225) | fn assert_sorted_strings_prefixed_by(
  function sorted_strings_prefixed_by_empty (line 239) | fn sorted_strings_prefixed_by_empty() {
  function sorted_strings_prefixed_by_missing_at_beginning (line 245) | fn sorted_strings_prefixed_by_missing_at_beginning() {
  function sorted_strings_prefixed_by_missing_in_middle (line 252) | fn sorted_strings_prefixed_by_missing_in_middle() {
  function sorted_strings_prefixed_by_missing_at_end (line 259) | fn sorted_strings_prefixed_by_missing_at_end() {
  function sorted_strings_prefixed_by_only_self (line 266) | fn sorted_strings_prefixed_by_only_self() {
  function strings_prefixed_by_only_other (line 272) | fn strings_prefixed_by_only_other() {
  function strings_prefixed_by_self_and_other (line 279) | fn strings_prefixed_by_self_and_other() {

FILE: driver/subcommand/repl/command.rs
  constant TYPE_ONLY_PREFIX (line 1) | pub const TYPE_ONLY_PREFIX: &str = "/type ";
  constant QUIT_COMMAND (line 2) | pub const QUIT_COMMAND: &str = "/quit";
  constant HELP_COMMAND (line 3) | pub const HELP_COMMAND: &str = "/help";
  type ParsedCommand (line 5) | pub enum ParsedCommand {
  function parse_command (line 12) | pub fn parse_command(mut line: String) -> ParsedCommand {

FILE: driver/subcommand/repl/history.rs
  function repl_history_path (line 6) | pub fn repl_history_path() -> Option<path::PathBuf> {

FILE: driver/subcommand/repl/mod.rs
  constant PROMPT (line 19) | const PROMPT: &str = "arret> ";
  function interactive_loop (line 21) | pub fn interactive_loop(ccx: Arc<CompileCtx>, include_path: Option<path:...

FILE: driver/subcommand/repl/syntax.rs
  constant MAXIMUM_PARSED_LINE_LEN (line 11) | pub const MAXIMUM_PARSED_LINE_LEN: usize = 512;
  function error_for_line (line 13) | pub fn error_for_line(mut line: &str) -> Option<arret_syntax::error::Err...
  function error_context_for_eol (line 36) | pub fn error_context_for_eol(line: &str) -> Option<arret_syntax::error::...

FILE: editors/code/src/test/downloadVsCode.ts
  function main (line 5) | async function main(): Promise<void> {

FILE: editors/code/src/test/runTest.ts
  function main (line 7) | async function main(): Promise<void> {

FILE: editors/code/src/test/suite/index.ts
  function run (line 5) | function run(): Promise<void> {

FILE: editors/code/src/test/vsCodeVersion.ts
  constant VSCODE_VERSION (line 1) | const VSCODE_VERSION = '1.60.0';

FILE: lsp-server/capabilities.rs
  function server_capabilities (line 1) | pub fn server_capabilities() -> lsp_types::ServerCapabilities {

FILE: lsp-server/handler/mod.rs
  type SyncNotificationHandler (line 13) | pub trait SyncNotificationHandler {
    method handle (line 16) | fn handle(state: &mut State, params: <Self::Notification as LspNotific...
  function handle_non_lifecycle_request (line 49) | pub fn handle_non_lifecycle_request(_state: &mut State, request: Request...

FILE: lsp-server/handler/text_synchronisation.rs
  type DidOpenTextDocumentHandler (line 8) | pub struct DidOpenTextDocumentHandler;
  type Notification (line 11) | type Notification = lsp_types::notification::DidOpenTextDocument;
  method handle (line 13) | fn handle(state: &mut State, params: lsp_types::DidOpenTextDocumentParam...
  type DidChangeTextDocumentHandler (line 26) | pub struct DidChangeTextDocumentHandler;
  type Notification (line 29) | type Notification = lsp_types::notification::DidChangeTextDocument;
  method handle (line 31) | fn handle(state: &mut State, params: lsp_types::DidChangeTextDocumentPar...
  type DidCloseTextDocumentHandler (line 85) | pub struct DidCloseTextDocumentHandler;
  type Notification (line 88) | type Notification = lsp_types::notification::DidCloseTextDocument;
  method handle (line 90) | fn handle(state: &mut State, params: lsp_types::DidCloseTextDocumentPara...

FILE: lsp-server/handler/workspace.rs
  type DidChangeWorkspaceFoldersHandler (line 7) | pub struct DidChangeWorkspaceFoldersHandler;
  type Notification (line 10) | type Notification = lsp_types::notification::DidChangeWorkspaceFolders;
  method handle (line 12) | fn handle(state: &mut State, params: lsp_types::DidChangeWorkspaceFolder...

FILE: lsp-server/json_rpc.rs
  type ErrorCode (line 6) | pub enum ErrorCode {
  type ClientMessage (line 14) | pub enum ClientMessage {
    method from (line 20) | fn from(request: Request) -> ClientMessage {
    method from (line 26) | fn from(notification: Notification) -> ClientMessage {
  type ServerMessage (line 33) | pub enum ServerMessage {
    method from (line 39) | fn from(response: Response) -> ServerMessage {
    method from (line 45) | fn from(notification: Notification) -> ServerMessage {
  type Notification (line 51) | pub struct Notification {
    method new (line 57) | pub fn new(method: impl Into<String>, params: impl Serialize) -> Self {
    method new_lsp (line 64) | pub fn new_lsp<N>(params: N::Params) -> Self
  type IdRepr (line 75) | enum IdRepr {
  type RequestId (line 82) | pub struct RequestId(IdRepr);
    method from (line 85) | fn from(id: u64) -> RequestId {
    method from (line 91) | fn from(id: String) -> RequestId {
  type Request (line 97) | pub struct Request {
    method new (line 105) | pub fn new(id: RequestId, method: impl Into<String>, params: impl Seri...
    method new_lsp (line 114) | pub fn new_lsp<N>(id: RequestId, params: N::Params) -> Self
  type Response (line 124) | pub struct Response {
    method new_ok (line 141) | pub fn new_ok(id: RequestId, result: impl Serialize) -> Response {
    method new_err (line 149) | pub fn new_err(id: RequestId, code: ErrorCode, message: impl Into<Stri...
  type ResponseError (line 133) | pub struct ResponseError {

FILE: lsp-server/main.rs
  function main (line 12) | async fn main() -> Result<(), ()> {

FILE: lsp-server/model/document.rs
  type Document (line 4) | pub struct Document {
    method new (line 17) | pub fn new(version: i32, text: String) -> Document {
    method with_range_edit (line 26) | pub fn with_range_edit(
    method version (line 74) | pub fn version(&self) -> i32 {
    method text (line 79) | pub fn text(&self) -> &str {
    method span_to_range (line 84) | pub fn span_to_range(&self, span: Span) -> lsp_types::Range {
    method offset_to_position (line 92) | pub fn offset_to_position(&self, offset: usize) -> lsp_types::Position {
    method position_to_offset (line 114) | fn position_to_offset(&self, position: lsp_types::Position) -> Option<...
  function line_offsets_for_str (line 10) | fn line_offsets_for_str(source: &str) -> Vec<usize> {
  function assert_consistency (line 141) | fn assert_consistency(doc: &Document) {
  function test_positions (line 146) | fn test_positions() {
  function test_append_to_empty (line 191) | fn test_append_to_empty() {
  function test_append_to_line (line 214) | fn test_append_to_line() {
  function test_erase_all (line 237) | fn test_erase_all() {
  function test_replace_line (line 260) | fn test_replace_line() {
  function test_insert_line (line 283) | fn test_insert_line() {
  function test_delete_line (line 306) | fn test_delete_line() {
  function test_delete_utf16 (line 329) | fn test_delete_utf16() {

FILE: lsp-server/model/workspace.rs
  type Workspace (line 2) | pub struct Workspace {
    method new (line 7) | pub fn new(name: String) -> Workspace {

FILE: lsp-server/session.rs
  type State (line 13) | pub struct State {
    method new (line 20) | fn new(
    method shutdown (line 46) | async fn shutdown(self) {
  function create_initialize_response (line 51) | pub fn create_initialize_response() -> lsp_types::InitializeResult {
  function run (line 65) | pub async fn run(connection: Connection) -> Result<(), ()> {
  type TestSession (line 187) | struct TestSession<F>
  function run_test_session (line 196) | fn run_test_session() -> TestSession<impl Future<Output = Result<(), ()>...
  function expect_response (line 212) | fn expect_response(server_message: ServerMessage) -> Response {
  function test_clean_lifecycle (line 222) | async fn test_clean_lifecycle() {

FILE: lsp-server/transport/bytestream.rs
  function parse_header_line (line 8) | fn parse_header_line(header_line: &str) -> (String, String) {
  function create_connection (line 41) | pub fn create_connection(
  function test_happy_recv_notification (line 131) | async fn test_happy_recv_notification() {

FILE: lsp-server/transport/mod.rs
  type Connection (line 7) | pub struct Connection {

FILE: lsp-server/watcher/mod.rs
  type DocumentWatcher (line 9) | pub trait DocumentWatcher {
    method did_open (line 11) | fn did_open(&mut self, _url: &lsp_types::Url, _document: &Arc<Document...
    method did_change (line 14) | fn did_change(&mut self, _url: &lsp_types::Url, _document: &Arc<Docume...
    method did_close (line 17) | fn did_close(&mut self, _url: &lsp_types::Url) {}

FILE: lsp-server/watcher/syntax.rs
  function syntax_diagnostics_for_document (line 13) | fn syntax_diagnostics_for_document(
  type DocumentTask (line 58) | struct DocumentTask {
    method new (line 64) | pub fn new(
    method did_change (line 105) | fn did_change(&self, document: Arc<Document>) {
    method shutdown (line 111) | async fn shutdown(self) {
  type SyntaxWatcher (line 119) | pub struct SyntaxWatcher {
    method new (line 125) | pub fn new(outgoing: mpsc::Sender<ServerMessage>) -> SyntaxWatcher {
    method shutdown (line 132) | pub async fn shutdown(self) {
  method did_open (line 146) | fn did_open(&mut self, url: &lsp_types::Url, document: &Arc<Document>) {
  method did_change (line 153) | fn did_change(&mut self, url: &lsp_types::Url, document: &Arc<Document>) {
  method did_close (line 159) | fn did_close(&mut self, url: &lsp_types::Url) {
  function correct_document_diagnostics (line 169) | fn correct_document_diagnostics() {
  function missing_delimiter_diagnostics (line 179) | fn missing_delimiter_diagnostics() {
  function unsupported_character_diagnostics (line 241) | fn unsupported_character_diagnostics() {

FILE: rfi-derive/lib.rs
  function arg_is_task (line 9) | fn arg_is_task(arg: &syn::PatType) -> bool {
  function rust_fun (line 32) | pub fn rust_fun(

FILE: runtime-syntax/reader.rs
  function box_syntax_datum (line 8) | pub fn box_syntax_datum(heap: &mut impl boxed::AsHeap, datum: &Datum) ->...

FILE: runtime-syntax/writer.rs
  function write_escaped_str (line 30) | fn write_escaped_str(w: &mut dyn Write, source: &str) -> Result<()> {
  function write_boxed_seq (line 43) | fn write_boxed_seq(
  function write_boxed_map (line 62) | fn write_boxed_map(
  function write_char (line 86) | fn write_char(w: &mut dyn Write, c: char) -> Result<()> {
  function write_float (line 98) | fn write_float(w: &mut dyn Write, f: f64) -> Result<()> {
  function write_interned_sym (line 117) | fn write_interned_sym(
  function write_record (line 134) | fn write_record(w: &mut dyn Write, heap: &impl AsHeap, record: &boxed::R...
  function write_boxed (line 163) | pub fn write_boxed(w: &mut dyn Write, heap: &impl AsHeap, any_ref: Gc<bo...
  function pretty_print_boxed (line 201) | pub fn pretty_print_boxed(write: &mut dyn Write, heap: &impl AsHeap, any...
  function string_for_boxed (line 227) | fn string_for_boxed(heap: &boxed::Heap, any_ref: Gc<boxed::Any>) -> Stri...
  function assert_write (line 235) | fn assert_write(heap: &mut boxed::Heap, expected: &'static str, any_ref:...
  function bools (line 251) | fn bools() {
  function ints (line 258) | fn ints() {
  function floats (line 272) | fn floats() {
  function sym (line 294) | fn sym() {
  function lists (line 305) | fn lists() {
  function vectors (line 320) | fn vectors() {
  function chars (line 337) | fn chars() {
  function strings (line 358) | fn strings() {

FILE: runtime/abitype.rs
  type BoxedAbiType (line 12) | pub enum BoxedAbiType {
    method from (line 163) | fn from(type_tag: boxed::TypeTag) -> BoxedAbiType {
    method into_abi_type (line 169) | pub fn into_abi_type(self) -> AbiType {
  constant TOP_LIST_BOXED_ABI_TYPE (line 23) | pub const TOP_LIST_BOXED_ABI_TYPE: BoxedAbiType = BoxedAbiType::List(&Bo...
  type AbiType (line 27) | pub enum AbiType {
    method from (line 175) | fn from(type_tag: boxed::TypeTag) -> AbiType {
    method from (line 181) | fn from(boxed_abi_type: BoxedAbiType) -> AbiType {
    method into_ret_abi_type (line 187) | pub fn into_ret_abi_type(self) -> RetAbiType {
    method into_param_abi_type (line 191) | pub fn into_param_abi_type(self) -> ParamAbiType {
    method may_contain_gc_refs (line 203) | pub fn may_contain_gc_refs(&self) -> bool {
  type ParamCapture (line 62) | pub enum ParamCapture {
  type ParamAbiType (line 72) | pub struct ParamAbiType {
    method from (line 212) | fn from(type_tag: boxed::TypeTag) -> ParamAbiType {
    method from (line 221) | fn from(boxed_abi_type: BoxedAbiType) -> ParamAbiType {
    method from (line 227) | fn from(abi_type: AbiType) -> ParamAbiType {
  type RetAbiType (line 78) | pub enum RetAbiType {
    method from (line 233) | fn from(type_tag: boxed::TypeTag) -> RetAbiType {
    method from (line 241) | fn from(boxed_abi_type: BoxedAbiType) -> RetAbiType {
    method from (line 247) | fn from(abi_type: AbiType) -> RetAbiType {
  type EncodeAbiType (line 84) | pub trait EncodeAbiType {
    constant ABI_TYPE (line 85) | const ABI_TYPE: AbiType;
    constant PARAM_CAPTURE (line 87) | const PARAM_CAPTURE: ParamCapture = ParamCapture::Never;
    constant PARAM_ABI_TYPE (line 89) | const PARAM_ABI_TYPE: ParamAbiType = ParamAbiType {
    constant ABI_TYPE (line 96) | const ABI_TYPE: AbiType = AbiType::Float;
    constant ABI_TYPE (line 100) | const ABI_TYPE: AbiType = AbiType::Int;
    constant ABI_TYPE (line 104) | const ABI_TYPE: AbiType = AbiType::Char;
    constant ABI_TYPE (line 108) | const ABI_TYPE: AbiType = AbiType::Bool;
    constant ABI_TYPE (line 115) | const ABI_TYPE: AbiType = AbiType::Boxed(T::BOXED_ABI_TYPE);
    constant PARAM_CAPTURE (line 116) | const PARAM_CAPTURE: ParamCapture = ParamCapture::Auto;
    constant ABI_TYPE (line 123) | const ABI_TYPE: AbiType = AbiType::Boxed(T::BOXED_ABI_TYPE);
    constant PARAM_CAPTURE (line 124) | const PARAM_CAPTURE: ParamCapture = ParamCapture::Never;
    constant ABI_TYPE (line 131) | const ABI_TYPE: AbiType = AbiType::Boxed(T::BOXED_ABI_TYPE);
    constant PARAM_CAPTURE (line 132) | const PARAM_CAPTURE: ParamCapture = ParamCapture::Always;
    constant ABI_TYPE (line 139) | const ABI_TYPE: AbiType = AbiType::Callback(&F::ENTRY_POINT_ABI_TYPE);
  type EncodeBoxedAbiType (line 142) | pub trait EncodeBoxedAbiType {
    constant BOXED_ABI_TYPE (line 143) | const BOXED_ABI_TYPE: BoxedAbiType;
  type EncodeRetAbiType (line 146) | pub trait EncodeRetAbiType {
    constant RET_ABI_TYPE (line 147) | const RET_ABI_TYPE: RetAbiType;
    constant RET_ABI_TYPE (line 151) | const RET_ABI_TYPE: RetAbiType = RetAbiType::Inhabited(Self::ABI_TYPE);
    constant RET_ABI_TYPE (line 155) | const RET_ABI_TYPE: RetAbiType = RetAbiType::Void;
    constant RET_ABI_TYPE (line 159) | const RET_ABI_TYPE: RetAbiType = RetAbiType::Never;

FILE: runtime/binding.rs
  type RustFun (line 9) | pub struct RustFun {
  type RustExports (line 17) | pub type RustExports = &'static [(&'static str, &'static RustFun)];
  type Never (line 20) | pub enum Never {}

FILE: runtime/boxed/heap/collect.rs
  type ForwardingCell (line 15) | struct ForwardingCell {
  type StrongPass (line 26) | pub struct StrongPass {
    method new (line 33) | pub fn new(old_heap: Heap) -> StrongPass {
    method into_weak_pass (line 43) | pub fn into_weak_pass(self) -> WeakPass {
    method into_new_heap (line 51) | pub fn into_new_heap(self) -> Heap {
    method visit_box (line 58) | pub fn visit_box<T: Boxed>(&mut self, box_ref: &mut Gc<T>) {
    method move_box_to_new_heap (line 63) | fn move_box_to_new_heap(new_heap: &mut Heap, box_ref: &mut Gc<boxed::A...
    method visit_interned_sym (line 99) | fn visit_interned_sym(old_heap: &Heap, new_heap: &mut Heap, interned_s...
    method visit_any_box (line 107) | fn visit_any_box(old_heap: &Heap, new_heap: &mut Heap, mut box_ref: &m...
  type WeakPass (line 194) | pub struct WeakPass {
    method into_new_heap (line 202) | pub fn into_new_heap(self) -> Heap {
    method new_heap_ref_for (line 212) | pub fn new_heap_ref_for<T: Boxed>(&self, boxed: Gc<T>) -> Option<Gc<T>> {
    method new_heap_any_ref_for (line 218) | fn new_heap_any_ref_for(&self, box_ref: Gc<boxed::Any>) -> Option<Gc<b...
  function simple_collect (line 240) | fn simple_collect() {
  function sym_collect (line 283) | fn sym_collect() {
  function list_collect (line 307) | fn list_collect() {
  function vector_collect (line 341) | fn vector_collect() {

FILE: runtime/boxed/heap/mod.rs
  type Segment (line 16) | pub struct Segment {
    method with_capacity (line 33) | fn with_capacity(count: usize) -> Segment {
    method alloc_cells (line 54) | fn alloc_cells(&mut self, count: usize) -> Option<*mut Any> {
    method len (line 69) | fn len(&self) -> usize {
  type Heap (line 24) | pub struct Heap {
    constant DEFAULT_SEGMENT_CAPACITY (line 106) | const DEFAULT_SEGMENT_CAPACITY: usize = 1024;
    constant DEFAULT_CAPACITY (line 109) | const DEFAULT_CAPACITY: usize = Self::DEFAULT_SEGMENT_CAPACITY;
    method empty (line 112) | pub fn empty() -> Heap {
    method new (line 117) | pub fn new(type_info: TypeInfo, count: usize) -> Heap {
    method should_collect (line 129) | pub fn should_collect(&self) -> bool {
    method save_len_at_gc (line 134) | fn save_len_at_gc(&mut self) {
    method alloc_cells (line 139) | pub fn alloc_cells(&mut self, count: usize) -> *mut Any {
    method type_info (line 159) | pub fn type_info(&self) -> &TypeInfo {
    method type_info_mut (line 164) | pub fn type_info_mut(&mut self) -> &mut TypeInfo {
    method len (line 169) | pub fn len(&self) -> usize {
    method is_empty (line 175) | pub fn is_empty(&self) -> bool {
    method place_box (line 180) | pub fn place_box<T: Boxed>(&mut self, boxed: T) -> Gc<T> {
  method drop (line 76) | fn drop(&mut self) {
  method default (line 202) | fn default() -> Self {
  type AsHeap (line 208) | pub trait AsHeap {
    method as_heap (line 210) | fn as_heap(&self) -> &Heap;
    method as_heap_mut (line 213) | fn as_heap_mut(&mut self) -> &mut Heap;
    method as_heap (line 217) | fn as_heap(&self) -> &Heap {
    method as_heap_mut (line 221) | fn as_heap_mut(&mut self) -> &mut Heap {
  method as_interner (line 227) | fn as_interner(&self) -> &Interner {
  function basic_alloc (line 237) | fn basic_alloc() {

FILE: runtime/boxed/heap/type_info.rs
  type TypeInfo (line 9) | pub struct TypeInfo {
    method new (line 16) | pub fn new(interner: Interner, class_map: ClassMap) -> TypeInfo {
    method empty (line 24) | pub fn empty() -> TypeInfo {
    method clone_for_collect_garbage (line 29) | pub fn clone_for_collect_garbage(&self) -> Self {
    method interner (line 37) | pub fn interner(&self) -> &Interner {
    method interner_mut (line 42) | pub fn interner_mut(&mut self) -> &mut Interner {
    method class_map (line 47) | pub fn class_map(&self) -> &ClassMap {
    method class_map_mut (line 52) | pub fn class_map_mut(&mut self) -> &mut ClassMap {
  method as_interner (line 58) | fn as_interner(&self) -> &Interner {

FILE: runtime/boxed/mod.rs
  type BoxSize (line 51) | pub enum BoxSize {
    method cell_count (line 60) | pub fn cell_count(self) -> usize {
    method to_heap_alloc_type (line 68) | pub fn to_heap_alloc_type(self) -> AllocType {
  type AllocType (line 79) | pub enum AllocType {
    method to_heap_box_size (line 102) | pub fn to_heap_box_size(self) -> Option<BoxSize> {
  type Header (line 114) | pub struct Header {
    method new (line 121) | pub fn new(type_tag: TypeTag, alloc_type: AllocType) -> Header {
    method type_tag (line 129) | pub fn type_tag(self) -> TypeTag {
    method alloc_type (line 134) | pub fn alloc_type(self) -> AllocType {
  type PartialEqInHeap (line 143) | pub trait PartialEqInHeap {
    method eq_in_heap (line 147) | fn eq_in_heap(&self, heap: &Heap, other: &Self) -> bool;
    method eq_in_heap (line 154) | fn eq_in_heap(&self, _heap: &Heap, other: &Self) -> bool {
  type HashInHeap (line 162) | pub trait HashInHeap {
    method hash_in_heap (line 164) | fn hash_in_heap<H: Hasher>(&self, heap: &Heap, state: &mut H);
    method hash_in_heap (line 171) | fn hash_in_heap<H: Hasher>(&self, _heap: &Heap, state: &mut H) {
  type Boxed (line 180) | pub trait Boxed: Sized + PartialEqInHeap + HashInHeap + fmt::Debug {
    method as_any_ref (line 182) | fn as_any_ref(&self) -> Gc<Any> {
    method header (line 187) | fn header(&self) -> Header {
  constant BOXED_ABI_TYPE (line 193) | const BOXED_ABI_TYPE: BoxedAbiType = BoxedAbiType::Any;
  type ConstTagged (line 202) | pub trait ConstTagged: Boxed {
    constant TYPE_TAG (line 204) | const TYPE_TAG: TypeTag;
  type DistinctTagged (line 214) | pub trait DistinctTagged: Boxed {
    method has_tag (line 216) | fn has_tag(type_tag: TypeTag) -> bool;
  type UniqueTagged (line 225) | pub trait UniqueTagged: ConstTagged + DistinctTagged {}
  constant BOXED_ABI_TYPE (line 228) | const BOXED_ABI_TYPE: BoxedAbiType = BoxedAbiType::UniqueTagged(T::TYPE_...
  method to_boxed_abi_type (line 284) | pub fn to_boxed_abi_type(self) -> BoxedAbiType {
  method to_const_header (line 289) | pub fn to_const_header(self) -> Header {
  method to_heap_header (line 294) | pub fn to_heap_header(self, box_size: BoxSize) -> Header {
  method singleton_ref (line 547) | pub fn singleton_ref(value: bool) -> Gc<Bool> {
  method as_bool (line 556) | pub fn as_bool(&self) -> bool {
  function sizes (line 570) | fn sizes() {
  function downcast_ref (line 578) | fn downcast_ref() {
  function as_tagged (line 589) | fn as_tagged() {
  function any_equality (line 602) | fn any_equality() {
  function any_fmt_debug (line 621) | fn any_fmt_debug() {
  function union_types (line 630) | fn union_types() {

FILE: runtime/boxed/refs.rs
  type Gc (line 15) | pub struct Gc<T: Boxed> {
  method clone (line 21) | fn clone(&self) -> Self {
  type Target (line 29) | type Target = T;
  method deref (line 30) | fn deref(&self) -> &T {
  function new (line 40) | pub unsafe fn new(ptr: *const T) -> Gc<T> {
  function cast (line 50) | pub unsafe fn cast<U: Boxed>(self) -> Gc<U> {
  function as_ptr (line 57) | pub fn as_ptr(self) -> *const T {
  function as_mut_ptr (line 62) | pub(super) fn as_mut_ptr(self) -> *mut T {
  method eq (line 71) | fn eq(&self, other: &Gc<T>) -> bool {
  function hash (line 82) | fn hash<H: hash::Hasher>(&self, state: &mut H) {
  function fmt (line 91) | fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Err...

FILE: runtime/boxed/types/char.rs
  type Char (line 11) | pub struct Char {
    method new (line 21) | pub fn new(heap: &mut impl AsHeap, value: char) -> Gc<Char> {
    method size (line 29) | pub fn size() -> BoxSize {
    method value (line 34) | pub fn value(&self) -> char {
    method fmt (line 53) | fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::E...
  method eq (line 40) | fn eq(&self, other: &Char) -> bool {
  method hash (line 46) | fn hash<H: Hasher>(&self, state: &mut H) {
  function sizes (line 65) | fn sizes() {
  function equality (line 70) | fn equality() {
  function fmt_debug (line 82) | fn fmt_debug() {

FILE: runtime/boxed/types/field_value.rs
  type FieldValue (line 11) | pub enum FieldValue {
  type FieldGcRef (line 26) | pub(crate) enum FieldGcRef {
  method eq_in_heap (line 32) | fn eq_in_heap(&self, heap: &boxed::Heap, other: &FieldValue) -> bool {
  method hash_in_heap (line 46) | fn hash_in_heap<H: Hasher>(&self, heap: &boxed::Heap, state: &mut H) {
  type FieldValueIter (line 66) | pub struct FieldValueIter<'cm> {
  type Item (line 72) | type Item = FieldValue;
  method next (line 74) | fn next(&mut self) -> Option<FieldValue> {
  type FieldGcRefIter (line 98) | pub(crate) struct FieldGcRefIter<'cm> {
  function empty (line 104) | pub(crate) fn empty() -> FieldGcRefIter<'static> {
  type Item (line 113) | type Item = FieldGcRef;
  method next (line 115) | fn next(&mut self) -> Option<FieldGcRef> {

FILE: runtime/boxed/types/float.rs
  type Float (line 9) | pub struct Float {
    method new (line 19) | pub fn new(heap: &mut impl AsHeap, value: f64) -> Gc<Float> {
    method size (line 27) | pub fn size() -> BoxSize {
    method value (line 32) | pub fn value(&self) -> f64 {
    method fmt (line 59) | fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::E...
  method eq (line 38) | fn eq(&self, other: &Float) -> bool {
  method hash (line 44) | fn hash<H: Hasher>(&self, state: &mut H) {
  function calc_hash (line 70) | fn calc_hash(value: f64) -> u64 {
  function sizes (line 82) | fn sizes() {
  function equality (line 87) | fn equality() {
  function hash (line 99) | fn hash() {
  function fmt_debug (line 109) | fn fmt_debug() {

FILE: runtime/boxed/types/fun.rs
  type Captures (line 14) | pub type Captures = Gc<Any>;
  type ThunkEntry (line 17) | pub type ThunkEntry = extern "C" fn(&mut task::Task, Captures, Gc<Any>) ...
  type FunThunk (line 26) | pub struct FunThunk {
    method new (line 37) | pub fn new(heap: &mut impl AsHeap, captures: Captures, entry: ThunkEnt...
    method size (line 46) | pub fn size() -> BoxSize {
    method apply (line 51) | pub fn apply(&self, task: &mut task::Task, arg_list: Gc<Any>) -> Gc<An...
    method fmt (line 73) | fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::E...
  method eq (line 57) | fn eq(&self, _: &FunThunk) -> bool {
  method hash (line 66) | fn hash<H: Hasher>(&self, state: &mut H) {
  function identity_entry (line 85) | extern "C" fn identity_entry(
  function return_42_entry (line 93) | extern "C" fn return_42_entry(
  function sizes (line 102) | fn sizes() {
  function equality (line 107) | fn equality() {

FILE: runtime/boxed/types/int.rs
  type Int (line 9) | pub struct Int {
    method new (line 19) | pub fn new(heap: &mut impl AsHeap, value: i64) -> Gc<Int> {
    method size (line 27) | pub fn size() -> BoxSize {
    method value (line 32) | pub fn value(&self) -> i64 {
    method fmt (line 51) | fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::E...
  method eq (line 38) | fn eq(&self, other: &Int) -> bool {
  method hash (line 44) | fn hash<H: Hasher>(&self, state: &mut H) {
  function sizes (line 63) | fn sizes() {
  function equality (line 68) | fn equality() {
  function fmt_debug (line 80) | fn fmt_debug() {

FILE: runtime/boxed/types/list.rs
  type Pair (line 12) | pub struct Pair<T: Boxed = Any> {
  constant BOXED_ABI_TYPE (line 24) | const BOXED_ABI_TYPE: BoxedAbiType = BoxedAbiType::Pair(&T::BOXED_ABI_TY...
  function new (line 29) | pub fn new(heap: &mut impl AsHeap, head: Gc<T>, rest: Gc<List<T>>) -> Gc...
  function size (line 39) | pub fn size() -> BoxSize {
  function len (line 46) | pub fn len(&self) -> usize {
  function is_empty (line 51) | pub fn is_empty(&self) -> bool {
  function head (line 57) | pub fn head(&self) -> Gc<T> {
  function rest (line 62) | pub fn rest(&self) -> Gc<List<T>> {
  function as_list_ref (line 67) | pub fn as_list_ref(&self) -> Gc<List<T>> {
  method eq_in_heap (line 73) | fn eq_in_heap(&self, heap: &Heap, rhs: &Pair<T>) -> bool {
  method hash_in_heap (line 79) | fn hash_in_heap<H: Hasher>(&self, task: &Heap, state: &mut H) {
  function fmt (line 87) | fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Err...
  type List (line 97) | pub struct List<T: Boxed = Any> {
  method has_tag (line 106) | fn has_tag(type_tag: TypeTag) -> bool {
  constant BOXED_ABI_TYPE (line 115) | const BOXED_ABI_TYPE: BoxedAbiType = BoxedAbiType::List(&T::BOXED_ABI_TY...
  type ListSubtype (line 119) | pub enum ListSubtype<'a, T: Boxed> {
  function new (line 128) | pub fn new(heap: &mut impl AsHeap, elems: impl ExactSizeIterator<Item = ...
  function new_with_tail (line 133) | pub fn new_with_tail(
  function empty (line 175) | pub fn empty() -> Gc<List<T>> {
  function from_values (line 180) | pub fn from_values<V, F>(
  function as_subtype (line 195) | pub fn as_subtype(&self) -> ListSubtype<'_, T> {
  function len (line 208) | pub fn len(&self) -> usize {
  function is_empty (line 213) | pub fn is_empty(&self) -> bool {
  function iter (line 218) | pub fn iter(&self) -> ListIterator<T> {
  method eq_in_heap (line 226) | fn eq_in_heap(&self, heap: &Heap, other: &List<T>) -> bool {
  method hash_in_heap (line 238) | fn hash_in_heap<H: Hasher>(&self, heap: &Heap, state: &mut H) {
  function fmt (line 247) | fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Err...
  type ListIterator (line 254) | pub struct ListIterator<T: Boxed> {
  type Item (line 259) | type Item = Gc<T>;
  method next (line 261) | fn next(&mut self) -> Option<Gc<T>> {
  method size_hint (line 274) | fn size_hint(&self) -> (usize, Option<usize>) {
  type Nil (line 285) | pub struct Nil {
  method eq (line 304) | fn eq(&self, _: &Nil) -> bool {
  method hash (line 310) | fn hash<H: Hasher>(&self, state: &mut H) {
  function sizes (line 324) | fn sizes() {
  function equality (line 331) | fn equality() {
  function fmt_debug (line 345) | fn fmt_debug() {
  function construct_and_iter (line 356) | fn construct_and_iter() {

FILE: runtime/boxed/types/map.rs
  type Map (line 11) | pub struct Map<K: Boxed = Any, V: Boxed = Any> {
  function new (line 21) | pub fn new(
  function from_values (line 37) | pub fn from_values<T, F>(
  function size (line 57) | pub fn size() -> BoxSize {
  function is_empty (line 62) | pub fn is_empty(&self) -> bool {
  function len (line 67) | pub fn len(&self) -> usize {
  function iter (line 72) | pub fn iter(&self) -> impl Iterator<Item = (Gc<K>, Gc<V>)> + '_ {
  method eq_in_heap (line 78) | fn eq_in_heap(&self, _heap: &Heap, _other: &Map<K, V>) -> bool {
  method hash_in_heap (line 85) | fn hash_in_heap<H: Hasher>(&self, _heap: &Heap, state: &mut H) {
  function fmt (line 91) | fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Err...
  constant BOXED_ABI_TYPE (line 103) | const BOXED_ABI_TYPE: BoxedAbiType = BoxedAbiType::Map(&K::BOXED_ABI_TYP...
  function sizes (line 112) | fn sizes() {

FILE: runtime/boxed/types/record.rs
  type RecordClassId (line 13) | pub type RecordClassId = u32;
  type RecordHeader (line 16) | struct RecordHeader {
  type RecordStorage (line 25) | pub enum RecordStorage {
    method box_size (line 34) | pub fn box_size(self) -> BoxSize {
  type Record (line 44) | pub struct Record {
    constant MAX_INLINE_BYTES (line 53) | pub const MAX_INLINE_BYTES: usize = 24;
    constant EXTERNAL_INLINE_LEN (line 56) | pub const EXTERNAL_INLINE_LEN: u8 = (Self::MAX_INLINE_BYTES as u8) + 1;
    constant INLINE_DATA_ALIGNMENT (line 59) | const INLINE_DATA_ALIGNMENT: usize = 8;
    method new (line 62) | pub fn new(heap: &mut impl AsHeap, class_id: RecordClassId, data: Reco...
    method storage_for_data_layout (line 81) | pub fn storage_for_data_layout(data_layout: Option<alloc::Layout>) -> ...
    method class_id (line 100) | pub fn class_id(&self) -> RecordClassId {
    method field_values (line 105) | pub fn field_values<'cm>(&self, heap: &'cm Heap) -> FieldValueIter<'cm> {
    method field_gc_refs (line 117) | pub(crate) fn field_gc_refs<'cm>(&mut self, heap: &'cm Heap) -> FieldG...
    method data_ptr (line 133) | fn data_ptr(&self) -> *const u8 {
    method is_empty (line 140) | fn is_empty(&self) -> bool {
    method is_inline (line 144) | fn is_inline(&self) -> bool {
    method as_repr (line 148) | fn as_repr(&self) -> Repr<'_> {
    method as_repr_mut (line 156) | fn as_repr_mut(&mut self) -> ReprMut<'_> {
    method fmt (line 195) | fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::E...
  method eq_in_heap (line 166) | fn eq_in_heap(&self, heap: &Heap, other: &Record) -> bool {
  method hash_in_heap (line 182) | fn hash_in_heap<H: Hasher>(&self, heap: &Heap, state: &mut H) {
  type InlineRecord (line 201) | struct InlineRecord {
    method new (line 207) | fn new(box_size: BoxSize, class_id: RecordClassId, data: RecordData) -...
  type ExternalRecord (line 239) | struct ExternalRecord {
    method new (line 245) | fn new(box_size: BoxSize, class_id: RecordClassId, data: RecordData) -...
  type Repr (line 262) | enum Repr<'a> {
  type ReprMut (line 267) | enum ReprMut<'a> {
  method drop (line 273) | fn drop(&mut self) {
  function sizes (line 290) | fn sizes() {
  function equality (line 297) | fn equality() {
  function fmt_debug (line 309) | fn fmt_debug() {

FILE: runtime/boxed/types/record_data.rs
  type RecordData (line 5) | pub struct RecordData {
    method empty (line 12) | pub fn empty() -> Self {
    method alloc (line 17) | pub fn alloc(data_layout: Option<alloc::Layout>) -> Self {
    method as_ptr (line 30) | pub fn as_ptr(&self) -> *const u8 {
    method as_mut_ptr (line 35) | pub fn as_mut_ptr(&mut self) -> *mut u8 {
    method layout (line 40) | pub fn layout(&self) -> Option<alloc::Layout> {
    method alloc_layout_to_compact (line 47) | pub fn alloc_layout_to_compact(alloc_layout: Option<alloc::Layout>) ->...
    method compact_to_alloc_layout (line 57) | fn compact_to_alloc_layout(input: u64) -> Option<alloc::Layout> {
  method drop (line 70) | fn drop(&mut self) {
  function test_alloc_layout_to_u64 (line 84) | fn test_alloc_layout_to_u64() {

FILE: runtime/boxed/types/set.rs
  constant MAX_16BYTE_INLINE_LEN (line 10) | const MAX_16BYTE_INLINE_LEN: usize = (16 - 8) / mem::size_of::<Gc<Any>>();
  constant MAX_32BYTE_INLINE_LEN (line 11) | const MAX_32BYTE_INLINE_LEN: usize = (32 - 8) / mem::size_of::<Gc<Any>>();
  type SetStorage (line 15) | pub enum SetStorage {
    method box_size (line 24) | pub fn box_size(self) -> BoxSize {
  type Set (line 36) | pub struct Set<T: Boxed = Any> {
  constant MAX_INLINE_LEN (line 47) | pub const MAX_INLINE_LEN: usize = MAX_32BYTE_INLINE_LEN;
  constant EXTERNAL_INLINE_LEN (line 50) | pub const EXTERNAL_INLINE_LEN: u32 = (Self::MAX_INLINE_LEN as u32) + 1;
  function new (line 53) | pub fn new(heap: &mut impl AsHeap, values: impl ExactSizeIterator<Item =...
  function storage_for_element_len (line 84) | fn storage_for_element_len(len: usize) -> SetStorage {
  function from_values (line 98) | pub fn from_values<V, F>(
  function is_inline (line 112) | fn is_inline(&self) -> bool {
  function as_repr (line 116) | fn as_repr(&self) -> Repr<'_, T> {
  function as_repr_mut (line 124) | fn as_repr_mut(&mut self) -> ReprMut<'_, T> {
  function len (line 133) | pub fn len(&self) -> usize {
  function is_empty (line 141) | pub fn is_empty(&self) -> bool {
  function contains (line 146) | pub fn contains(&self, heap: &Heap, value: &Gc<T>) -> bool {
  function iter (line 154) | pub fn iter<'a>(&'a self) -> Box<dyn ExactSizeIterator<Item = Gc<T>> + '...
  function is_subset (line 163) | pub fn is_subset(&self, heap: &Heap, other: &Set<T>) -> bool {
  method eq_in_heap (line 187) | fn eq_in_heap(&self, heap: &Heap, other: &Set<T>) -> bool {
  method hash_in_heap (line 201) | fn hash_in_heap<H: Hasher>(&self, heap: &Heap, state: &mut H) {
  function fmt (line 210) | fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Err...
  constant BOXED_ABI_TYPE (line 221) | const BOXED_ABI_TYPE: BoxedAbiType = BoxedAbiType::Set(&T::BOXED_ABI_TYPE);
  type InlineSet (line 225) | pub struct InlineSet<T: Boxed> {
  function new (line 232) | fn new(header: Header, hashed_values: Vec<(u64, Gc<T>)>) -> InlineSet<T> {
  function len (line 248) | fn len(&self) -> usize {
  function iter (line 252) | fn iter(&self) -> impl ExactSizeIterator<Item = Gc<T>> + '_ {
  function contains (line 258) | fn contains(&self, heap: &Heap, value: &Gc<T>) -> bool {
  function eq_in_heap (line 262) | fn eq_in_heap(&self, heap: &Heap, other: &InlineSet<T>) -> bool {
  function hash_in_heap (line 272) | fn hash_in_heap<H: Hasher>(&self, heap: &Heap, state: &mut H) {
  type ExternalSet (line 282) | pub struct ExternalSet<T: Boxed> {
  function new (line 289) | fn new(header: Header, sorted_hashed_values: Vec<(u64, Gc<T>)>) -> Exter...
  function len (line 297) | fn len(&self) -> usize {
  function iter (line 301) | fn iter(&self) -> impl ExactSizeIterator<Item = &Gc<T>> {
  function contains (line 305) | fn contains(&self, heap: &Heap, needle_value: &Gc<T>) -> bool {
  function is_subset (line 358) | fn is_subset(&self, heap: &Heap, other: &ExternalSet<T>) -> bool {
  function eq_in_heap (line 393) | fn eq_in_heap(&self, heap: &Heap, other: &ExternalSet<T>) -> bool {
  function hash_in_heap (line 406) | fn hash_in_heap<H: Hasher>(&self, _: &Heap, state: &mut H) {
  type Repr (line 417) | enum Repr<'a, T: Boxed> {
  type ReprMut (line 422) | enum ReprMut<'a, T: Boxed> {
  method drop (line 428) | fn drop(&mut self) {
  function sizes (line 449) | fn sizes() {
  function inline_equality (line 456) | fn inline_equality() {
  function inline_contains (line 482) | fn inline_contains() {
  function external_equality (line 511) | fn external_equality() {
  function external_contains (line 544) | fn external_contains() {
  function subset (line 584) | fn subset() {

FILE: runtime/boxed/types/shared_str.rs
  constant GLOBAL_CONSTANT_REFCOUNT (line 5) | const GLOBAL_CONSTANT_REFCOUNT: u64 = std::u64::MAX;
  type DataHeader (line 11) | struct DataHeader {
  type SharedStrData (line 18) | struct SharedStrData {
    method new (line 25) | fn new(value: &str) -> *mut SharedStrData {
    method as_str (line 45) | fn as_str(&self) -> &str {
    method layout_for_byte_len (line 52) | fn layout_for_byte_len(len: usize) -> alloc::Layout {
    method is_global_constant (line 61) | fn is_global_constant(&self) -> bool {
    method take_ref (line 67) | fn take_ref(&mut self) -> *mut SharedStrData {
    method release_ref (line 83) | unsafe fn release_ref(&mut self) {
  type SharedStr (line 107) | pub(super) struct SharedStr {
    method new (line 112) | pub(super) fn new(value: &str) -> SharedStr {
    method as_str (line 119) | pub(super) fn as_str(&self) -> &str {
    method from (line 125) | fn from(value: &str) -> SharedStr {
  method clone (line 131) | fn clone(&self) -> SharedStr {
  method drop (line 141) | fn drop(&mut self) {
  function construction (line 153) | fn construction() {
  function cloning (line 162) | fn cloning() {

FILE: runtime/boxed/types/str.rs
  type StrStorage (line 10) | pub enum StrStorage {
    method box_size (line 19) | pub fn box_size(self) -> BoxSize {
  type Str (line 29) | pub struct Str {
    constant MAX_INLINE_BYTES (line 40) | pub const MAX_INLINE_BYTES: usize = 29;
    constant EXTERNAL_INLINE_BYTE_LEN (line 43) | pub const EXTERNAL_INLINE_BYTE_LEN: u8 = (Self::MAX_INLINE_BYTES as u8...
    method new (line 46) | pub fn new(heap: &mut impl AsHeap, value: &str) -> Gc<Str> {
    method storage_for_byte_len (line 61) | pub fn storage_for_byte_len(len: usize) -> StrStorage {
    method is_inline (line 72) | fn is_inline(&self) -> bool {
    method as_repr (line 76) | fn as_repr(&self) -> Repr<'_> {
    method as_repr_mut (line 84) | fn as_repr_mut(&mut self) -> ReprMut<'_> {
    method as_str (line 93) | pub fn as_str(&self) -> &str {
    method fmt (line 115) | fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::E...
  method eq (line 102) | fn eq(&self, other: &Str) -> bool {
  method hash (line 108) | fn hash<H: Hasher>(&self, state: &mut H) {
  method drop (line 121) | fn drop(&mut self) {
  type InlineStr (line 135) | struct InlineStr {
    method new (line 142) | fn new(header: Header, value: &str) -> InlineStr {
    method as_utf8 (line 160) | fn as_utf8(&self) -> &[u8] {
    method as_str (line 170) | fn as_str(&self) -> &str {
  type ExternalStr (line 177) | struct ExternalStr {
    method new (line 186) | fn new(header: Header, value: &str) -> ExternalStr {
  type Repr (line 196) | enum Repr<'a> {
  type ReprMut (line 201) | enum ReprMut<'a> {
  function sizes (line 213) | fn sizes() {
  function equality (line 220) | fn equality() {
  function fmt_debug (line 232) | fn fmt_debug() {
  function round_trip (line 240) | fn round_trip() {

FILE: runtime/boxed/types/sym.rs
  type Sym (line 11) | pub struct Sym {
    method new (line 23) | pub fn new(heap: &mut impl AsHeap, value: &str) -> Gc<Sym> {
    method from_interned_sym (line 30) | pub fn from_interned_sym(heap: &mut impl AsHeap, interned: InternedSym...
    method size (line 40) | pub fn size() -> BoxSize {
    method name (line 48) | pub fn name<'a>(&'a self, interner: &'a impl AsInterner) -> &'a str {
    method interned (line 53) | pub fn interned(&self) -> InternedSym {
    method interned_mut (line 58) | pub(crate) fn interned_mut(&mut self) -> &mut InternedSym {
    method fmt (line 77) | fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::E...
  method eq (line 64) | fn eq(&self, other: &Sym) -> bool {
  method hash (line 70) | fn hash<H: Hasher>(&self, state: &mut H) {
  function sizes (line 89) | fn sizes() {
  function equality (line 94) | fn equality() {
  function fmt_debug (line 106) | fn fmt_debug() {

FILE: runtime/boxed/types/vector.rs
  constant MAX_16BYTE_INLINE_LEN (line 10) | const MAX_16BYTE_INLINE_LEN: usize = (16 - 8) / mem::size_of::<Gc<Any>>();
  constant MAX_32BYTE_INLINE_LEN (line 11) | const MAX_32BYTE_INLINE_LEN: usize = (32 - 8) / mem::size_of::<Gc<Any>>();
  constant EXTERNAL_INLINE_LEN (line 13) | const EXTERNAL_INLINE_LEN: u32 = (MAX_32BYTE_INLINE_LEN + 1) as u32;
  type VectorStorage (line 17) | pub enum VectorStorage {
    method box_size (line 26) | pub fn box_size(self) -> BoxSize {
  type Vector (line 38) | pub struct Vector<T: Boxed = Any> {
  constant MAX_INLINE_LEN (line 49) | pub const MAX_INLINE_LEN: usize = MAX_32BYTE_INLINE_LEN;
  constant EXTERNAL_INLINE_LEN (line 52) | pub const EXTERNAL_INLINE_LEN: u32 = (Self::MAX_INLINE_LEN as u32) + 1;
  function new (line 55) | pub fn new(
  function storage_for_element_len (line 73) | fn storage_for_element_len(len: usize) -> VectorStorage {
  function from_values (line 87) | pub fn from_values<V, F>(
  function is_inline (line 101) | fn is_inline(&self) -> bool {
  function as_repr (line 105) | fn as_repr(&self) -> Repr<'_, T> {
  function as_repr_mut (line 113) | fn as_repr_mut(&mut self) -> ReprMut<'_, T> {
  function len (line 122) | pub fn len(&self) -> usize {
  function is_empty (line 130) | pub fn is_empty(&self) -> bool {
  function get (line 135) | pub fn get(&self, index: usize) -> Option<Gc<T>> {
  function iter (line 143) | pub fn iter<'a>(&'a self) -> Box<(dyn ExactSizeIterator<Item = Gc<T>> + ...
  function assoc (line 151) | pub fn assoc(&self, heap: &mut impl AsHeap, index: usize, value: Gc<T>) ...
  function append (line 179) | pub fn append(&self, heap: &mut impl AsHeap, other: Gc<Vector<T>>) -> Gc...
  function extend (line 188) | pub fn extend(
  function take (line 219) | pub fn take(&self, heap: &mut impl AsHeap, count: usize) -> Gc<Vector<T>> {
  function visit_mut_elements (line 243) | pub(crate) fn visit_mut_elements<F>(&mut self, visitor: &mut F)
  method eq_in_heap (line 259) | fn eq_in_heap(&self, heap: &Heap, other: &Vector<T>) -> bool {
  method hash_in_heap (line 271) | fn hash_in_heap<H: Hasher>(&self, heap: &Heap, state: &mut H) {
  function fmt (line 281) | fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Err...
  constant BOXED_ABI_TYPE (line 292) | const BOXED_ABI_TYPE: BoxedAbiType = BoxedAbiType::Vector(&T::BOXED_ABI_...
  type InlineVector (line 296) | pub struct InlineVector<T: Boxed> {
  function new (line 303) | fn new(header: Header, values: impl ExactSizeIterator<Item = Gc<T>>) -> ...
  function iter (line 319) | fn iter(&self) -> impl ExactSizeIterator<Item = Gc<T>> + '_ {
  function iter_mut (line 325) | fn iter_mut<'a>(&'a mut self) -> impl ExactSizeIterator<Item = &mut Gc<T...
  function get (line 331) | fn get(&self, index: usize) -> Option<Gc<T>> {
  type ExternalVector (line 341) | pub struct ExternalVector<T: Boxed> {
  function new (line 348) | fn new(header: Header, values: impl ExactSizeIterator<Item = Gc<T>>) -> ...
  type Repr (line 357) | enum Repr<'a, T: Boxed> {
  type ReprMut (line 362) | enum ReprMut<'a, T: Boxed> {
  method drop (line 368) | fn drop(&mut self) {
  function sizes (line 389) | fn sizes() {
  function equality (line 396) | fn equality() {
  function fmt_debug (line 418) | fn fmt_debug() {

FILE: runtime/callback.rs
  type Callback (line 16) | pub struct Callback<F>
  function captures (line 29) | pub fn captures(&self) -> boxed::Captures {
  type EntryPointAbiType (line 38) | pub struct EntryPointAbiType {
  type EncodeEntryPointAbiType (line 50) | pub trait EncodeEntryPointAbiType: Copy {
    constant ENTRY_POINT_ABI_TYPE (line 52) | const ENTRY_POINT_ABI_TYPE: EntryPointAbiType;
  function encode_entry_point_abi_type (line 103) | fn encode_entry_point_abi_type() {

FILE: runtime/class_map.rs
  type FieldType (line 13) | pub enum FieldType {
    method from_abi_type (line 23) | pub fn from_abi_type(abi_type: &abitype::AbiType) -> Self {
  type Field (line 41) | pub struct Field {
    method new (line 49) | pub fn new(field_type: FieldType, offset: usize) -> Field {
    method field_type (line 58) | pub fn field_type(self) -> FieldType {
    method offset (line 63) | pub fn offset(self) -> usize {
    method is_last (line 68) | pub fn is_last(self) -> bool {
  type ClassRef (line 76) | pub struct ClassRef<'a> {
  function is_empty (line 83) | pub fn is_empty(self) -> bool {
  function field_iter (line 88) | pub fn field_iter(self) -> FieldIterator<'a> {
  type BoxedClass (line 100) | pub struct BoxedClass {
    method from_fields (line 106) | pub fn from_fields(fields_iter: impl Iterator<Item = Field>) -> Self {
    method as_ref (line 115) | pub fn as_ref(&self) -> ClassRef<'_> {
  type FieldIterator (line 128) | pub struct FieldIterator<'a> {
  function empty (line 134) | pub fn empty() -> FieldIterator<'static> {
  type Item (line 143) | type Item = Field;
  method next (line 145) | fn next(&mut self) -> Option<Field> {
  type ClassMap (line 165) | pub struct ClassMap {
    constant DYNAMIC_RECORD_CLASS_ID_BASE (line 171) | const DYNAMIC_RECORD_CLASS_ID_BASE: RecordClassId = 1u32 << 30;
    method empty (line 174) | pub fn empty() -> ClassMap {
    method with_const_classes (line 179) | pub(crate) fn with_const_classes(const_classes: *const ClassRef<'stati...
    method push_dynamic_class (line 187) | pub fn push_dynamic_class(&mut self, boxed_class: BoxedClass) -> Recor...
    method class_for_record_class_id (line 196) | pub fn class_for_record_class_id(&self, record_class_id: RecordClassId...

FILE: runtime/compiler_support.rs
  type TaskEntry (line 18) | type TaskEntry = extern "C" fn(&mut Task);
  function launch_task (line 21) | pub unsafe extern "C" fn launch_task(
  function alloc_cells (line 44) | pub extern "C" fn alloc_cells(task: &mut Task, count: u32) -> *mut boxed...
  function alloc_record_data (line 49) | pub extern "C" fn alloc_record_data(size: u64, align: u32) -> *mut u8 {
  function equals (line 57) | pub extern "C" fn equals(task: &Task, lhs: Gc<boxed::Any>, rhs: Gc<boxed...
  function panic_with_string (line 62) | pub unsafe extern "C" fn panic_with_string(

FILE: runtime/intern.rs
  constant INLINE_FILL_BYTE (line 24) | const INLINE_FILL_BYTE: u8 = 0x80;
  constant LOCAL_INDEXED_FLAG (line 25) | const LOCAL_INDEXED_FLAG: u8 = 0x81;
  constant GLOBAL_INDEXED_FLAG (line 26) | const GLOBAL_INDEXED_FLAG: u8 = 0x82;
  constant INLINE_SIZE (line 28) | const INLINE_SIZE: usize = 8;
  type RawGlobalNames (line 31) | pub struct RawGlobalNames {
  type GlobalName (line 37) | struct GlobalName {
    method as_str (line 43) | fn as_str(&self) -> &str {
  type InternedIndexed (line 54) | struct InternedIndexed {
  type InternedInline (line 62) | struct InternedInline {
    method as_str (line 67) | fn as_str(&self) -> &str {
  type InternedRepr (line 87) | enum InternedRepr<'a> {
  method try_from_inline_name (line 98) | pub fn try_from_inline_name(name: &str) -> Option<InternedSym> {
  method from_global_index (line 120) | pub fn from_global_index(index: u32) -> InternedSym {
  method from_local_index (line 130) | pub fn from_local_index(index: u32) -> InternedSym {
  method to_raw_u64 (line 140) | pub fn to_raw_u64(self) -> u64 {
  method repr (line 144) | fn repr(&self) -> InternedRepr<'_> {
  method eq (line 156) | fn eq(&self, other: &InternedSym) -> bool {
  method hash (line 164) | fn hash<H: Hasher>(&self, state: &mut H) {
  method fmt (line 172) | fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Err...
  type Interner (line 183) | pub struct Interner {
    method new (line 192) | pub fn new() -> Interner {
    method with_global_names (line 205) | pub unsafe fn with_global_names(raw_global_names: *const RawGlobalName...
    method lookup_global_name (line 219) | fn lookup_global_name(&mut self, name: &str) -> Option<InternedSym> {
    method intern (line 231) | pub fn intern(&mut self, name: &str) -> InternedSym {
    method intern_static (line 264) | pub fn intern_static(&mut self, name: &str) -> InternedSym {
    method unintern (line 274) | pub fn unintern<'a>(&'a self, interned: &'a InternedSym) -> &'a str {
    method clone_for_collect_garbage (line 287) | pub(crate) fn clone_for_collect_garbage(&self) -> Self {
  method default (line 320) | fn default() -> Interner {
  type AsInterner (line 326) | pub trait AsInterner {
    method as_interner (line 328) | fn as_interner(&self) -> &Interner;
    method as_interner (line 332) | fn as_interner(&self) -> &Interner {
  function sizes (line 343) | fn sizes() {
  function equality (line 350) | fn equality() {
  function fmt_debug (line 369) | fn fmt_debug() {
  function roundtrip (line 380) | fn roundtrip() {
  function clone_for_collect_garbage (line 404) | fn clone_for_collect_garbage() {

FILE: runtime/persistent/vector.rs
  constant GLOBAL_CONSTANT_REFCOUNT (line 7) | pub const GLOBAL_CONSTANT_REFCOUNT: u64 = std::u64::MAX;
  constant TRIE_RADIX (line 9) | const TRIE_RADIX: u32 = 5;
  constant NODE_SIZE (line 10) | pub const NODE_SIZE: usize = 1 << TRIE_RADIX;
  constant LEVEL_MASK (line 11) | const LEVEL_MASK: usize = (1 << TRIE_RADIX) - 1;
  type Vector (line 27) | pub struct Vector<T>
  function new (line 40) | pub fn new(values: impl ExactSizeIterator<Item = T>) -> Self {
  function len (line 50) | pub fn len(&self) -> usize {
  function is_empty (line 54) | pub fn is_empty(&self) -> bool {
  function push_leaf (line 59) | fn push_leaf(&self, leaf: *const Node<T>, added_elements: u64) -> Vector...
  function get (line 92) | pub fn get(&self, index: usize) -> Option<T> {
  function take (line 101) | pub fn take(&self, count: usize) -> Vector<T> {
  function get_leaf (line 135) | fn get_leaf(&self, index: usize) -> *const Node<T> {
  function assoc (line 144) | pub fn assoc(&self, index: usize, value: T) -> Vector<T> {
  function iter (line 176) | pub fn iter(&self) -> impl ExactSizeIterator<Item = T> + '_ {
  function extend (line 184) | pub fn extend(&self, mut values: impl ExactSizeIterator<Item = T>) -> Ve...
  function visit_mut_elements (line 255) | pub(crate) fn visit_mut_elements<F>(&mut self, visitor: &mut F)
  function trie_size (line 276) | fn trie_size(&self) -> usize {
  function trie_size_for_len (line 280) | fn trie_size_for_len(len: usize) -> usize {
  function tail_size (line 287) | fn tail_size(&self) -> usize {
  function tail_size_for_len (line 291) | fn tail_size_for_len(len: usize) -> usize {
  function tail_offset (line 296) | fn tail_offset(&self) -> usize {
  function trie_depth (line 301) | fn trie_depth(trie_size: usize) -> u32 {
  method drop (line 315) | fn drop(&mut self) {
  type Node (line 332) | struct Node<T>
  function new_leaf (line 344) | fn new_leaf(elements: [MaybeUninit<T>; NODE_SIZE]) -> *const Node<T> {
  function new_branch (line 360) | fn new_branch(elements: [*const Node<T>; NODE_SIZE]) -> *const Node<T> {
  function new_chain (line 377) | fn new_chain(leaf_node: *const Node<T>, remaining_depth: u32) -> *const ...
  function get_leaf (line 391) | fn get_leaf(&self, remaining_depth: u32, index: usize) -> *const Node<T> {
  function assoc_value (line 402) | fn assoc_value(&self, remaining_depth: u32, index: usize, value: T) -> *...
  function push_leaf (line 434) | fn push_leaf(
  function is_global_constant (line 469) | fn is_global_constant(&self) -> bool {
  function take_ptr_ref (line 473) | fn take_ptr_ref(self_ptr: *const Node<T>) -> *const Node<T> {
  function release_ptr_ref (line 486) | unsafe fn release_ptr_ref(self_ptr: *const Node<T>, depth: u32) {
  function visit_mut_elements (line 522) | fn visit_mut_elements<F>(
  type Iter (line 566) | struct Iter<'a, T>
  type Item (line 579) | type Item = T;
  method next (line 581) | fn next(&mut self) -> Option<T> {
  method size_hint (line 598) | fn size_hint(&self) -> (usize, Option<usize>) {
  method clone (line 611) | fn clone(&self) -> Self {
  function assert_nodes_deallocated (line 626) | fn assert_nodes_deallocated<T>(block: T)
  function tail_only_vector (line 658) | fn tail_only_vector() {
  function extended_one_level_vector (line 687) | fn extended_one_level_vector() {
  function extended_two_level_vector (line 716) | fn extended_two_level_vector() {
  function initialised_three_level_vector (line 756) | fn initialised_three_level_vector() {
  function vector_extend (line 806) | fn vector_extend() {

FILE: runtime/task.rs
  type Task (line 17) | pub struct Task {
    constant DEFAULT_CAPACITY (line 22) | const DEFAULT_CAPACITY: usize = 32;
    method new (line 25) | pub fn new() -> Task {
    method with_type_info (line 29) | pub(crate) fn with_type_info(type_info: TypeInfo) -> Task {
    method heap (line 36) | pub fn heap(&self) -> &Heap {
    method heap_mut (line 41) | pub fn heap_mut(&mut self) -> &mut Heap {
    method panic (line 48) | pub fn panic(&mut self, message: String) -> Never {
  method default (line 65) | fn default() -> Task {
  method as_heap (line 71) | fn as_heap(&self) -> &Heap {
  method as_heap_mut (line 75) | fn as_heap_mut(&mut self) -> &mut Heap {

FILE: stdlib/rust/bitwise.rs
  function stdlib_bit_and (line 7) | pub fn stdlib_bit_and(lhs: i64, rhs: i64, rest: Gc<boxed::List<boxed::In...
  function stdlib_bit_or (line 12) | pub fn stdlib_bit_or(lhs: i64, rhs: i64, rest: Gc<boxed::List<boxed::Int...
  function stdlib_bit_xor (line 17) | pub fn stdlib_bit_xor(lhs: i64, rhs: i64, rest: Gc<boxed::List<boxed::In...
  function stdlib_bit_not (line 22) | pub fn stdlib_bit_not(val: i64) -> i64 {
  function stdlib_bit_shift_left (line 27) | pub fn stdlib_bit_shift_left(task: &mut Task, val: i64, bit_count: i64) ...
  function stdlib_bit_shift_right (line 38) | pub fn stdlib_bit_shift_right(task: &mut Task, val: i64, bit_count: i64)...
  function stdlib_unsigned_bit_shift_right (line 49) | pub fn stdlib_unsigned_bit_shift_right(task: &mut Task, val: i64, bit_co...

FILE: stdlib/rust/hash.rs
  function stdlib_hash (line 12) | pub fn stdlib_hash(task: &mut Task, input: Gc<boxed::Any>) -> i64 {

FILE: stdlib/rust/lib.rs
  function panic_common (line 44) | pub fn panic_common(task: &mut Task, values: Gc<boxed::List<boxed::Any>>...
  function stdlib_panic (line 57) | pub fn stdlib_panic(task: &mut Task, values: Gc<boxed::List<boxed::Any>>...
  function stdlib_panic_impure (line 62) | pub fn stdlib_panic_impure(task: &mut Task, values: Gc<boxed::List<boxed...
  function stdlib_exit (line 67) | pub fn stdlib_exit(exit_code: i64) {

FILE: stdlib/rust/list.rs
  function stdlib_length (line 9) | pub fn stdlib_length(input: Gc<boxed::List<boxed::Any>>) -> i64 {
  function stdlib_cons (line 14) | pub fn stdlib_cons(
  function stdlib_map (line 23) | pub fn stdlib_map(
  function stdlib_filter (line 37) | pub fn stdlib_filter(
  function stdlib_some_p (line 51) | pub fn stdlib_some_p(
  function stdlib_every_p (line 60) | pub fn stdlib_every_p(
  function stdlib_fold (line 69) | pub fn stdlib_fold(
  function stdlib_concat (line 83) | pub fn stdlib_concat(
  function stdlib_take (line 112) | pub fn stdlib_take(
  function stdlib_reverse (line 122) | pub fn stdlib_reverse(
  function stdlib_repeat (line 131) | pub fn stdlib_repeat(

FILE: stdlib/rust/math.rs
  function fold_float_op (line 7) | fn fold_float_op<FR>(
  function fold_num_op (line 33) | fn fold_num_op<IR, FR>(
  function stdlib_add (line 69) | pub fn stdlib_add(
  function stdlib_mul (line 88) | pub fn stdlib_mul(
  function stdlib_sub (line 107) | pub fn stdlib_sub(
  function stdlib_div (line 140) | pub fn stdlib_div(initial_float: f64, rest: Gc<boxed::List<boxed::Float>...
  function stdlib_quot (line 154) | pub fn stdlib_quot(task: &mut Task, numerator: i64, denominator: i64) ->...
  function stdlib_rem (line 165) | pub fn stdlib_rem(task: &mut Task, numerator: i64, denominator: i64) -> ...
  function stdlib_sqrt (line 176) | pub fn stdlib_sqrt(radicand: f64) -> f64 {

FILE: stdlib/rust/number.rs
  function compare_nums (line 6) | fn compare_nums<IC, FC>(
  function stdlib_float (line 47) | pub fn stdlib_float(input: Gc<boxed::Num>) -> f64 {
  function stdlib_int (line 55) | pub fn stdlib_int(task: &mut Task, input: Gc<boxed::Num>) -> i64 {
  function stdlib_num_lt (line 79) | pub fn stdlib_num_lt(initial: Gc<boxed::Num>, rest: Gc<boxed::List<boxed...
  function stdlib_num_le (line 84) | pub fn stdlib_num_le(initial: Gc<boxed::Num>, rest: Gc<boxed::List<boxed...
  function stdlib_num_eq (line 89) | pub fn stdlib_num_eq(initial: Gc<boxed::Num>, rest: Gc<boxed::List<boxed...
  function stdlib_num_gt (line 94) | pub fn stdlib_num_gt(initial: Gc<boxed::Num>, rest: Gc<boxed::List<boxed...
  function stdlib_num_ge (line 99) | pub fn stdlib_num_ge(initial: Gc<boxed::Num>, rest: Gc<boxed::List<boxed...

FILE: stdlib/rust/read.rs
  function stdlib_read_str (line 11) | pub fn stdlib_read_str(task: &mut Task, edn_str: Gc<boxed::Str>) -> Gc<b...

FILE: stdlib/rust/set.rs
  function stdlib_set (line 7) | pub fn stdlib_set(
  function stdlib_set_contains_p (line 15) | pub fn stdlib_set_contains_p(
  function stdlib_set_length (line 24) | pub fn stdlib_set_length(set: Gc<boxed::Set<boxed::Any>>) -> i64 {
  function stdlib_set_to_list (line 29) | pub fn stdlib_set_to_list(
  function stdlib_subset_p (line 37) | pub fn stdlib_subset_p(

FILE: stdlib/rust/testing.rs
  function stdlib_black_box (line 10) | pub fn stdlib_black_box(value: Gc<boxed::Any>) -> Gc<boxed::Any> {
  function stdlib_black_box_impure (line 15) | pub fn stdlib_black_box_impure(value: Gc<boxed::Any>) -> Gc<boxed::Any> {
  function stdlib_heap_alloc_count (line 20) | pub fn stdlib_heap_alloc_count(
  function stdlib_fn_op_categories (line 34) | pub fn stdlib_fn_op_categories(_value: Gc<boxed::FunThunk>) -> Gc<boxed:...

FILE: stdlib/rust/vector.rs
  function stdlib_vector (line 7) | pub fn stdlib_vector(
  function stdlib_vector_ref (line 15) | pub fn stdlib_vector_ref(
  function stdlib_vector_length (line 41) | pub fn stdlib_vector_length(vector: Gc<boxed::Vector<boxed::Any>>) -> i64 {
  function stdlib_vector_to_list (line 46) | pub fn stdlib_vector_to_list(
  function stdlib_vector_assoc (line 54) | pub fn stdlib_vector_assoc(
  function stdlib_vector_append (line 80) | pub fn stdlib_vector_append(
  function stdlib_vector_extend (line 96) | pub fn stdlib_vector_extend(
  function stdlib_vector_take (line 105) | pub fn stdlib_vector_take(

FILE: stdlib/rust/write.rs
  function pretty_print_common (line 10) | fn pretty_print_common(
  function write_boxed_common (line 20) | fn write_boxed_common(
  function stdlib_print (line 37) | pub fn stdlib_print(task: &mut Task, values: Gc<boxed::List<boxed::Any>>) {
  function stdlib_println (line 45) | pub fn stdlib_println(task: &mut Task, values: Gc<boxed::List<boxed::Any...
  function stdlib_write (line 54) | pub fn stdlib_write(task: &mut Task, values: Gc<boxed::List<boxed::Any>>) {
  function stdlib_writeln (line 62) | pub fn stdlib_writeln(task: &mut Task, values: Gc<boxed::List<boxed::Any...
  function stdlib_print_str (line 71) | pub fn stdlib_print_str(task: &mut Task, values: Gc<boxed::List<boxed::A...
  function stdlib_write_str (line 82) | pub fn stdlib_write_str(task: &mut Task, values: Gc<boxed::List<boxed::A...

FILE: syntax/anon_fun.rs
  type FoundArity (line 5) | struct FoundArity {
  function visit_arg_literals (line 11) | fn visit_arg_literals(found_arity: &mut FoundArity, datum: Datum) -> Res...
  function convert_anon_fun (line 52) | pub fn convert_anon_fun(outer_span: Span, body_data: impl Iterator<Item ...
  function empty_fun (line 96) | fn empty_fun() {
  function one_arg_fun (line 119) | fn one_arg_fun() {
  function two_arg_fun (line 148) | fn two_arg_fun() {
  function rest_fun (line 185) | fn rest_fun() {

FILE: syntax/datum.rs
  type DataStr (line 5) | pub type DataStr = Arc<str>;
  type Datum (line 8) | pub enum Datum {
    method span (line 22) | pub fn span(&self) -> Span {
    method description (line 37) | pub fn description(&self) -> &'static str {

FILE: syntax/error.rs
  type Error (line 10) | pub struct Error {
    method new (line 16) | pub fn new(span: Span, kind: ErrorKind) -> Error {
    method kind (line 20) | pub fn kind(&self) -> &ErrorKind {
    method span (line 24) | pub fn span(&self) -> Span {
  method fmt (line 32) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type ErrorKind (line 39) | pub enum ErrorKind {
    method message (line 54) | pub fn message(&self) -> String {
    method within_context (line 80) | pub fn within_context(&self) -> Option<WithinContext> {
  type Result (line 88) | pub type Result<T> = result::Result<T, Error>;
  type WithinContext (line 92) | pub enum WithinContext {
    method description (line 107) | pub fn description(&self) -> &'static str {
    method expected_next (line 123) | pub fn expected_next(&self) -> Option<ExpectedNext> {
    method open_char_span (line 135) | pub fn open_char_span(&self) -> Option<Span> {
  type ExpectedNext (line 149) | pub enum ExpectedNext {
    method close_char (line 159) | pub fn close_char(self) -> char {
    method description (line 169) | pub fn description(self) -> String {

FILE: syntax/parser.rs
  function data_from_str_with_span_offset (line 5) | pub fn data_from_str_with_span_offset(
  function data_from_str (line 13) | pub fn data_from_str(file_id: Option<FileId>, s: &str) -> Result<Vec<Dat...
  function datum_from_str_with_span_offset (line 17) | pub fn datum_from_str_with_span_offset(
  function datum_from_str (line 25) | pub fn datum_from_str(file_id: Option<FileId>, s: &str) -> Result<Datum> {
  function is_whitespace (line 29) | fn is_whitespace(c: char) -> bool {
  function is_identifier_char (line 33) | pub fn is_identifier_char(c: char) -> bool {
  type Parser (line 45) | pub struct Parser<'input> {
  function from_str (line 52) | fn from_str(file_id: Option<FileId>, input: &'input str, span_offset: By...
  function eof_err (line 60) | fn eof_err(&self, within: WithinContext) -> Error {
  function peek_char (line 69) | fn peek_char(&mut self, within: WithinContext) -> Result<char> {
  function peek_nth_char (line 76) | fn peek_nth_char(&mut self, i: usize, within: WithinContext) -> Result<c...
  function eat_bytes (line 83) | fn eat_bytes(&mut self, count: usize) {
  function consume_char (line 88) | fn consume_char(&mut self, within: WithinContext) -> Result<char> {
  function skip_until_non_whitespace (line 106) | fn skip_until_non_whitespace(&mut self, within: WithinContext) -> Result...
  function consume_until (line 133) | fn consume_until<T>(&mut self, predicate: T) -> (Span, &str)
  function consume_while (line 153) | fn consume_while<T>(&mut self, mut predicate: T) -> (Span, &str)
  function capture_span (line 160) | fn capture_span<F, R>(&mut self, block: F) -> (Span, R)
  function parse_num (line 171) | fn parse_num(&mut self) -> Result<Datum> {
  function parse_symbolic_float (line 214) | fn parse_symbolic_float(&mut self) -> Result<Datum> {
  function parse_signed_num_or_symbol (line 233) | fn parse_signed_num_or_symbol(&mut self) -> Result<Datum> {
  function parse_char (line 245) | fn parse_char(&mut self) -> Result<Datum> {
  function parse_dispatch (line 284) | fn parse_dispatch(&mut self) -> Result<Datum> {
  function parse_seq (line 304) | fn parse_seq<F>(&mut self, terminator: char, make_ec: F) -> Result<Vec<D...
  function parse_list (line 329) | fn parse_list(&mut self) -> Result<Datum> {
  function parse_vector (line 335) | fn parse_vector(&mut self) -> Result<Datum> {
  function parse_map (line 341) | fn parse_map(&mut self) -> Result<Datum> {
  function parse_set (line 360) | fn parse_set(&mut self) -> Result<Datum> {
  function parse_anon_fun (line 372) | fn parse_anon_fun(&mut self) -> Result<Datum> {
  function parse_quote_escape (line 387) | fn parse_quote_escape(&mut self) -> Result<char> {
  function parse_string (line 417) | fn parse_string(&mut self) -> Result<Datum> {
  function parse_identifier (line 443) | fn parse_identifier(&mut self, within: WithinContext) -> Result<Datum> {
  function parse_symbol_shorthand (line 461) | fn parse_symbol_shorthand(&mut self, expansion: &str) -> Result<Datum> {
  function parse_datum_starting_with (line 479) | fn parse_datum_starting_with(&mut self, c: char, within: WithinContext) ...
  function parse_datum (line 494) | fn parse_datum(&mut self) -> Result<Datum> {
  function parse_data (line 501) | fn parse_data(&mut self) -> Result<Vec<Datum>> {
  function whole_str_span (line 527) | fn whole_str_span(v: &str) -> Span {
  function bool_datum (line 532) | fn bool_datum() {
  function list_datum (line 561) | fn list_datum() {
  function vector_datum (line 617) | fn vector_datum() {
  function symbol_datum (line 655) | fn symbol_datum() {
  function keyword_symbol_datum (line 680) | fn keyword_symbol_datum() {
  function string_datum (line 690) | fn string_datum() {
  function char_datum (line 728) | fn char_datum() {
  function int_datum (line 765) | fn int_datum() {
  function float_datum (line 801) | fn float_datum() {
  function map_datum (line 832) | fn map_datum() {
  function set_datum (line 875) | fn set_datum() {
  function quote_shorthand (line 915) | fn quote_shorthand() {
  function unsupported_dispatch (line 961) | fn unsupported_dispatch() {
  function datum_comment (line 976) | fn datum_comment() {
  function multiple_data (line 1000) | fn multiple_data() {

FILE: syntax/span.rs
  type FileId (line 4) | pub type FileId = NonZeroU32;
  type ByteIndex (line 5) | pub type ByteIndex = u32;
  type Span (line 8) | pub struct Span {
    method new (line 15) | pub const fn new(file_id: Option<FileId>, start: ByteIndex, end: ByteI...
    method from_str (line 23) | pub const fn from_str(file_id: Option<FileId>, s: &str) -> Self {
    method file_id (line 31) | pub fn file_id(&self) -> Option<FileId> {
    method start (line 35) | pub fn start(&self) -> ByteIndex {
    method end (line 39) | pub fn end(&self) -> ByteIndex {
    method byte_range (line 43) | pub fn byte_range(&self) -> Range<usize> {
    method contains (line 47) | pub fn contains(&self, other: Span) -> bool {
  function t2s (line 53) | pub fn t2s(v: &str) -> Span {