SYMBOL INDEX (863 symbols across 59 files)

FILE: src/diagnostics.rs
  constant ERR_INDENT_SIZE (line 10) | pub const ERR_INDENT_SIZE: usize = 2;
  type Diagnostics (line 13) | pub struct Diagnostics {
    method new (line 72) | pub fn new(config: DiagnosticsConfig) -> Self {
    method add_parsing_error (line 76) | pub fn add_parsing_error(&mut self, err: impl std::fmt::Display, sourc...
    method add_book_error (line 80) | pub fn add_book_error(&mut self, err: impl std::fmt::Display) {
    method add_function_error (line 84) | pub fn add_function_error(&mut self, err: impl std::fmt::Display, name...
    method add_inet_error (line 93) | pub fn add_inet_error(&mut self, err: impl std::fmt::Display, def_name...
    method add_function_warning (line 97) | pub fn add_function_warning(
    method add_book_warning (line 113) | pub fn add_book_warning(&mut self, warn: impl std::fmt::Display, warn_...
    method add_diagnostic (line 118) | pub fn add_diagnostic(
    method take_rule_err (line 129) | pub fn take_rule_err<T, E: std::fmt::Display>(
    method take_inet_err (line 143) | pub fn take_inet_err<T, E: std::fmt::Display>(
    method has_severity (line 157) | pub fn has_severity(&self, severity: Severity) -> bool {
    method has_errors (line 161) | pub fn has_errors(&self) -> bool {
    method fatal (line 168) | pub fn fatal<T>(&mut self, t: T) -> Result<T, Diagnostics> {
    method display_with_severity (line 177) | pub fn display_with_severity(&self, severity: Severity) -> impl std::f...
    method display_only_messages (line 279) | pub fn display_only_messages(&self) -> impl std::fmt::Display + '_ {
    method from (line 302) | fn from(value: String) -> Self {
    method from (line 319) | fn from(value: ParseError) -> Self {
  type DiagnosticsConfig (line 19) | pub struct DiagnosticsConfig {
    method new (line 331) | pub fn new(severity: Severity, verbose: bool) -> Self {
    method warning_severity (line 346) | pub fn warning_severity(&self, warn: WarningType) -> Severity {
  type Diagnostic (line 32) | pub struct Diagnostic {
    method display_with_origin (line 375) | pub fn display_with_origin<'a>(&'a self, origin: &'a DiagnosticOrigin)...
  type DiagnosticOrigin (line 39) | pub enum DiagnosticOrigin {
  type Severity (line 53) | pub enum Severity {
  type WarningType (line 60) | pub enum WarningType {
  method fmt (line 290) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  method default (line 361) | fn default() -> Self {
  method fmt (line 369) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  type TextLocation (line 399) | pub struct TextLocation {
    method new (line 405) | pub fn new(line: usize, char: usize) -> Self {
    method from_byte_loc (line 410) | pub fn from_byte_loc(code: &str, loc: usize) -> Self {
  type TextSpan (line 430) | pub struct TextSpan {
    method new (line 436) | pub fn new(start: TextLocation, end: TextLocation) -> Self {
    method from_byte_span (line 441) | pub fn from_byte_span(code: &str, span: Range<usize>) -> Self {

FILE: src/fun/builtins.rs
  constant BUILTINS (line 7) | const BUILTINS: &str = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), ...
  constant LIST (line 9) | pub const LIST: &str = "List";
  constant LCONS (line 10) | pub const LCONS: &str = "List/Cons";
  constant LNIL (line 11) | pub const LNIL: &str = "List/Nil";
  constant LCONS_TAG (line 12) | pub const LCONS_TAG: u32 = 1;
  constant LNIL_TAG_REF (line 13) | pub const LNIL_TAG_REF: &str = "List/Nil/tag";
  constant LCONS_TAG_REF (line 14) | pub const LCONS_TAG_REF: &str = "List/Cons/tag";
  constant HEAD (line 16) | pub const HEAD: &str = "head";
  constant TAIL (line 17) | pub const TAIL: &str = "tail";
  constant STRING (line 19) | pub const STRING: &str = "String";
  constant SCONS (line 20) | pub const SCONS: &str = "String/Cons";
  constant SNIL (line 21) | pub const SNIL: &str = "String/Nil";
  constant SCONS_TAG (line 22) | pub const SCONS_TAG: u32 = 1;
  constant SNIL_TAG_REF (line 23) | pub const SNIL_TAG_REF: &str = "String/Nil/tag";
  constant SCONS_TAG_REF (line 24) | pub const SCONS_TAG_REF: &str = "String/Cons/tag";
  constant NAT (line 26) | pub const NAT: &str = "Nat";
  constant NAT_SUCC (line 27) | pub const NAT_SUCC: &str = "Nat/Succ";
  constant NAT_ZERO (line 28) | pub const NAT_ZERO: &str = "Nat/Zero";
  constant NAT_SUCC_TAG (line 29) | pub const NAT_SUCC_TAG: u32 = 0;
  constant TREE (line 31) | pub const TREE: &str = "Tree";
  constant TREE_NODE (line 32) | pub const TREE_NODE: &str = "Tree/Node";
  constant TREE_LEAF (line 33) | pub const TREE_LEAF: &str = "Tree/Leaf";
  constant MAP (line 35) | pub const MAP: &str = "Map";
  constant MAP_NODE (line 36) | pub const MAP_NODE: &str = "Map/Node";
  constant MAP_LEAF (line 37) | pub const MAP_LEAF: &str = "Map/Leaf";
  constant IO (line 39) | pub const IO: &str = "IO";
  constant IO_DONE (line 40) | pub const IO_DONE: &str = "IO/Done";
  constant IO_CALL (line 41) | pub const IO_CALL: &str = "IO/Call";
  constant BUILTIN_CTRS (line 43) | pub const BUILTIN_CTRS: &[&str] =
  constant BUILTIN_TYPES (line 46) | pub const BUILTIN_TYPES: &[&str] = &[LIST, STRING, NAT, TREE, MAP, IO];
  method builtins (line 49) | pub fn builtins() -> Self {
  method encode_builtins (line 57) | pub fn encode_builtins(&mut self) {
  method encode_builtins (line 68) | fn encode_builtins(&mut self) {
  method encode_list (line 88) | fn encode_list(elements: Vec<Term>) -> Term {
  method encode_str (line 95) | pub fn encode_str(val: &str) -> Term {
  method encode_nat (line 101) | pub fn encode_nat(val: u32) -> Term {
  method encode_builtins (line 107) | pub fn encode_builtins(&mut self) {
  method encode_list (line 119) | fn encode_list(elements: Vec<Pattern>) -> Pattern {
  method encode_str (line 128) | fn encode_str(str: &str) -> Pattern {

FILE: src/fun/check/check_untyped.rs
  function check_untyped_terms (line 9) | pub fn check_untyped_terms(&mut self) -> Result<(), Diagnostics> {
  method check_untyped_terms (line 24) | fn check_untyped_terms(&self) -> Result<(), String> {
  method check_untyped_patterns (line 59) | fn check_untyped_patterns(&self) -> Result<(), String> {

FILE: src/fun/check/set_entrypoint.rs
  type EntryErr (line 8) | pub enum EntryErr {
    method fmt (line 73) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function set_entrypoint (line 15) | pub fn set_entrypoint(&mut self) {
  function validate_entry_point (line 55) | fn validate_entry_point(entry: &Definition) -> Result<Name, EntryErr> {
  method get_possible_entry_points (line 64) | fn get_possible_entry_points(&self) -> (Option<&Definition>, Option<&Def...

FILE: src/fun/check/shared_names.rs
  type RepeatedTopLevelNameErr (line 6) | pub struct RepeatedTopLevelNameErr {
    method fmt (line 88) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function check_shared_names (line 15) | pub fn check_shared_names(&mut self) {
  type NameKind (line 37) | enum NameKind {
  type NameInfo (line 44) | struct NameInfo<'a>(IndexMap<&'a Name, Vec<NameKind>>);
  function add_name (line 47) | fn add_name(&mut self, name: &'a Name, kind: NameKind) {
  function into_errs (line 51) | fn into_errs(self) -> Vec<RepeatedTopLevelNameErr> {
  method fmt (line 78) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: src/fun/check/type_check.rs
  function type_check (line 13) | pub fn type_check(&mut self) -> Result<(), Diagnostics> {
  type ProgramTypes (line 24) | type ProgramTypes = HashMap<Name, Scheme>;
  type Scheme (line 28) | struct Scheme(Vec<Name>, Type);
    method free_type_vars (line 85) | fn free_type_vars(&self) -> BTreeSet<Name> {
    method subst (line 91) | fn subst(&self, subst: &Subst) -> Scheme {
    method instantiate (line 102) | fn instantiate(&self, var_gen: &mut VarGen) -> Type {
  type Subst (line 32) | struct Subst(BTreeMap<Name, Type>);
    method compose (line 113) | fn compose(mut self, other: Subst) -> Subst {
    method fmt (line 778) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type TypeEnv (line 36) | struct TypeEnv(BTreeMap<Name, Scheme>);
    method free_type_vars (line 121) | fn free_type_vars(&self) -> BTreeSet<Name> {
    method subst (line 130) | fn subst(&self, subst: &Subst) -> TypeEnv {
    method insert (line 135) | fn insert(&mut self, name: Name, scheme: Scheme) {
    method add_binds (line 139) | fn add_binds<'a>(
    method pop_binds (line 153) | fn pop_binds(&mut self, old_bnd: Vec<(Name, Option<Scheme>)>) {
  type VarGen (line 40) | struct VarGen(usize);
    method fresh (line 163) | fn fresh(&mut self) -> Type {
    method fresh_name (line 168) | fn fresh_name(&mut self) -> Name {
  type RecGroups (line 43) | struct RecGroups(Vec<Vec<Name>>);
    method from_book (line 176) | fn from_book(book: &Book) -> RecGroups {
  method free_type_vars (line 48) | fn free_type_vars(&self) -> BTreeSet<Name> {
  method subst (line 58) | fn subst(&self, subst: &Subst) -> Type {
  method generalize (line 76) | fn generalize(&self, env: &TypeEnv) -> Scheme {
  function infer_book (line 273) | fn infer_book(book: &Book, diags: &mut Diagnostics) -> Result<ProgramTyp...
  function infer_group (line 304) | fn infer_group(
  function infer (line 368) | fn infer(
  function instantiate_adt (line 560) | fn instantiate_adt(adt: &Adt, var_gen: &mut VarGen) -> Result<(Subst, Ty...
  function infer_match_cases (line 568) | fn infer_match_cases(
  function unify_fields (line 603) | fn unify_fields<'a>(ts: impl Iterator<Item = (&'a Type, &'a Type)>, ctx:...
  function unify_term (line 612) | fn unify_term(t1: &Type, t2: &Type, ctx: &Term) -> Result<(Type, Subst),...
  function unify (line 619) | fn unify(t1: &Type, t2: &Type) -> Result<(Type, Subst), String> {
  function specialize (line 704) | fn specialize(inf: &Type, ann: &Type) -> Result<Type, String> {

FILE: src/fun/check/unbound_refs.rs
  function check_unbound_refs (line 9) | pub fn check_unbound_refs(&mut self) -> Result<(), Diagnostics> {
  method check_unbound_refs (line 28) | pub fn check_unbound_refs(&self, book: &Book, unbounds: &mut HashSet<Nam...

FILE: src/fun/check/unbound_vars.rs
  type UnboundVarErr (line 9) | pub enum UnboundVarErr {
    method fmt (line 106) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function check_unbound_vars (line 16) | pub fn check_unbound_vars(&mut self) -> Result<(), Diagnostics> {
  method check_unbound_vars (line 37) | pub fn check_unbound_vars<'a>(
  function check_uses (line 54) | pub fn check_uses<'a>(
  function check_global_binds (line 88) | pub fn check_global_binds(pat: &Pattern, globals: &mut HashMap<Name, (us...
  function scope_contains (line 101) | fn scope_contains(nam: &Name, scope: &[Option<&Name>]) -> bool {

FILE: src/fun/display.rs
  type DisplayFn (line 7) | pub struct DisplayFn<F: Fn(&mut fmt::Formatter) -> fmt::Result>(pub F);
  function fmt (line 10) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type DisplayJoin (line 15) | pub struct DisplayJoin<F, S>(pub F, pub S);
  function fmt (line 24) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function gen_fan_pat_name (line 45) | fn gen_fan_pat_name() -> Name {
  function namegen_reset (line 50) | fn namegen_reset() {
  method fmt (line 55) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method fmt (line 183) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method fmt (line 194) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method display (line 212) | pub fn display<'a>(&'a self, def_name: &'a Name) -> impl fmt::Display + ...
  method fmt (line 223) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method fmt (line 231) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method fmt (line 241) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method display_app (line 247) | fn display_app<'a>(&'a self, tag: &'a Tag) -> impl fmt::Display + 'a {
  method fmt (line 260) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method display_padded (line 284) | pub fn display_padded(&self) -> impl fmt::Display + '_ {
  method fmt (line 295) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method display_arrow (line 320) | pub fn display_arrow(&self) -> impl fmt::Display + '_ {
  function var_as_str (line 332) | fn var_as_str(nam: &Option<Name>) -> &str {
  method display_pretty (line 339) | pub fn display_pretty(&self) -> impl fmt::Display + '_ {
  method display_pretty (line 352) | pub fn display_pretty(&self) -> impl fmt::Display + '_ {
  method display_pretty (line 359) | pub fn display_pretty<'a>(&'a self, def_name: &'a Name) -> impl fmt::Dis...
  method display_def_aux (line 368) | pub fn display_def_aux<'a>(&'a self, def_name: &'a Name, tab: usize) -> ...
  method display_pretty (line 380) | pub fn display_pretty(&self, tab: usize) -> impl fmt::Display + '_ {
  method display_app_pretty (line 557) | fn display_app_pretty<'a>(&'a self, tag: &'a Tag, tab: usize) -> impl fm...

FILE: src/fun/load_book.rs
  function load_file_to_book (line 14) | pub fn load_file_to_book(
  function load_to_book (line 31) | pub fn load_to_book(
  function do_parse_book (line 42) | pub fn do_parse_book(code: &str, origin: &Path, mut book: ParseBook) -> ...

FILE: src/fun/mod.rs
  type Ctx (line 29) | pub struct Ctx<'book> {
  function new (line 35) | pub fn new(book: &mut Book, diagnostics_cfg: DiagnosticsConfig) -> Ctx {
  type Book (line 42) | pub struct Book {
    method hvm_entrypoint (line 1226) | pub fn hvm_entrypoint(&self) -> &str {
  type Definitions (line 62) | pub type Definitions = IndexMap<Name, Definition>;
  type HvmDefinitions (line 63) | pub type HvmDefinitions = IndexMap<Name, HvmDefinition>;
  type Adts (line 64) | pub type Adts = IndexMap<Name, Adt>;
  type Constructors (line 65) | pub type Constructors = IndexMap<Name, Name>;
  type Definition (line 69) | pub struct Definition {
    method new_gen (line 1089) | pub fn new_gen(name: Name, rules: Vec<Rule>, source: Source, check: bo...
    method is_builtin (line 1095) | pub fn is_builtin(&self) -> bool {
    method arity (line 1099) | pub fn arity(&self) -> usize {
    method assert_no_pattern_matching_rules (line 1104) | pub fn assert_no_pattern_matching_rules(&self) {
    method rule (line 1110) | pub fn rule(&self) -> &Rule {
    method rule_mut (line 1116) | pub fn rule_mut(&mut self) -> &mut Rule {
  type Source (line 78) | pub struct Source {
    method is_builtin (line 1235) | pub fn is_builtin(&self) -> bool {
    method is_local (line 1239) | pub fn is_local(&self) -> bool {
    method from_file_span (line 1243) | pub fn from_file_span(file: &Name, txt: &str, span: Range<usize>, buil...
  type SourceKind (line 85) | pub enum SourceKind {
  type HvmDefinition (line 100) | pub struct HvmDefinition {
  type Type (line 108) | pub enum Type {
    method subst_ctr (line 1126) | pub fn subst_ctr(&mut self, from: &Name, to: &Name) {
    method children (line 1147) | pub fn children(&self) -> impl Iterator<Item = &Type> {
    method children_mut (line 1159) | pub fn children_mut(&mut self) -> impl Iterator<Item = &mut Type> {
  type Rule (line 125) | pub struct Rule {
    method arity (line 1083) | pub fn arity(&self) -> usize {
  type Term (line 131) | pub enum Term {
    method lam (line 493) | pub fn lam(pat: Pattern, bod: Term) -> Self {
    method tagged_lam (line 498) | pub fn tagged_lam(tag: Tag, pat: Pattern, bod: Term) -> Self {
    method rfold_lams (line 505) | pub fn rfold_lams(term: Term, pats: impl DoubleEndedIterator<Item = Op...
    method var_or_era (line 509) | pub fn var_or_era(nam: Option<Name>) -> Self {
    method app (line 517) | pub fn app(fun: Term, arg: Term) -> Self {
    method tagged_app (line 521) | pub fn tagged_app(tag: Tag, fun: Term, arg: Term) -> Self {
    method call (line 526) | pub fn call(called: Term, args: impl IntoIterator<Item = Term>) -> Self {
    method tagged_call (line 530) | pub fn tagged_call(tag: Tag, called: Term, args: impl IntoIterator<Ite...
    method arg_call (line 535) | pub fn arg_call(fun: Term, arg: Name) -> Self {
    method r#ref (line 539) | pub fn r#ref(name: &str) -> Self {
    method str (line 543) | pub fn str(str: &str) -> Self {
    method sub_num (line 547) | pub fn sub_num(arg: Term, val: Num) -> Term {
    method add_num (line 555) | pub fn add_num(arg: Term, val: Num) -> Term {
    method pattern (line 563) | pub fn pattern(&self) -> Option<&Pattern> {
    method pattern_mut (line 570) | pub fn pattern_mut(&mut self) -> Option<&mut Pattern> {
    method children (line 578) | pub fn children(&self) -> impl DoubleEndedIterator<Item = &Term> + Clo...
    method children_mut (line 614) | pub fn children_mut(&mut self) -> impl DoubleEndedIterator<Item = &mut...
    method children_with_binds (line 658) | pub fn children_with_binds(
    method children_mut_with_binds (line 720) | pub fn children_mut_with_binds(
    method subst (line 794) | pub fn subst(&mut self, from: &Name, to: &Term) {
    method subst_ctrs (line 811) | pub fn subst_ctrs(&mut self, from: &Name, to: &Name) {
    method subst_type_ctrs (line 838) | pub fn subst_type_ctrs(&mut self, from: &Name, to: &Name) {
    method subst_unscoped (line 858) | pub fn subst_unscoped(&mut self, from: &Name, to: &Term) {
    method free_vars (line 876) | pub fn free_vars(&self) -> IndexMap<Name, u64> {
    method unscoped_vars (line 902) | pub fn unscoped_vars(&self) -> (IndexSet<Name>, IndexSet<Name>) {
    method has_unscoped (line 935) | pub fn has_unscoped(&self) -> bool {
  type MatchRule (line 239) | pub type MatchRule = (Option<Name>, Vec<Option<Name>>, Term);
  type FanKind (line 242) | pub enum FanKind {
  type Op (line 248) | pub enum Op {
  type Num (line 272) | pub enum Num {
    method is_zero (line 954) | pub fn is_zero(&self) -> bool {
    method to_bits (line 962) | pub fn to_bits(&self) -> u32 {
    method from_bits (line 970) | pub fn from_bits(bits: u32) -> Self {
  type Pattern (line 279) | pub enum Pattern {
    method from (line 484) | fn from(value: Option<Name>) -> Self {
    method binds (line 995) | pub fn binds(&self) -> impl DoubleEndedIterator<Item = &Option<Name>> ...
    method binds_mut (line 1002) | pub fn binds_mut(&mut self) -> impl DoubleEndedIterator<Item = &mut Op...
    method children (line 1017) | pub fn children(&self) -> impl DoubleEndedIterator<Item = &Pattern> + ...
    method children_mut (line 1025) | pub fn children_mut(&mut self) -> impl DoubleEndedIterator<Item = &mut...
    method iter (line 1035) | pub fn iter(&self) -> impl DoubleEndedIterator<Item = &Pattern> + Clone {
    method is_wildcard (line 1045) | pub fn is_wildcard(&self) -> bool {
    method to_term (line 1049) | pub fn to_term(&self) -> Term {
    method has_unscoped (line 1064) | pub fn has_unscoped(&self) -> bool {
    method has_nested (line 1072) | pub fn has_nested(&self) -> bool {
  type Tag (line 291) | pub enum Tag {
    method adt_name (line 385) | pub fn adt_name(name: &Name) -> Self {
  type Adt (line 301) | pub struct Adt {
  type AdtCtr (line 309) | pub struct AdtCtr {
  type CtrField (line 316) | pub struct CtrField {
  type Name (line 323) | pub struct Name(GlobalString);
    method eq (line 328) | fn eq(&self, other: &str) -> bool {
    method eq (line 334) | fn eq(&self, other: &&str) -> bool {
    method eq (line 340) | fn eq(&self, other: &Option<Name>) -> bool {
    method eq (line 356) | fn eq(&self, other: &Option<&Name>) -> bool {
    method new (line 1173) | pub fn new<'a, V: Into<Cow<'a, str>>>(value: V) -> Name {
    method is_generated (line 1177) | pub fn is_generated(&self) -> bool {
    method def_name_from_generated (line 1182) | pub fn def_name_from_generated(&self) -> Name {
    method from (line 1200) | fn from(value: u64) -> Self {
    method from (line 1206) | fn from(value: u32) -> Self {
    method as_ref (line 1220) | fn as_ref(&self) -> &str {
  function eq (line 350) | fn eq(&self, other: &Name) -> bool {
  function eq (line 366) | fn eq(&self, other: &Name) -> bool {
  function num_to_name (line 371) | pub fn num_to_name(mut num: u64) -> String {
  method clone (line 391) | fn clone(&self) -> Self {
  method drop (line 448) | fn drop(&mut self) {
  method hash (line 981) | fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
  method eq (line 987) | fn eq(&self, other: &Self) -> bool {
  method default (line 1194) | fn default() -> Self {
  type Target (line 1212) | type Target = str;
  method deref (line 1214) | fn deref(&self) -> &Self::Target {
  method default (line 1252) | fn default() -> Self {
  function num_to_from_bits (line 1258) | fn num_to_from_bits() {

FILE: src/fun/net_to_term.rs
  function net_to_term (line 11) | pub fn net_to_term(
  type Scope (line 62) | type Scope = BTreeSet<NodeId>;
  type Reader (line 64) | pub struct Reader<'a> {
  function read_term (line 80) | fn read_term(&mut self, next: Port) -> Term {
  function read_con (line 108) | fn read_con(&mut self, next: Port, label: Option<BendLab>) -> Term {
  function read_fan (line 143) | fn read_fan(&mut self, next: Port, kind: CtrKind) -> Term {
  function read_opr (line 211) | fn read_opr(&mut self, next: Port) -> Term {
  function read_swi (line 424) | fn read_swi(&mut self, next: Port) -> Term {
  function decay_or_get_ports (line 512) | fn decay_or_get_ports(&mut self, node: NodeId) -> Result<Term, (Term, Te...
  function error (line 540) | pub fn error(&mut self, error: ReadbackError) {
  function report_errors (line 544) | pub fn report_errors(&mut self, diagnostics: &mut Diagnostics) {
  function is_tup (line 566) | fn is_tup(&self, node: NodeId) -> bool {
  function num_from_bits_with_type (line 602) | fn num_from_bits_with_type(val: u32, typ: u32) -> Term {
  type Split (line 616) | struct Split {
  method default (line 625) | fn default() -> Self {
  method insert_split (line 647) | fn insert_split(&mut self, split: &mut Split, threshold: usize) -> Optio...
  type NameGen (line 676) | pub struct NameGen {
    method var_name (line 683) | fn var_name(&mut self, var_port: Port) -> Name {
    method decl_name (line 692) | fn decl_name(&mut self, net: &INet, var_port: Port) -> Option<Name> {
    method unique (line 699) | pub fn unique(&mut self) -> Name {
  type ReadbackError (line 709) | pub enum ReadbackError {
    method hash (line 725) | fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
    method fmt (line 731) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method eq (line 717) | fn eq(&self, other: &Self) -> bool {
  method collect_unscoped (line 748) | pub fn collect_unscoped(&self, unscoped: &mut HashSet<Name>, scope: &mut...
  method apply_unscoped (line 781) | pub fn apply_unscoped(&mut self, unscoped: &HashSet<Name>) {
  method apply_unscoped (line 799) | fn apply_unscoped(&mut self, unscoped: &HashSet<Name>) {

FILE: src/fun/parser.rs
  type FunDefinition (line 16) | type FunDefinition = super::Definition;
  type ImpDefinition (line 17) | type ImpDefinition = crate::imp::Definition;
  type ParseBook (line 21) | pub struct ParseBook {
    method contains_def (line 45) | pub fn contains_def(&self, name: &Name) -> bool {
    method contains_builtin_def (line 49) | pub fn contains_builtin_def(&self, name: &Name) -> Option<bool> {
  type ParseResult (line 59) | pub type ParseResult<T> = std::result::Result<T, ParseError>;
  type FunParser (line 61) | pub struct FunParser<'i> {
  function new (line 69) | pub fn new(file: Name, input: &'a str, builtin: bool) -> Self {
  function parse_book (line 75) | pub fn parse_book(&mut self, default_book: ParseBook) -> ParseResult<Par...
  function parse_type_def (line 192) | fn parse_type_def(&mut self) -> ParseResult<Adt> {
  function parse_type_ctr (line 226) | fn parse_type_ctr(&mut self, type_name: &Name, type_vars: &[Name]) -> Pa...
  function parse_type_ctr_field (line 256) | fn parse_type_ctr_field(&mut self) -> ParseResult<CtrField> {
  function parse_fun_def (line 276) | fn parse_fun_def(&mut self) -> ParseResult<FunDefinition> {
  function parse_def_sig (line 325) | fn parse_def_sig(&mut self) -> ParseResult<(Name, Vec<Name>, bool, Type)> {
  function parse_def_sig_arg (line 347) | fn parse_def_sig_arg(&mut self) -> ParseResult<(Name, Type)> {
  function parse_checked (line 362) | fn parse_checked(&mut self, default: bool) -> bool {
  function parse_from_import (line 372) | fn parse_from_import(&mut self) -> ParseResult<Import> {
  function parse_import (line 400) | fn parse_import(&mut self) -> ParseResult<Vec<Import>> {
  function parse_rule_lhs (line 426) | fn parse_rule_lhs(&mut self) -> ParseResult<(Name, Vec<Pattern>)> {
  function parse_rule (line 447) | fn parse_rule(&mut self) -> ParseResult<(Name, Rule)> {
  function starts_with_rule (line 459) | fn starts_with_rule(&mut self, expected_name: &Name) -> bool {
  function parse_pattern (line 482) | fn parse_pattern(&mut self, simple: bool) -> ParseResult<Pattern> {
  function parse_term (line 576) | pub fn parse_term(&mut self) -> ParseResult<Term> {
  function parse_name_or_era (line 961) | fn parse_name_or_era(&mut self) -> ParseResult<Option<Name>> {
  function parse_tag (line 978) | fn parse_tag(&mut self) -> ParseResult<(Option<Tag>, impl FnOnce(&mut Se...
  function parse_match_arg (line 1001) | fn parse_match_arg(&mut self) -> ParseResult<(Option<Name>, Term)> {
  function parse_named_arg (line 1019) | fn parse_named_arg(&mut self) -> ParseResult<(Option<Name>, Term)> {
  function parse_with_clause (line 1032) | fn parse_with_clause(&mut self) -> ParseResult<(Vec<Option<Name>>, Vec<T...
  function parse_match_arm (line 1043) | fn parse_match_arm(&mut self) -> ParseResult<MatchRule> {
  function parse_type_term (line 1052) | fn parse_type_term(&mut self) -> ParseResult<Type> {
  function parse_type_atom (line 1064) | fn parse_type_atom(&mut self) -> ParseResult<Type> {
  function add_fun_def (line 1121) | fn add_fun_def(&mut self, def: FunDefinition, book: &mut ParseBook, span...
  function add_imp_def (line 1127) | fn add_imp_def(
  function add_hvm (line 1138) | fn add_hvm(&mut self, def: HvmDefinition, book: &mut ParseBook, span: Ra...
  function add_type_def (line 1144) | fn add_type_def(&mut self, adt: Adt, book: &mut ParseBook, span: Range<u...
  function check_top_level_redefinition (line 1163) | fn check_top_level_redefinition(
  function check_type_redefinition (line 1184) | fn check_type_redefinition(
  function input (line 1199) | fn input(&mut self) -> &'a str {
  function index (line 1203) | fn index(&mut self) -> &mut usize {
  function expected (line 1210) | fn expected<T>(&mut self, exp: &str) -> ParseResult<T> {
  function expected_and (line 1219) | fn expected_and<T>(&mut self, exp: &str, msg: &str) -> ParseResult<T> {
  function consume (line 1228) | fn consume(&mut self, text: &str) -> ParseResult<()> {
  function skip_trivia (line 1238) | fn skip_trivia(&mut self) {
  function is_name_char (line 1277) | pub fn is_name_char(c: char) -> bool {
  function is_num_char (line 1281) | pub fn is_num_char(c: char) -> bool {
  function make_fn_type (line 1285) | pub fn make_fn_type(args: Vec<Type>, ret: Type) -> Type {
  function make_ctr_type (line 1289) | pub fn make_ctr_type(type_name: Name, fields: &[Type], vars: &[Name]) ->...
  type Indent (line 1296) | pub enum Indent {
    method new (line 1302) | pub fn new(val: isize) -> Self {
    method enter_level (line 1306) | pub fn enter_level(&mut self) {
    method exit_level (line 1312) | pub fn exit_level(&mut self) {
  type ParserCommons (line 1321) | pub trait ParserCommons<'a>: Parser<'a> {
    method labelled (line 1322) | fn labelled<T>(&mut self, parser: impl Fn(&mut Self) -> ParseResult<T>...
    method parse_restricted_name (line 1329) | fn parse_restricted_name(&mut self, kind: &str) -> ParseResult<Name> {
    method parse_top_level_name (line 1348) | fn parse_top_level_name(&mut self) -> ParseResult<Name> {
    method parse_var_name (line 1352) | fn parse_var_name(&mut self) -> ParseResult<Name> {
    method parse_name_maybe_alias (line 1356) | fn parse_name_maybe_alias(&mut self, label: &str) -> ParseResult<(Name...
    method parse_import_name (line 1368) | fn parse_import_name(&mut self, label: &str) -> ParseResult<(Name, Opt...
    method consume_exactly (line 1375) | fn consume_exactly(&mut self, text: &str) -> ParseResult<()> {
    method consume_new_line (line 1384) | fn consume_new_line(&mut self) -> ParseResult<()> {
    method advance_newlines (line 1391) | fn advance_newlines(&mut self) -> ParseResult<Indent> {
    method advance_trivia_inline (line 1409) | fn advance_trivia_inline(&mut self) -> ParseResult<isize> {
    method skip_trivia_inline (line 1461) | fn skip_trivia_inline(&mut self) -> ParseResult<()> {
    method expected_spanned (line 1466) | fn expected_spanned<T>(&mut self, exp: &str, span: Range<usize>) -> Pa...
    method expected_spanned_and (line 1474) | fn expected_spanned_and<T>(&mut self, exp: &str, msg: &str, span: Rang...
    method err_msg_spanned (line 1485) | fn err_msg_spanned<T>(&mut self, msg: &str, span: Range<usize>) -> Par...
    method with_ctx (line 1493) | fn with_ctx<T>(&mut self, res: Result<T, impl std::fmt::Display>, span...
    method try_consume (line 1502) | fn try_consume(&mut self, text: &str) -> bool {
    method try_consume_exactly (line 1513) | fn try_consume_exactly(&mut self, text: &str) -> bool {
    method try_parse_keyword (line 1522) | fn try_parse_keyword(&mut self, keyword: &str) -> bool {
    method parse_keyword (line 1531) | fn parse_keyword(&mut self, keyword: &str) -> ParseResult<()> {
    method starts_with_keyword (line 1544) | fn starts_with_keyword(&mut self, keyword: &str) -> bool {
    method list_like (line 1563) | fn list_like<T>(
    method try_parse_oper (line 1600) | fn try_parse_oper(&mut self) -> Option<Op> {
    method peek_oper (line 1641) | fn peek_oper(&mut self) -> Option<Op> {
    method parse_u32 (line 1682) | fn parse_u32(&mut self) -> ParseResult<u32> {
    method u32_with_radix (line 1706) | fn u32_with_radix(&mut self, radix: Radix) -> ParseResult<u32> {
    method parse_number (line 1718) | fn parse_number(&mut self) -> ParseResult<Num> {
    method num_range_err (line 1770) | fn num_range_err<T>(&mut self, ini_idx: usize, typ: &str) -> ParseResu...
    method parse_quoted_symbol (line 1778) | fn parse_quoted_symbol(&mut self) -> ParseResult<u32> {
    method check_repeated_ctr_fields (line 1803) | fn check_repeated_ctr_fields(
    method redefinition_of_function_msg (line 1819) | fn redefinition_of_function_msg(builtin: bool, function_name: &str) ->...
    method redefinition_of_hvm_msg (line 1827) | fn redefinition_of_hvm_msg(builtin: bool, function_name: &str) -> Stri...
    method redefinition_of_constructor_msg (line 1835) | fn redefinition_of_constructor_msg(constructor_name: &str) -> String {
    method redefinition_of_type_msg (line 1843) | fn redefinition_of_type_msg(type_name: &str) -> String {
  type Radix (line 1853) | pub enum Radix {
    method to_f32 (line 1860) | fn to_f32(self) -> f32 {
    method fmt (line 1870) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: src/fun/term_to_net.rs
  type ViciousCycleErr (line 16) | pub struct ViciousCycleErr;
  function book_to_hvm (line 18) | pub fn book_to_hvm(book: &Book, diags: &mut Diagnostics) -> Result<(hvm:...
  function term_to_hvm (line 55) | pub fn term_to_hvm(term: &Term, labels: &mut Labels) -> Result<Net, Stri...
  type EncodeTermState (line 82) | struct EncodeTermState<'t, 'l> {
  function count_nodes (line 92) | fn count_nodes(tree: &Tree) -> usize {
  type Place (line 99) | enum Place<'t> {
  function encode_term (line 111) | fn encode_term(&mut self, term: &'t Term, up: Place<'t>) {
  function encode_le_ge_opers (line 251) | fn encode_le_ge_opers(&mut self, opr: &Op, up: Place<'t>, node: Place<'t...
  function encode_pat (line 265) | fn encode_pat(&mut self, pat: &Pattern, up: Place<'t>) {
  function link (line 278) | fn link(&mut self, a: Place<'t>, b: Place<'t>) {
  function new_ctr (line 305) | fn new_ctr(&mut self, kind: CtrKind) -> (Place<'t>, Place<'t>, Place<'t>) {
  function new_opr (line 321) | fn new_opr(&mut self) -> (Place<'t>, Place<'t>, Place<'t>) {
  function make_node_list (line 332) | fn make_node_list(
  function new_wire (line 348) | fn new_wire(&mut self) -> usize {
  function fan_kind (line 354) | fn fan_kind(&mut self, fan: &FanKind, tag: &crate::fun::Tag) -> CtrKind {
  function link_var (line 363) | fn link_var(&mut self, global: bool, name: &Name, place: Place<'t>) {
  type Labels (line 377) | pub struct Labels {
    type Output (line 391) | type Output = LabelGenerator;
    method index (line 393) | fn index(&self, fan: FanKind) -> &Self::Output {
    method index_mut (line 402) | fn index_mut(&mut self, fan: FanKind) -> &mut Self::Output {
  type LabelGenerator (line 384) | pub struct LabelGenerator {
    method generate (line 413) | fn generate(&mut self, tag: &crate::fun::Tag) -> Option<u16> {
    method to_tag (line 433) | pub fn to_tag(&self, label: Option<u16>) -> crate::fun::Tag {
    method finish (line 450) | fn finish(&mut self) {
  method to_native_tag (line 457) | fn to_native_tag(self) -> hvm::hvm::Tag {
  function flip_sym (line 482) | fn flip_sym(tag: hvm::hvm::Tag) -> hvm::hvm::Tag {

FILE: src/fun/transform/apply_args.rs
  function apply_args (line 17) | pub fn apply_args(&mut self, args: Option<Vec<Term>>) -> Result<(), Diag...

FILE: src/fun/transform/definition_merge.rs
  constant MERGE_SEPARATOR (line 9) | pub const MERGE_SEPARATOR: &str = "__M_";
  method merge_definitions (line 17) | pub fn merge_definitions(&mut self) {
  method merge (line 24) | fn merge(&mut self, defs: impl Iterator<Item = Name>) {
  method collect_terms (line 67) | fn collect_terms(&mut self, def_entries: impl Iterator<Item = Name>) -> ...
  method update_refs (line 79) | fn update_refs(&mut self, name_map: &BTreeMap<Name, Name>) {
  method subst_ref_to_ref (line 97) | pub fn subst_ref_to_ref(term: &mut Term, ref_map: &BTreeMap<Name, Name>)...

FILE: src/fun/transform/definition_pruning.rs
  type Used (line 10) | enum Used {
  type Definitions (line 19) | type Definitions = HashMap<Name, Used>;
  function prune (line 26) | pub fn prune(&mut self, prune_all: bool) {
  method find_used_definitions_from_term (line 113) | fn find_used_definitions_from_term(&self, term: &Term, used: Used, uses:...
  method find_used_definitions_from_hvm_net (line 138) | fn find_used_definitions_from_hvm_net(&self, net: &Net, used: Used, uses...
  method insert_used (line 161) | fn insert_used(&self, def_name: &Name, used: Used, uses: &mut Definition...

FILE: src/fun/transform/desugar_bend.rs
  constant RECURSIVE_KW (line 8) | pub const RECURSIVE_KW: &str = "fork";
  constant NEW_FN_SEP (line 9) | const NEW_FN_SEP: &str = "__bend";
  function desugar_bend (line 12) | pub fn desugar_bend(&mut self) -> Result<(), Diagnostics> {
  method desugar_bend (line 33) | fn desugar_bend(

FILE: src/fun/transform/desugar_fold.rs
  function desugar_fold (line 30) | pub fn desugar_fold(&mut self) -> Result<(), Diagnostics> {
  type DesugarFoldCtx (line 58) | struct DesugarFoldCtx<'a> {
  method desugar_fold (line 69) | fn desugar_fold(&mut self, ctx: &mut DesugarFoldCtx<'_>) -> Result<(), S...
  method call_recursive (line 145) | fn call_recursive(&mut self, def_name: &Name, recursive: &HashSet<Name>,...

FILE: src/fun/transform/desugar_match_defs.rs
  type DesugarMatchDefErr (line 9) | pub enum DesugarMatchDefErr {
    method fmt (line 637) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function desugar_match_defs (line 19) | pub fn desugar_match_defs(&mut self) -> Result<(), Diagnostics> {
  method desugar_match_def (line 50) | pub fn desugar_match_def(&mut self, ctrs: &Constructors, adts: &Adts) ->...
  function desugar_inner_match_defs (line 83) | fn desugar_inner_match_defs(
  function fix_repeated_binds (line 112) | fn fix_repeated_binds(rules: &mut [Rule]) -> Vec<DesugarMatchDefErr> {
  function simplify_rule_match (line 151) | fn simplify_rule_match(
  function irrefutable_fst_row_rule (line 179) | fn irrefutable_fst_row_rule(args: Vec<Name>, rule: Rule, idx: usize, use...
  function var_rule (line 205) | fn var_rule(
  function fan_rule (line 255) | fn fan_rule(
  function num_rule (line 309) | fn num_rule(
  function fast_pred_access (line 422) | fn fast_pred_access(body: &mut Term, cur_num: u32, var: &Name, pred_var:...
  function switch_rule (line 490) | fn switch_rule(
  type Type (line 572) | pub enum Type {
    method infer_from_def_arg (line 585) | fn infer_from_def_arg(
    method fmt (line 625) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method to_type (line 609) | fn to_type(&self, ctrs: &Constructors) -> Type {

FILE: src/fun/transform/desugar_open.rs
  function desugar_open (line 8) | pub fn desugar_open(&mut self) -> Result<(), Diagnostics> {
  method desugar_open (line 22) | fn desugar_open(&mut self, adts: &Adts) -> Result<(), String> {

FILE: src/fun/transform/desugar_use.rs
  method desugar_use (line 17) | pub fn desugar_use(&mut self) {
  method desugar_ctr_use (line 26) | pub fn desugar_ctr_use(&mut self) {
  method desugar_use (line 36) | pub fn desugar_use(&mut self) {
  method desugar_ctr_use (line 49) | pub fn desugar_ctr_use(&mut self) {

FILE: src/fun/transform/desugar_with_blocks.rs
  function desugar_with_blocks (line 10) | pub fn desugar_with_blocks(&mut self) -> Result<(), Diagnostics> {
  method desugar_with_blocks (line 26) | pub fn desugar_with_blocks(
  method defer (line 70) | fn defer(self) -> Term {

FILE: src/fun/transform/encode_adts.rs
  method encode_adts (line 8) | pub fn encode_adts(&mut self, adt_encoding: AdtEncoding) {
  function encode_ctr_scott (line 39) | fn encode_ctr_scott<'a>(
  function encode_ctr_num_scott (line 50) | fn encode_ctr_num_scott<'a>(ctr_args: impl DoubleEndedIterator<Item = &'...
  function encode_num_scott_tag (line 61) | fn encode_num_scott_tag(tag: u32, ctr_name: &Name, source: Source) -> De...

FILE: src/fun/transform/encode_match_terms.rs
  method encode_matches (line 13) | pub fn encode_matches(&mut self, adt_encoding: AdtEncoding) {
  method encode_matches (line 23) | pub fn encode_matches(&mut self, adt_encoding: AdtEncoding) {
  function encode_match (line 47) | fn encode_match(arg: Term, rules: Vec<MatchRule>, adt_encoding: AdtEncod...
  function encode_switch (line 97) | fn encode_switch(arg: Term, pred: Option<Name>, mut rules: Vec<Term>) ->...

FILE: src/fun/transform/expand_generated.rs
  method expand_generated (line 11) | pub fn expand_generated(&mut self, book: &Book, recursive_defs: &Recursi...
  type DepGraph (line 26) | type DepGraph = HashMap<Name, HashSet<Name>>;
  type Cycles (line 27) | type Cycles = Vec<Vec<Name>>;
  type RecursiveDefs (line 28) | type RecursiveDefs = BTreeSet<Name>;
  method recursive_defs (line 31) | pub fn recursive_defs(&self) -> RecursiveDefs {
  function cycles (line 47) | fn cycles(deps: &DepGraph) -> Cycles {
  function find_cycles (line 59) | fn find_cycles(deps: &DepGraph, nam: &Name, visited: &mut HashSet<Name>,...
  function book_def_deps (line 86) | fn book_def_deps(book: &Book) -> DepGraph {
  function def_deps (line 90) | fn def_deps(def: &crate::fun::Definition) -> HashSet<Name> {

FILE: src/fun/transform/expand_main.rs
  method expand_main (line 10) | pub fn expand_main(&mut self) {
  method expand_ref_return (line 38) | fn expand_ref_return(&mut self, book: &Book, seen: &mut Vec<Name>, globa...
  method expand_floated_combinators (line 104) | fn expand_floated_combinators(&mut self, book: &Book) {
  method multi_arg_app (line 118) | fn multi_arg_app(&mut self) -> (&mut Term, Vec<&mut Term>) {
  method rename_unscoped (line 138) | fn rename_unscoped(&mut self, unscoped_count: &mut usize, unscoped_map: ...
  method rename_unscoped (line 153) | fn rename_unscoped(&mut self, unscoped_count: &mut usize, unscoped_map: ...
  function rename_unscoped (line 169) | fn rename_unscoped(nam: &mut Name, unscoped_count: &mut usize, unscoped_...

FILE: src/fun/transform/fix_match_defs.rs
  function fix_match_defs (line 10) | pub fn fix_match_defs(&mut self) -> Result<(), Diagnostics> {
  method fix_match_defs (line 29) | fn fix_match_defs(&mut self, def_arity: usize, ctrs: &Constructors, adts...
  method fix_match_defs (line 48) | fn fix_match_defs(&mut self, ctrs: &Constructors, adts: &Adts, errs: &mu...
  method resolve_pat (line 68) | fn resolve_pat(&mut self, ctrs: &Constructors) {
  method check_good_ctr (line 80) | fn check_good_ctr(&self, ctrs: &Constructors, adts: &Adts, errs: &mut Ve...

FILE: src/fun/transform/fix_match_terms.rs
  type FixMatchErr (line 8) | enum FixMatchErr {
    method fmt (line 281) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function fix_match_terms (line 48) | pub fn fix_match_terms(&mut self) -> Result<(), Diagnostics> {
  method fix_match_terms (line 86) | fn fix_match_terms(&mut self, ctrs: &Constructors, adts: &Adts) -> Vec<F...
  method fix_match (line 145) | fn fix_match(&mut self, errs: &mut Vec<FixMatchErr>, ctrs: &Constructors...
  function fixed_match_arms (line 214) | fn fixed_match_arms<'a>(
  function match_field (line 270) | fn match_field(arg: &Name, field: &Name) -> Name {
  function rebuild_ctr (line 274) | fn rebuild_ctr(arg: &Name, ctr: &Name, fields: &[CtrField]) -> Term {

FILE: src/fun/transform/float_combinators.rs
  constant NAME_SEP (line 7) | pub const NAME_SEP: &str = "__C";
  method float_combinators (line 33) | pub fn float_combinators(&mut self, max_size: usize) {
  type FloatCombinatorsCtx (line 59) | struct FloatCombinatorsCtx<'b> {
  function new (line 69) | fn new(book: &'b Book, max_size: usize) -> Self {
  function reset (line 80) | fn reset(&mut self) {
  method float_combinators (line 88) | fn float_combinators(
  method float (line 121) | fn float(
  method is_safe (line 150) | fn is_safe(&self, ctx: &mut FloatCombinatorsCtx) -> bool {
  method is_safe_lambda (line 192) | fn is_safe_lambda(&self, ctx: &mut FloatCombinatorsCtx) -> bool {
  method has_unscoped_diff (line 208) | pub fn has_unscoped_diff(&self) -> bool {
  method is_combinator (line 213) | fn is_combinator(&self) -> bool {
  method base_size (line 217) | fn base_size(&self) -> usize {
  method size (line 245) | fn size(&self) -> usize {
  method float_children_mut (line 252) | pub fn float_children_mut(&mut self) -> impl Iterator<Item = &mut Term> {
  method size (line 299) | fn size(&self) -> usize {

FILE: src/fun/transform/lift_local_defs.rs
  method lift_local_defs (line 11) | pub fn lift_local_defs(&mut self) {
  method binds (line 24) | pub fn binds(&self) -> impl DoubleEndedIterator<Item = &Option<Name>> + ...
  method lift_local_defs (line 30) | pub fn lift_local_defs(
  function gen_use (line 67) | fn gen_use(
  function apply_closure (line 101) | fn apply_closure(rules: &mut [Rule], fvs: &BTreeSet<Name>) {

FILE: src/fun/transform/linearize_matches.rs
  method linearize_match_binds (line 26) | pub fn linearize_match_binds(&mut self) {
  method linearize_match_binds (line 38) | pub fn linearize_match_binds(&mut self) {
  method linearize_match_binds_go (line 42) | fn linearize_match_binds_go(&mut self, mut bind_terms: Vec<Term>) {
  method linearize_binds_single_match (line 83) | fn linearize_binds_single_match(&mut self, mut bind_terms: Vec<Term>) {
  method wrap_with_bind_terms (line 163) | fn wrap_with_bind_terms(
  function fixed_and_linearized_terms (line 207) | fn fixed_and_linearized_terms(used_in_arg: HashSet<Name>, bind_terms: Ve...
  function binds_fixed_by_dependency (line 235) | fn binds_fixed_by_dependency(used_in_arg: HashSet<Name>, bind_terms: &[T...
  function update_with_clause (line 341) | fn update_with_clause(
  method linearize_matches (line 363) | pub fn linearize_matches(&mut self) {
  method linearize_matches (line 373) | fn linearize_matches(&mut self) {
  function lift_match_vars (line 393) | pub fn lift_match_vars(match_term: &mut Term) -> &mut Term {
  function get_match_reference (line 463) | fn get_match_reference(mut match_term: &mut Term) -> &mut Term {
  method linearize_match_with (line 477) | pub fn linearize_match_with(&mut self) {
  method linearize_match_with (line 487) | fn linearize_match_with(&mut self) {

FILE: src/fun/transform/linearize_vars.rs
  method linearize_vars (line 20) | pub fn linearize_vars(&mut self) {
  method linearize_vars (line 28) | pub fn linearize_vars(&mut self) {
  function term_to_linear (line 33) | fn term_to_linear(term: &mut Term, var_uses: &mut HashMap<Name, u64>) {
  function get_var_uses (line 95) | fn get_var_uses(nam: Option<&Name>, var_uses: &HashMap<Name, u64>) -> u64 {
  function duplicate_pat (line 99) | fn duplicate_pat(nam: &Name, uses: u64) -> Box<Pattern> {
  function dup_name (line 107) | fn dup_name(nam: &Name, uses: u64) -> Name {
  method children_mut_with_binds_mut (line 118) | pub fn children_mut_with_binds_mut(

FILE: src/fun/transform/resolve_refs.rs
  type ReferencedMainErr (line 9) | pub struct ReferencedMainErr;
  function resolve_refs (line 20) | pub fn resolve_refs(&mut self) -> Result<(), Diagnostics> {
  method resolve_refs (line 42) | pub fn resolve_refs<'a>(
  function push_scope (line 96) | fn push_scope<'a>(name: Option<&'a Name>, scope: &mut HashMap<&'a Name, ...
  function pop_scope (line 103) | fn pop_scope<'a>(name: Option<&'a Name>, scope: &mut HashMap<&'a Name, u...
  function is_var_in_scope (line 110) | fn is_var_in_scope<'a>(name: &'a Name, scope: &HashMap<&'a Name, usize>)...

FILE: src/fun/transform/resolve_type_ctrs.rs
  function resolve_type_ctrs (line 9) | pub fn resolve_type_ctrs(&mut self) -> Result<(), Diagnostics> {
  method resolve_type_ctrs (line 33) | pub fn resolve_type_ctrs(&mut self, adts: &Adts) -> Result<(), String> {

FILE: src/fun/transform/resugar_list.rs
  method resugar_lists (line 8) | pub fn resugar_lists(&mut self, adt_encoding: AdtEncoding) {
  method resugar_lists_num_scott (line 16) | fn resugar_lists_num_scott(&mut self) {
  method resugar_lists_scott (line 80) | fn resugar_lists_scott(&mut self) {
  function build_list_num_scott (line 147) | fn build_list_num_scott(term: &mut Term, mut l: Vec<Box<Term>>) -> Resul...
  function build_list_scott (line 209) | fn build_list_scott(term: &mut Term, mut l: Vec<Box<Term>>) -> Result<Ve...

FILE: src/fun/transform/resugar_string.rs
  method resugar_strings (line 8) | pub fn resugar_strings(&mut self, adt_encoding: AdtEncoding) {
  method try_resugar_strings_with (line 16) | fn try_resugar_strings_with(&mut self, extract_fn: fn(&Term) -> Option<(...
  method try_resugar_strings_nil (line 28) | fn try_resugar_strings_nil(&mut self) -> bool {
  method try_resugar_strings_cons (line 33) | fn try_resugar_strings_cons(&mut self, extract_fn: fn(&Term) -> Option<(...
  method try_resugar_strings_cons_with (line 42) | fn try_resugar_strings_cons_with(&self, extract_fn: fn(&Term) -> Option<...
  method try_resugar_strings_cons_common (line 48) | fn try_resugar_strings_cons_common(&self) -> Option<String> {
  method build_strings_common (line 65) | fn build_strings_common(
  method resugar_strings_scott (line 89) | fn resugar_strings_scott(term: &Term) -> Option<(char, &Term)> {
  method resugar_strings_num_scott (line 115) | fn resugar_strings_num_scott(term: &Term) -> Option<(char, &Term)> {
  method extract_strings_common (line 142) | fn extract_strings_common(term: &Term) -> Option<(char, &Term)> {

FILE: src/fun/transform/unique_names.rs
  method make_var_names_unique (line 13) | pub fn make_var_names_unique(&mut self) {
  method make_var_names_unique (line 21) | pub fn make_var_names_unique(&mut self) {
  type VarId (line 26) | type VarId = u64;
  type UniqueNameGenerator (line 29) | pub struct UniqueNameGenerator {
    method unique_names_in_term (line 36) | pub fn unique_names_in_term(&mut self, term: &mut Term) {
    method push (line 169) | fn push(&mut self, nam: Option<&Name>) {
    method pop (line 180) | fn pop(&mut self, nam: Option<&Name>) -> Option<Name> {
    method use_var (line 192) | fn use_var(&self, nam: &Name) -> Name {

FILE: src/hvm/add_recursive_priority.rs
  function add_recursive_priority (line 6) | pub fn add_recursive_priority(book: &mut Book) {
  function add_priority_next_in_cycle (line 23) | fn add_priority_next_in_cycle(net: &mut Net, nxt: &String) {
  type DepGraph (line 57) | type DepGraph = HashMap<String, HashSet<String>>;
  type Cycles (line 58) | type Cycles = Vec<Vec<String>>;
  function cycles (line 61) | pub fn cycles(deps: &DepGraph) -> Cycles {
  function find_cycles (line 73) | fn find_cycles(
  function dependencies (line 104) | fn dependencies(net: &Net) -> HashSet<String> {
  function dependencies_tree (line 114) | fn dependencies_tree(tree: &Tree, deps: &mut HashSet<String>) {

FILE: src/hvm/check_net_size.rs
  constant MAX_NET_SIZE_C (line 5) | pub const MAX_NET_SIZE_C: usize = 4095;
  constant MAX_NET_SIZE_CUDA (line 6) | pub const MAX_NET_SIZE_CUDA: usize = 64;
  function check_net_sizes (line 8) | pub fn check_net_sizes(
  function count_nodes (line 32) | pub fn count_nodes(net: &Net) -> usize {

FILE: src/hvm/eta_reduce.rs
  function eta_reduce_hvm_net (line 64) | pub fn eta_reduce_hvm_net(net: &mut Net) {
  type NodeType (line 76) | enum NodeType {
  type Phase1 (line 85) | struct Phase1<'a> {
  function walk_tree (line 91) | fn walk_tree(&mut self, tree: &'a Tree) {
  type Phase2 (line 124) | struct Phase2 {
    method reduce_ctr (line 130) | fn reduce_ctr(&mut self, tree: &mut Tree, idx: usize) -> NodeType {
    method reduce_tree (line 156) | fn reduce_tree(&mut self, tree: &mut Tree) -> NodeType {

FILE: src/hvm/inline.rs
  function inline_hvm_book (line 7) | pub fn inline_hvm_book(book: &mut Book) -> Result<HashSet<String>, Strin...
  type InlineState (line 24) | struct InlineState {
    method populate_inlinees (line 29) | fn populate_inlinees(&mut self, book: &Book) -> Result<(), String> {
    method inline_into (line 58) | fn inline_into(&self, tree: &mut Tree) -> bool {
  function should_inline (line 73) | fn should_inline(net: &Net) -> bool {

FILE: src/hvm/mod.rs
  function tree_children (line 11) | pub fn tree_children(tree: &Tree) -> impl DoubleEndedIterator<Item = &Tr...
  function tree_children_mut (line 21) | pub fn tree_children_mut(tree: &mut Tree) -> impl DoubleEndedIterator<It...
  function net_trees (line 31) | pub fn net_trees(net: &Net) -> impl DoubleEndedIterator<Item = &Tree> + ...
  function net_trees_mut (line 35) | pub fn net_trees_mut(net: &mut Net) -> impl DoubleEndedIterator<Item = &...
  function hvm_book_show_pretty (line 39) | pub fn hvm_book_show_pretty(book: &hvm::ast::Book) -> String {

FILE: src/hvm/mutual_recursion.rs
  type Ref (line 11) | type Ref = String;
  type Stack (line 12) | type Stack<T> = Vec<T>;
  type RefSet (line 13) | type RefSet = IndexSet<Ref>;
  type Graph (line 16) | pub struct Graph(IndexMap<Ref, RefSet>);
    method cycles (line 60) | pub fn cycles(&self) -> Vec<Vec<Ref>> {
    method find_cycles (line 74) | fn find_cycles(
    method from (line 120) | fn from(book: &Book) -> Self {
    method new (line 143) | pub fn new() -> Self {
    method add (line 147) | pub fn add(&mut self, r#ref: Ref, dependency: Ref) {
    method get (line 152) | pub fn get(&self, r#ref: &Ref) -> Option<&RefSet> {
  function check_cycles (line 18) | pub fn check_cycles(book: &Book, diagnostics: &mut Diagnostics) -> Resul...
  function show_cycles (line 29) | fn show_cycles(mut cycles: Vec<Vec<Ref>>) -> String {
  function collect_refs (line 107) | fn collect_refs(current: Ref, tree: &Tree, graph: &mut Graph) {
  method fmt (line 158) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function combinations_from_merges (line 163) | fn combinations_from_merges(cycle: Vec<Ref>) -> Vec<Vec<Ref>> {

FILE: src/hvm/prune.rs
  function prune_hvm_book (line 6) | pub fn prune_hvm_book(book: &mut Book, entrypoints: &[String]) {
  type PruneState (line 17) | struct PruneState<'a> {
  function visit_def (line 23) | fn visit_def(&mut self, name: &str) {
  function visit_tree (line 30) | fn visit_tree(&mut self, tree: &Tree) {

FILE: src/imp/gen_map_get.rs
  method gen_map_get (line 10) | pub fn gen_map_get(&mut self) {
  method gen_map_get (line 16) | fn gen_map_get(&mut self, id: &mut usize) {
  type Substitutions (line 149) | type Substitutions = Vec<(Name, Name, Box<Expr>)>;
  method substitute_map_gets (line 152) | fn substitute_map_gets(&mut self, id: &mut usize) -> Substitutions {
  function gen_get (line 215) | fn gen_get(current: &mut Stmt, substitutions: Substitutions) -> Stmt {
  function gen_map_var (line 230) | fn gen_map_var(id: &mut usize) -> Name {

FILE: src/imp/mod.rs
  type Expr (line 10) | pub enum Expr {
  type MatchArm (line 48) | pub struct MatchArm {
  type AssignPattern (line 54) | pub enum AssignPattern {
  type InPlaceOp (line 71) | pub enum InPlaceOp {
    method to_lang_op (line 215) | pub fn to_lang_op(self) -> Op {
  type Stmt (line 83) | pub enum Stmt {
  type Definition (line 205) | pub struct Definition {

FILE: src/imp/order_kwargs.rs
  method order_kwargs (line 10) | pub fn order_kwargs(&mut self, book: &ParseBook) -> Result<(), String> {
  method order_kwargs (line 17) | fn order_kwargs(&mut self, book: &ParseBook, use_map: &mut IndexMap<Name...
  method order_kwargs (line 112) | fn order_kwargs(&mut self, book: &ParseBook, use_map: &mut IndexMap<Name...
  function go_order_kwargs (line 188) | fn go_order_kwargs(
  function get_args_def_or_ctr (line 213) | fn get_args_def_or_ctr(name: &Name, book: &ParseBook, use_map: &IndexMap...

FILE: src/imp/parser.rs
  type ImpParser (line 11) | pub struct ImpParser<'i> {
  function new (line 19) | pub fn new(file: Name, input: &'a str, builtin: bool) -> Self {
  function parse_function_def (line 23) | pub fn parse_function_def(&mut self, indent: Indent) -> ParseResult<(Def...
  function parse_type_def (line 37) | pub fn parse_type_def(&mut self, mut indent: Indent) -> ParseResult<(Adt...
  function parse_object (line 81) | pub fn parse_object(&mut self, indent: Indent) -> ParseResult<(Adt, Inde...
  function parse_hvm (line 127) | pub fn parse_hvm(&mut self) -> ParseResult<(HvmDefinition, Indent)> {
  function parse_type_def_variant (line 155) | fn parse_type_def_variant(&mut self, type_name: &Name, type_vars: &[Name...
  function parse_variant_field (line 174) | fn parse_variant_field(&mut self) -> ParseResult<CtrField> {
  function parse_primary_expr (line 186) | fn parse_primary_expr(&mut self, inline: bool) -> ParseResult<Expr> {
  function call_or_postfix (line 252) | fn call_or_postfix(&mut self, inline: bool) -> ParseResult<Expr> {
  function parse_map_or_sup (line 322) | fn parse_map_or_sup(&mut self) -> ParseResult<Expr> {
  function parse_map_init (line 339) | fn parse_map_init(&mut self, head: Expr) -> ParseResult<Expr> {
  function parse_sup (line 352) | fn parse_sup(&mut self, head: Expr) -> ParseResult<Expr> {
  function parse_tree_node (line 359) | fn parse_tree_node(&mut self) -> ParseResult<Expr> {
  function parse_tree_leaf (line 369) | fn parse_tree_leaf(&mut self, inline: bool) -> ParseResult<Expr> {
  function data_kwarg (line 375) | fn data_kwarg(&mut self) -> ParseResult<(Name, Expr)> {
  function parse_map_entry (line 383) | fn parse_map_entry(&mut self) -> ParseResult<(Expr, Expr)> {
  function parse_list_or_comprehension (line 390) | fn parse_list_or_comprehension(&mut self) -> ParseResult<Expr> {
  function parse_expr (line 431) | fn parse_expr(&mut self, inline: bool, tup: bool) -> ParseResult<Expr> {
  function parse_named_arg (line 472) | fn parse_named_arg(&mut self) -> ParseResult<(Option<Name>, Expr)> {
  function parse_infix_expr (line 491) | fn parse_infix_expr(&mut self, prec: usize, inline: bool) -> ParseResult...
  function consume_indent_at_most (line 521) | fn consume_indent_at_most(&mut self, expected: Indent) -> ParseResult<In...
  function consume_indent_exactly (line 530) | fn consume_indent_exactly(&mut self, expected: Indent) -> ParseResult<()> {
  function parse_statement (line 540) | fn parse_statement(&mut self, indent: &mut Indent) -> ParseResult<(Stmt,...
  function parse_assign (line 572) | fn parse_assign(&mut self, indent: &mut Indent) -> ParseResult<(Stmt, In...
  function parse_in_place_op (line 633) | fn parse_in_place_op(&mut self) -> ParseResult<Option<InPlaceOp>> {
  function parse_return (line 665) | fn parse_return(&mut self) -> ParseResult<(Stmt, Indent)> {
  function parse_if (line 680) | fn parse_if(&mut self, indent: &mut Indent) -> ParseResult<(Stmt, Indent...
  function parse_match (line 746) | fn parse_match(&mut self, indent: &mut Indent) -> ParseResult<(Stmt, Ind...
  function parse_match_arg (line 776) | fn parse_match_arg(&mut self) -> ParseResult<(Option<Name>, Expr)> {
  function parse_with_clause (line 793) | fn parse_with_clause(&mut self) -> ParseResult<(Vec<Option<Name>>, Vec<E...
  function parse_with_arg (line 804) | fn parse_with_arg(&mut self) -> ParseResult<(Option<Name>, Expr)> {
  function parse_match_case (line 815) | fn parse_match_case(&mut self, indent: &mut Indent) -> ParseResult<(Matc...
  function parse_switch (line 837) | fn parse_switch(&mut self, indent: &mut Indent) -> ParseResult<(Stmt, In...
  function parse_switch_case (line 888) | fn parse_switch_case(&mut self, indent: &mut Indent) -> ParseResult<(Opt...
  function parse_fold (line 918) | fn parse_fold(&mut self, indent: &mut Indent) -> ParseResult<(Stmt, Inde...
  function parse_bend (line 955) | fn parse_bend(&mut self, indent: &mut Indent) -> ParseResult<(Stmt, Inde...
  function parse_with (line 1022) | fn parse_with(&mut self, indent: &mut Indent) -> ParseResult<(Stmt, Inde...
  function parse_assign_pattern (line 1050) | fn parse_assign_pattern(&mut self) -> ParseResult<AssignPattern> {
  function parse_primary_assign_pattern (line 1082) | fn parse_primary_assign_pattern(&mut self) -> ParseResult<AssignPattern> {
  function parse_open (line 1105) | fn parse_open(&mut self, indent: &mut Indent) -> ParseResult<(Stmt, Inde...
  function parse_use (line 1128) | fn parse_use(&mut self, indent: &mut Indent) -> ParseResult<(Stmt, Inden...
  function parse_local_def (line 1151) | fn parse_local_def(&mut self, indent: &mut Indent) -> ParseResult<(Stmt,...
  function parse_type_expr (line 1161) | fn parse_type_expr(&mut self) -> ParseResult<Type> {
  function parse_def_aux (line 1233) | fn parse_def_aux(&mut self, mut indent: Indent) -> ParseResult<(Definiti...
  function parse_def_arg (line 1286) | fn parse_def_arg(&mut self) -> ParseResult<(Name, Option<Type>)> {
  function parse_return_type (line 1297) | fn parse_return_type(&mut self) -> ParseResult<Option<Type>> {
  function expected_indent (line 1305) | fn expected_indent<T>(&mut self, expected: Indent, got: Indent) -> Parse...
  function input (line 1334) | fn input(&mut self) -> &'a str {
  function index (line 1338) | fn index(&mut self) -> &mut usize {
  function expected (line 1345) | fn expected<T>(&mut self, exp: &str) -> ParseResult<T> {
  function consume (line 1354) | fn consume(&mut self, text: &str) -> ParseResult<()> {
  function skip_trivia (line 1364) | fn skip_trivia(&mut self) {
  method precedence (line 1387) | fn precedence(&self) -> usize {
  method max_precedence (line 1409) | fn max_precedence() -> usize {

FILE: src/imp/to_fun.rs
  method to_fun (line 14) | pub fn to_fun(mut self) -> Result<Book, Diagnostics> {
  method to_fun (line 32) | pub fn to_fun(self) -> Result<fun::Definition, Diagnostics> {
  method into_fun (line 67) | pub fn into_fun(self) -> fun::Pattern {
  type StmtToFun (line 86) | enum StmtToFun {
  function take (line 91) | fn take(t: Stmt) -> Result<(bool, Option<fun::Pattern>, fun::Term), Stri...
  function wrap (line 98) | fn wrap(nxt: Option<fun::Pattern>, term: fun::Term, ask: bool) -> StmtTo...
  method into_fun (line 107) | fn into_fun(self) -> Result<StmtToFun, String> {
  method to_fun (line 375) | pub fn to_fun(self) -> fun::Term {
  function map_init (line 463) | fn map_init(entries: Vec<(Expr, Expr)>) -> fun::Term {
  function wrap_nxt_assign_stmt (line 474) | fn wrap_nxt_assign_stmt(

FILE: src/imports/book.rs
  method load_imports (line 28) | pub fn load_imports(
  method apply_imports (line 55) | fn apply_imports(
  method load_packages (line 68) | fn load_packages(
  method apply_import_binds (line 116) | fn apply_import_binds(&mut self, main_imports: Option<&ImportsMap>, pkgs...
  method apply_adts (line 165) | fn apply_adts(&mut self, src: &Name, main_imports: &ImportsMap) {
  method apply_defs (line 234) | fn apply_defs(&mut self, src: &Name, main_imports: &ImportsMap) {
  method top_level_names (line 253) | pub fn top_level_names(&self) -> impl Iterator<Item = &Name> {
  method add_imported_adt (line 263) | fn add_imported_adt(&mut self, nam: Name, adt: Adt, diag: &mut Diagnosti...
  method add_imported_def (line 286) | fn add_imported_def(&mut self, def: Definition, diag: &mut Diagnostics) {
  method add_imported_hvm_def (line 292) | fn add_imported_hvm_def(&mut self, def: HvmDefinition, diag: &mut Diagno...
  method has_def_conflict (line 298) | fn has_def_conflict(&mut self, name: &Name, diag: &mut Diagnostics) -> b...
  method local_defs_mut (line 312) | fn local_defs_mut(&mut self) -> impl Iterator<Item = (&Name, &mut dyn De...
  type Def (line 321) | trait Def {
    method canonicalize_name (line 322) | fn canonicalize_name(&mut self, src: &Name, main_imports: &ImportsMap,...
    method apply_binds (line 338) | fn apply_binds(&mut self, maybe_constructor: bool, binds: &BindMap);
    method apply_type_binds (line 340) | fn apply_type_binds(&mut self, binds: &BindMap);
    method source (line 342) | fn source(&self) -> &Source;
    method source_mut (line 343) | fn source_mut(&mut self) -> &mut Source;
    method name_mut (line 344) | fn name_mut(&mut self) -> &mut Name;
    method apply_binds (line 348) | fn apply_binds(&mut self, maybe_constructor: bool, binds: &BindMap) {
    method apply_type_binds (line 379) | fn apply_type_binds(&mut self, binds: &BindMap) {
    method source (line 388) | fn source(&self) -> &Source {
    method source_mut (line 392) | fn source_mut(&mut self) -> &mut Source {
    method name_mut (line 396) | fn name_mut(&mut self) -> &mut Name {
    method apply_binds (line 402) | fn apply_binds(&mut self, _maybe_constructor: bool, binds: &BindMap) {
    method apply_type_binds (line 407) | fn apply_type_binds(&mut self, binds: &BindMap) {
    method source (line 493) | fn source(&self) -> &Source {
    method source_mut (line 497) | fn source_mut(&mut self) -> &mut Source {
    method name_mut (line 501) | fn name_mut(&mut self) -> &mut Name {
    method apply_binds (line 508) | fn apply_binds(&mut self, _maybe_constructor: bool, _binds: &BindMap) {}
    method apply_type_binds (line 510) | fn apply_type_binds(&mut self, binds: &BindMap) {
    method source (line 516) | fn source(&self) -> &Source {
    method source_mut (line 520) | fn source_mut(&mut self) -> &mut Source {
    method name_mut (line 524) | fn name_mut(&mut self) -> &mut Name {
    method canonicalize_name (line 528) | fn canonicalize_name(&mut self, src: &Name, main_imports: &ImportsMap,...
  method fold_uses (line 542) | fn fold_uses<'a>(self, map: impl Iterator<Item = (&'a Name, &'a Name)>) ...
  method fold_uses (line 552) | fn fold_uses<'a>(self, map: impl Iterator<Item = (&'a Name, &'a Name)>) ...

FILE: src/imports/loader.rs
  type Sources (line 9) | pub type Sources = IndexMap<Name, String>;
  type PackageLoader (line 12) | pub trait PackageLoader {
    method load (line 36) | fn load(&mut self, import: &mut Import) -> Result<Sources, String>;
    method load (line 156) | fn load(&mut self, import: &mut Import) -> Result<Sources, String> {
  type DefaultLoader (line 40) | pub struct DefaultLoader {
    method new (line 47) | pub fn new(local_path: &Path) -> Self {
    method read_file (line 53) | fn read_file(&mut self, path: &Path, file_path: &str, src: &mut Source...
    method read_file_in_folder (line 72) | fn read_file_in_folder(
    method read_path (line 89) | fn read_path(
    method is_loaded (line 148) | fn is_loaded(&self, name: &Name) -> bool {
  constant BEND_PATH (line 153) | pub const BEND_PATH: &[&str] = &[""];
  function normalize_path (line 184) | pub fn normalize_path(path: &Path) -> PathBuf {

FILE: src/imports/mod.rs
  type BindMap (line 15) | pub type BindMap = IndexMap<Name, Name>;
  type ImportCtx (line 18) | pub struct ImportCtx {
    method add_import (line 27) | pub fn add_import(&mut self, import: Import) {
    method to_imports (line 31) | pub fn to_imports(self) -> Vec<Import> {
    method sources (line 35) | pub fn sources(&self) -> Vec<&Name> {
  type Import (line 50) | pub struct Import {
    method new (line 58) | pub fn new(path: Name, imp_type: ImportType, relative: bool) -> Self {
  type ImportType (line 64) | pub enum ImportType {
  method fmt (line 71) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type BoundSource (line 81) | pub enum BoundSource {
  type ImportsMap (line 90) | struct ImportsMap {
    method contains_source (line 95) | pub fn contains_source(&self, s: &Name) -> bool {
    method add_bind (line 99) | fn add_bind(&mut self, src: &str, bind: Name, diag: &mut Diagnostics) {
    method add_aliased_bind (line 108) | fn add_aliased_bind(&mut self, src: &Name, sub: &Name, alias: Option<&...
    method add_binds (line 114) | fn add_binds(&mut self, names: &IndexSet<Name>, src: &Name, diag: &mut...
    method add_file_nested_binds (line 122) | fn add_file_nested_binds(
    method add_nested_binds (line 141) | fn add_nested_binds<'a>(

FILE: src/imports/packages.rs
  type Packages (line 10) | pub struct Packages {
    method new (line 21) | pub fn new(book: ParseBook) -> Self {
    method load_imports (line 31) | pub fn load_imports(
    method load_imports_go (line 54) | fn load_imports_go(
    method load_binds (line 91) | fn load_binds(&mut self, idx: usize, diag: &mut Diagnostics) {
    method add_aliased_bind (line 209) | fn add_aliased_bind(
    method add_file_from_dir (line 227) | fn add_file_from_dir(
    method add_glob_from_dir (line 244) | fn add_glob_from_dir(&self, pkgs: &IndexMap<Name, Name>, map: &mut Imp...
    method unique_top_level_names (line 251) | fn unique_top_level_names(&self, src: &Name) -> IndexSet<Name> {

FILE: src/lib.rs
  constant ENTRY_POINT (line 28) | pub const ENTRY_POINT: &str = "main";
  constant HVM1_ENTRY_POINT (line 29) | pub const HVM1_ENTRY_POINT: &str = "Main";
  constant HVM_OUTPUT_END_MARKER (line 30) | pub const HVM_OUTPUT_END_MARKER: &str = "Result: ";
  function check_book (line 32) | pub fn check_book(
  function compile_book (line 42) | pub fn compile_book(
  function desugar_book (line 83) | pub fn desugar_book(
  function type_check_book (line 172) | pub fn type_check_book(ctx: &mut Ctx) -> Result<(), Diagnostics> {
  function run_book (line 179) | pub fn run_book(
  function readback_hvm_net (line 203) | pub fn readback_hvm_net(
  function run_hvm (line 222) | fn run_hvm(book: &::hvm::ast::Book, cmd: &str, run_opts: &RunOpts) -> Re...
  function parse_hvm_output (line 246) | fn parse_hvm_output(out: &str) -> Result<(::hvm::ast::Net, String), Stri...
  function filter_hvm_output (line 264) | fn filter_hvm_output(
  type RunOpts (line 313) | pub struct RunOpts {
  method default (line 320) | fn default() -> Self {
  type OptLevel (line 326) | pub enum OptLevel {
    method enabled (line 334) | pub fn enabled(&self) -> bool {
    method is_extra (line 338) | pub fn is_extra(&self) -> bool {
  type CompilerTarget (line 344) | pub enum CompilerTarget {
  type CompileOpts (line 351) | pub struct CompileOpts {
    method set_all (line 386) | pub fn set_all(self) -> Self {
    method set_no_all (line 403) | pub fn set_no_all(self) -> Self {
    method check_for_strict (line 418) | pub fn check_for_strict(&self) {
  method default (line 435) | fn default() -> Self {
  type AdtEncoding (line 452) | pub enum AdtEncoding {
    method fmt (line 458) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type CompileResult (line 466) | pub struct CompileResult {
  function maybe_grow (line 472) | fn maybe_grow<R, F>(f: F) -> R

FILE: src/main.rs
  type Cli (line 17) | struct Cli {
  type Mode (line 32) | enum Mode {
  type RunArgs (line 86) | struct RunArgs {
  type GenArgs (line 113) | struct GenArgs {
  type CliRunOpts (line 131) | struct CliRunOpts {
  type CliWarnOpts (line 141) | struct CliWarnOpts {
  type OptArgs (line 171) | pub enum OptArgs {
  function compile_opts_from_cli (line 195) | fn compile_opts_from_cli(args: &Vec<OptArgs>, compiler_target: CompilerT...
  type WarningArgs (line 234) | pub enum WarningArgs {
  function main (line 246) | fn main() -> ExitCode {
  function execute_cli_mode (line 259) | fn execute_cli_mode(mut cli: Cli) -> Result<(), Diagnostics> {
  function set_warning_cfg_from_cli (line 407) | fn set_warning_cfg_from_cli(mut cfg: DiagnosticsConfig, warn_opts: CliWa...

FILE: src/net/hvm_to_net.rs
  function hvm_to_net (line 8) | pub fn hvm_to_net(net: &Net) -> INet {
  function hvm_to_inodes (line 13) | fn hvm_to_inodes(net: &Net) -> INodes {
  function new_var (line 36) | fn new_var(n_vars: &mut NodeId) -> String {
  function tree_to_inodes (line 43) | fn tree_to_inodes(tree: &Tree, tree_root: String, net_root: &str, n_vars...
  function inodes_to_inet (line 112) | fn inodes_to_inet(inodes: &INodes) -> INet {

FILE: src/net/mod.rs
  type BendLab (line 4) | pub type BendLab = u16;
  type INet (line 9) | pub struct INet {
    method new (line 75) | pub fn new() -> Self {
    method new_node (line 80) | pub fn new_node(&mut self, kind: NodeKind) -> NodeId {
    method node (line 88) | pub fn node(&self, node: NodeId) -> &Node {
    method enter_port (line 93) | pub fn enter_port(&self, port: Port) -> Port {
    method link (line 98) | pub fn link(&mut self, a: Port, b: Port) {
    method set (line 104) | pub fn set(&mut self, src: Port, dst: Port) {
  type Node (line 14) | pub struct Node {
    method new (line 118) | pub fn new(main: Port, aux1: Port, aux2: Port, kind: NodeKind) -> Self {
    method port (line 122) | pub fn port(&self, slot: SlotId) -> Port {
    method port_mut (line 131) | pub fn port_mut(&mut self, slot: SlotId) -> &mut Port {
  type Port (line 22) | pub struct Port(pub NodeId, pub SlotId);
    method node_id (line 143) | pub fn node_id(self) -> NodeId {
    method slot (line 148) | pub fn slot(self) -> SlotId {
  type NodeKind (line 25) | pub enum NodeKind {
  type CtrKind (line 43) | pub enum CtrKind {
    method to_lab (line 50) | pub fn to_lab(self) -> BendLab {
  type NodeId (line 63) | pub type NodeId = u64;
  type SlotId (line 64) | pub type SlotId = u64;
  constant ROOT (line 67) | pub const ROOT: Port = Port(0, 1);
  constant TAG_WIDTH (line 68) | pub const TAG_WIDTH: u32 = 4;
  constant TAG (line 69) | pub const TAG: u32 = u64::BITS - TAG_WIDTH;
  constant LABEL_MASK (line 70) | pub const LABEL_MASK: u64 = (1 << TAG) - 1;
  constant TAG_MASK (line 71) | pub const TAG_MASK: u64 = !LABEL_MASK;
  method default (line 110) | fn default() -> Self {
  type INodes (line 157) | pub type INodes = Vec<INode>;
  type INode (line 160) | pub struct INode {

FILE: tests/golden_tests.rs
  constant TESTS_PATH (line 40) | const TESTS_PATH: &str = "/tests/golden_tests/";
  type RunFn (line 42) | type RunFn = dyn Fn(&str, &Path) -> Result<String, Diagnostics>;
  function parse_book_single_file (line 44) | pub fn parse_book_single_file(code: &str, origin: &Path) -> Result<Book,...
  function run_single_golden_test (line 48) | fn run_single_golden_test(path: &Path, run: &[&RunFn]) -> Result<(), Str...
  function run_golden_test_dir (line 78) | fn run_golden_test_dir(test_name: &str, run: &RunFn) {
  function run_golden_test_dir_multiple (line 82) | fn run_golden_test_dir_multiple(test_name: &str, run: &[&RunFn]) {
  function compile_file (line 114) | fn compile_file() {
  function compile_file_o_all (line 127) | fn compile_file_o_all() {
  function compile_file_o_no_all (line 144) | fn compile_file_o_no_all() {
  function linear_readback (line 156) | fn linear_readback() {
  function run_file (line 179) | fn run_file() {
  function import_system (line 206) | fn import_system() {
  function readback_hvm (line 231) | fn readback_hvm() {
  function simplify_matches (line 245) | fn simplify_matches() {
  function encode_pattern_match (line 286) | fn encode_pattern_match() {
  function parse_file (line 326) | fn parse_file() {
  function check_file (line 341) | fn check_file() {
  function desugar_file (line 356) | fn desugar_file() {
  function hangs (line 372) | fn hangs() {
  function compile_entrypoint (line 398) | fn compile_entrypoint() {
  function run_entrypoint (line 411) | fn run_entrypoint() {
  function cli (line 427) | fn cli() {
  function mutual_recursion (line 448) | fn mutual_recursion() {
  function io (line 461) | fn io() {
  function prelude (line 476) | fn prelude() {
  function examples (line 491) | fn examples() -> Result<(), Diagnostics> {
  function scott_triggers_unused (line 527) | fn scott_triggers_unused() {
  function compile_long (line 542) | fn compile_long() {