SYMBOL INDEX (396 symbols across 9 files)

FILE: embed_macro/src/lib.rs
  function embedded (line 9) | pub fn embedded(
  function generate_ffi_body (line 70) | fn generate_ffi_body(data: &Signature, fn_name: &Ident, fn_name_ffi: &Id...
  function call_ffi (line 106) | fn call_ffi(len: usize, fn_name: &Ident) -> TokenStream {
  function typecast (line 142) | fn typecast(ty: &Type, arg_dst: Ident, arg_src: TokenStream) -> TokenStr...
  function inputs_type (line 172) | fn inputs_type(data: &Signature) -> String {
  function output_type (line 189) | fn output_type(data: &Signature) -> String {
  function parse_type (line 198) | fn parse_type(ty: &Type) -> String {
  function ex_type_check (line 250) | fn ex_type_check(id: &Ident) -> String {

FILE: src/coq.rs
  function to_coq_type (line 9) | pub(crate) fn to_coq_type(
  function import (line 105) | pub(crate) fn import() -> &'static str {
  function to_coq_data (line 123) | pub(crate) fn to_coq_data(expr: &S::DataType) -> String {
  function to_coq_data_def (line 148) | fn to_coq_data_def(expr: &S::DataTypeName) -> String {
  function to_coq_data_mem (line 167) | fn to_coq_data_mem(expr: &S::DataTypeMem) -> String {
  function to_args_type (line 185) | fn to_args_type(args: &LinkedList<String>, ty: &str) -> String {
  function inductive_arguments (line 200) | fn inductive_arguments(expr: &S::DataType) -> String {
  function to_coq_func (line 215) | pub(crate) fn to_coq_func(expr: &S::Defun) -> String {
  function func_analyze (line 283) | fn func_analyze(expr: &S::LangExpr, count: &mut i32) -> String {
  function pattern_analyze (line 426) | fn pattern_analyze(pattern: &S::Pattern) -> String {
  function apply_arith (line 462) | fn apply_arith(expr: String) -> Option<String> {
  function tabb (line 474) | fn tabb(count: i32) -> String {
  function is_recursive (line 482) | fn is_recursive(expr: &S::Defun) -> bool {
  function is_recursive_expr (line 486) | fn is_recursive_expr(expr: &S::LangExpr, id: &str) -> bool {
  function is_recursive_exprs (line 520) | fn is_recursive_exprs(exprs: &[S::LangExpr], id: &str) -> bool {

FILE: src/lib.rs
  type FileType (line 114) | pub enum FileType {
  type Pos (line 123) | pub struct Pos {
  method fmt (line 130) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  type LispErr (line 137) | pub struct LispErr {
    method new (line 143) | fn new(msg: String, pos: Pos) -> LispErr {
  type TypingContext (line 148) | pub struct TypingContext {
  function init (line 166) | pub fn init(code: &str, ext_funs: Vec<Box<dyn FFI + Send>>) -> Result<Ty...
  function typing (line 230) | pub fn typing(exprs: TypingContext) -> Result<semantics::Context, LispEr...
  function eval (line 257) | pub fn eval(
  function transpile (line 264) | pub fn transpile(ctx: &semantics::Context) -> String {
  function eval_first (line 281) | fn eval_first(code: &str, ctx: &semantics::Context) -> String {
  function test_macro (line 292) | fn test_macro() {
  function test_macro_hygiene_lambda (line 329) | fn test_macro_hygiene_lambda() {
  function test_macro_hygiene_let (line 343) | fn test_macro_hygiene_let() {
  function test_macro_hygiene_match (line 357) | fn test_macro_hygiene_match() {
  function eval_result (line 373) | fn eval_result(code: &str, ctx: &semantics::Context) {
  function ops (line 380) | fn ops() {
  function lambda (line 415) | fn lambda() {
  function list (line 430) | fn list() {
  function tuple (line 454) | fn tuple() {
  function prelude (line 466) | fn prelude() {
  function callback (line 504) | fn callback() {
  function do_transpile (line 525) | fn do_transpile() {
  function test_multibyte (line 550) | fn test_multibyte() {

FILE: src/macro.rs
  type MacroErr (line 9) | pub struct MacroErr {
  function match_pattern (line 15) | pub fn match_pattern(e1: &Expr, e2: &Expr, ctx: &mut BTreeMap<String, Li...
  function match_list (line 55) | pub fn match_list(
  function eq_expr (line 106) | fn eq_expr(e1: &Expr, e2: &Expr) -> bool {
  function eq_exprs (line 120) | fn eq_exprs(es1: &LinkedList<Expr>, es2: &LinkedList<Expr>) -> bool {
  function process_macros (line 128) | pub(crate) fn process_macros(exprs: &mut LinkedList<Expr>) -> Result<Mac...
  function apply (line 139) | pub(crate) fn apply(expr: &mut Expr, macros: &Macros) -> Result<(), Macr...
  type MacroExpander (line 143) | struct MacroExpander<'a> {
  function new (line 149) | fn new(macros: &'a Macros) -> MacroExpander<'a> {
  function apply_macros (line 156) | fn apply_macros(&mut self, expr: &mut Expr) -> Result<(), MacroErr> {
  function apply_macros_expr (line 168) | fn apply_macros_expr(
  function apply_macros_recursively (line 199) | fn apply_macros_recursively(&mut self, expr: &mut Expr, count: u8) -> Re...
  function expand (line 220) | fn expand(
  function freshen_template (line 230) | fn freshen_template(&mut self, template: &Expr) -> Expr {
  function rename_expr (line 235) | fn rename_expr(&mut self, expr: &Expr, env: &mut BTreeMap<String, String...
  function rename_exprs (line 262) | fn rename_exprs(
  function rename_lambda (line 276) | fn rename_lambda(
  function rename_lambda_args (line 299) | fn rename_lambda_args(
  function rename_let (line 316) | fn rename_let(
  function rename_let_bindings (line 339) | fn rename_let_bindings(
  function rename_match (line 374) | fn rename_match(
  function rename_match_case (line 396) | fn rename_match_case(&mut self, case: &Expr, env: &mut BTreeMap<String, ...
  function rename_pattern (line 416) | fn rename_pattern(&mut self, pattern: &Expr, env: &mut BTreeMap<String, ...
  function rename_binder (line 444) | fn rename_binder(&mut self, expr: &Expr, env: &mut BTreeMap<String, Stri...
  function fresh_name (line 459) | fn fresh_name(&mut self, id: &str) -> String {
  type Macros (line 466) | pub(crate) type Macros = BTreeMap<String, LinkedList<MacroRule>>;
  type MacroRule (line 469) | pub(crate) struct MacroRule {
  function parse_macros (line 474) | fn parse_macros(exprs: &LinkedList<Expr>) -> Result<Macros, MacroErr> {
  function is_pattern_var (line 553) | fn is_pattern_var(id: &str) -> bool {
  function expand_expr (line 557) | fn expand_expr(pos: Pos, template: &Expr, ctx: &BTreeMap<String, LinkedL...
  function expand_list (line 598) | fn expand_list(

FILE: src/parser.rs
  type SyntaxErr (line 28) | pub struct SyntaxErr {
  type Parser (line 33) | pub struct Parser<'a> {
  type Expr (line 39) | pub enum Expr {
    method get_pos (line 103) | pub fn get_pos(&self) -> Pos {
  method fmt (line 51) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  function new (line 118) | pub fn new(code: &'a str, file_id: FileType) -> Parser<'a> {
  function parse (line 129) | pub fn parse(&mut self) -> Result<LinkedList<Expr>, SyntaxErr> {
  function parse_id_bool (line 142) | fn parse_id_bool(&mut self) -> Result<Expr, SyntaxErr> {
  function parse_oct (line 173) | fn parse_oct(&mut self) -> Result<Expr, SyntaxErr> {
  function parse_hex (line 203) | fn parse_hex(&mut self) -> Result<Expr, SyntaxErr> {
  function check_eof (line 237) | fn check_eof(&self, expr: Expr) -> Result<Expr, SyntaxErr> {
  function parse_binary (line 260) | fn parse_binary(&mut self) -> Result<Expr, SyntaxErr> {
  function parse_num (line 292) | fn parse_num(&mut self) -> Result<Expr, SyntaxErr> {
  function skip_spaces (line 351) | fn skip_spaces(&mut self) {
  function parse_exprs (line 386) | fn parse_exprs(&mut self) -> Result<LinkedList<Expr>, SyntaxErr> {
  function parse_expr (line 402) | fn parse_expr(&mut self) -> Result<Expr, SyntaxErr> {
  function parse_char (line 440) | fn parse_char(&mut self) -> Result<Expr, SyntaxErr> {
  function parse_string (line 512) | fn parse_string(&mut self) -> Result<Expr, SyntaxErr> {
  function parse_apply (line 583) | fn parse_apply(&mut self) -> Result<Expr, SyntaxErr> {
  function parse_list (line 601) | fn parse_list(&mut self) -> Result<Expr, SyntaxErr> {
  function parse_tuple (line 628) | fn parse_tuple(&mut self) -> Result<Expr, SyntaxErr> {
  function is_space (line 647) | fn is_space(c: char) -> bool {
  function is_paren (line 651) | fn is_paren(c: char) -> bool {

FILE: src/runtime.rs
  type Expr (line 21) | type Expr = semantics::LangExpr;
  type Pattern (line 22) | type Pattern = semantics::Pattern;
  type RuntimeErr (line 24) | struct RuntimeErr {
  type Variables (line 30) | pub struct Variables {
    method new (line 35) | fn new() -> Variables {
    method push (line 41) | fn push(&mut self) {
    method pop (line 45) | fn pop(&mut self) {
    method insert (line 49) | fn insert(&mut self, id: String, data: RTData) {
    method get (line 54) | fn get(&mut self, id: &str) -> Option<&RTData> {
  type TCall (line 65) | pub enum TCall {
  type IntType (line 71) | pub struct IntType(*mut (BigInt, bool));
    method get_int (line 74) | fn get_int(&self) -> &BigInt {
    method get_ref (line 78) | fn get_ref(&mut self) -> &mut bool {
  method cmp (line 84) | fn cmp(&self, other: &Self) -> Ordering {
  method partial_cmp (line 92) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  method eq (line 100) | fn eq(&self, other: &Self) -> bool {
  type StrType (line 108) | pub struct StrType(*mut (String, bool));
    method get_string (line 111) | fn get_string(&self) -> &String {
    method get_ref (line 115) | fn get_ref(&mut self) -> &mut bool {
  method cmp (line 121) | fn cmp(&self, other: &Self) -> Ordering {
  method partial_cmp (line 129) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  method eq (line 137) | fn eq(&self, other: &Self) -> bool {
  type ClojureType (line 145) | pub struct ClojureType(*mut (Clojure, bool));
    method get_clojure (line 148) | fn get_clojure(&self) -> &Clojure {
    method get_clojure_mut (line 152) | fn get_clojure_mut(&mut self) -> &mut Clojure {
    method get_ref (line 156) | fn get_ref(&mut self) -> &mut bool {
  method cmp (line 162) | fn cmp(&self, other: &Self) -> Ordering {
  method partial_cmp (line 170) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  method eq (line 178) | fn eq(&self, other: &Self) -> bool {
  type LDataType (line 186) | pub struct LDataType(*mut (LabeledData, bool));
    method get_ldata (line 189) | fn get_ldata(&self) -> &LabeledData {
    method get_ldata_mut (line 193) | fn get_ldata_mut(&mut self) -> &mut LabeledData {
    method get_ref (line 197) | fn get_ref(&mut self) -> &mut bool {
  method cmp (line 203) | fn cmp(&self, other: &Self) -> Ordering {
  method partial_cmp (line 211) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  method eq (line 219) | fn eq(&self, other: &Self) -> bool {
  type RTData (line 227) | pub enum RTData {
    method get_in_lisp (line 249) | fn get_in_lisp(&self, list_head: bool) -> String {
    method into (line 1239) | fn into(&self) -> BigInt {
    method into (line 1250) | fn into(&self) -> char {
    method into (line 1261) | fn into(&self) -> String {
    method into (line 1272) | fn into(&self) -> bool {
    method into (line 1286) | fn into(&self) -> Vec<T> {
    method into (line 1304) | fn into(&self) -> Option<T> {
    method into (line 1357) | fn into(&self) -> Result<T, E> {
    method from (line 1541) | fn from(env: &mut Environment<'_>, value: BigInt) -> Self {
    method from (line 1547) | fn from(_env: &mut Environment<'_>, value: char) -> Self {
    method from (line 1553) | fn from(_env: &mut Environment<'_>, value: bool) -> Self {
    method from (line 1559) | fn from(env: &mut Environment<'_>, value: String) -> Self {
    method from (line 1568) | fn from(env: &mut Environment<'_>, value: Option<T>) -> Self {
    method from (line 1582) | fn from(env: &mut Environment<'_>, value: Result<T, E>) -> Self {
    method from (line 1597) | fn from(env: &mut Environment<'_>, _: ()) -> Self {
    method from (line 1694) | fn from(env: &mut Environment<'_>, vec: Vec<T>) -> Self {
    method from (line 1702) | fn from(env: &mut Environment<'_>, slice: [T; N]) -> Self {
  function escape_char (line 238) | fn escape_char(c: char) -> String {
  type LabeledData (line 344) | struct LabeledData {
  type Clojure (line 350) | struct Clojure {
  constant MIN_GC_NUM (line 355) | const MIN_GC_NUM: usize = 1024;
  type RootObject (line 358) | pub(crate) struct RootObject {
    method new (line 367) | fn new() -> RootObject {
    method len (line 377) | fn len(&self) -> usize {
    method make_int (line 381) | fn make_int(&mut self, n: BigInt) -> IntType {
    method make_str (line 387) | fn make_str(&mut self, str: String) -> StrType {
    method make_obj (line 393) | fn make_obj(&mut self, label: String, data: Option<Vec<RTData>>) -> LD...
    method make_clojure (line 400) | fn make_clojure(&mut self, ident: u64, data: Option<BTreeMap<String, R...
  type Environment (line 408) | pub struct Environment<'a> {
  function eval (line 415) | pub(crate) fn eval(
  function get_data_of_id (line 484) | fn get_data_of_id(id: &str, vars: &mut VecDeque<Variables>) -> RTData {
  function eval_expr (line 491) | fn eval_expr(expr: &Expr, env: &mut Environment<'_>) -> Result<RTData, R...
  function eval_lambda (line 509) | fn eval_lambda(expr: &semantics::Lambda, env: &mut Environment<'_>) -> R...
  function eval_tuple (line 524) | fn eval_tuple(expr: &semantics::Exprs, env: &mut Environment<'_>) -> Res...
  function get_fun (line 535) | fn get_fun<'a>(
  function get_lambda (line 552) | fn get_lambda<'a>(
  function call_lambda (line 578) | fn call_lambda(
  function eval_apply (line 617) | fn eval_apply(expr: &semantics::Apply, env: &mut Environment<'_>) -> Res...
  function eval_tail_call (line 696) | fn eval_tail_call<'a>(
  function get_int (line 723) | fn get_int(args: &[RTData], pos: Pos) -> Result<*const BigInt, RuntimeEr...
  function get_int_int (line 733) | fn get_int_int(args: &[RTData], pos: Pos) -> Result<(*const BigInt, *con...
  function get_int_int_int (line 743) | fn get_int_int_int(
  function get_bool_bool (line 758) | fn get_bool_bool(args: &[RTData], pos: Pos) -> Result<(bool, bool), Runt...
  function get_bool (line 768) | fn get_bool(args: &[RTData], pos: Pos) -> Result<bool, RuntimeErr> {
  function eval_built_in (line 778) | fn eval_built_in(
  function eval_match (line 964) | fn eval_match(
  function eval_id (line 987) | fn eval_id(expr: &semantics::IDNode, vars: &mut VecDeque<Variables>) -> ...
  function eval_list (line 992) | fn eval_list(expr: &semantics::Exprs, env: &mut Environment<'_>) -> Resu...
  function eval_if (line 1004) | fn eval_if(expr: &semantics::IfNode, env: &mut Environment<'_>) -> Resul...
  function eval_data (line 1024) | fn eval_data(expr: &semantics::DataNode, env: &mut Environment<'_>) -> R...
  function eval_let (line 1040) | fn eval_let(expr: &semantics::LetNode, env: &mut Environment<'_>) -> Res...
  function eval_pat (line 1060) | fn eval_pat(pat: &Pattern, data: RTData, vars: &mut VecDeque<Variables>)...
  function collect_garbage (line 1130) | fn collect_garbage(vars: &mut VecDeque<Variables>, root: &mut RootObject) {
  function mark (line 1150) | fn mark(vars: &mut VecDeque<Variables>) {
  function mark_obj (line 1161) | fn mark_obj(data: &mut RTData) {
  function sweep (line 1194) | fn sweep<T>(root: &mut LinkedList<Pin<Box<(T, bool)>>>) {
  type RTDataToRust (line 1233) | pub trait RTDataToRust<T> {
    method into (line 1234) | fn into(&self) -> T;
  function list_to_vec (line 1326) | fn list_to_vec<T>(mut ldata: &LabeledData, result: &mut Vec<T>)
  type RustToRTData (line 1536) | pub trait RustToRTData<T> {
    method from (line 1537) | fn from(env: &mut Environment<'_>, value: T) -> Self;
  function collection_to_list (line 1708) | fn collection_to_list<I, T>(env: &mut Environment<'_>, iter: I) -> LData...
  type FFI (line 1746) | pub trait FFI {
    method blisp_extern (line 1748) | fn blisp_extern(&self) -> &'static str;
    method ffi (line 1751) | fn ffi(&self) -> fn(env: &mut Environment<'_>, args: &[RTData]) -> RTD...
    method name (line 1754) | fn name(&self) -> &'static str;

FILE: src/semantics.rs
  type ID (line 21) | type ID = u64;
  type Sbst (line 22) | type Sbst = BTreeMap<ID, Type>;
  type Type (line 25) | enum Type {
    method fmt (line 37) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method has_tvar (line 3925) | fn has_tvar(&self, id: ID) -> bool {
    method apply_sbst (line 3932) | fn apply_sbst(&self, sbst: &Sbst) -> Type {
  type Tycon (line 31) | struct Tycon {
    method fmt (line 46) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method has_tvar (line 3944) | fn has_tvar(&self, id: ID) -> bool {
    method apply_sbst (line 3956) | fn apply_sbst(&self, sbst: &Sbst) -> Type {
  function ty_bool (line 74) | fn ty_bool() -> Type {
  function ty_int (line 81) | fn ty_int() -> Type {
  function ty_string (line 88) | fn ty_string() -> Type {
  function ty_char (line 95) | fn ty_char() -> Type {
  function ty_var (line 102) | fn ty_var(n: ID) -> Type {
  function ty_tuple (line 106) | fn ty_tuple(types: Vec<Type>) -> Type {
  function ty_list (line 113) | fn ty_list(ty: Type) -> Type {
  function ty_args (line 120) | fn ty_args(types: Vec<Type>) -> Type {
  function ty_fun (line 134) | fn ty_fun(effect: &Effect, args: Vec<Type>, ret: Type) -> Type {
  function ty_fun_gen_effect (line 152) | fn ty_fun_gen_effect(n: ID, args: Vec<Type>, ret: Type) -> Type {
  type FunTypes (line 161) | pub struct FunTypes {
    method new (line 166) | fn new() -> FunTypes {
    method insert (line 172) | fn insert(&mut self, key: &str, val: Type) {
    method contains (line 185) | fn contains(&self, key: &str, val: &Type) -> bool {
  type VarType (line 200) | struct VarType {
    method new (line 205) | fn new() -> VarType {
    method push (line 213) | fn push(&mut self) {
    method pop (line 217) | fn pop(&mut self) {
    method insert (line 221) | fn insert(&mut self, key: String, val: Type) {
    method get (line 239) | fn get(&self, key: &str) -> Option<&Type> {
  type TypingErr (line 251) | pub struct TypingErr {
    method new (line 257) | fn new(msg: &str, ast: &parser::Expr) -> TypingErr {
  type LangExpr (line 266) | pub(crate) enum LangExpr {
    method get_pos (line 283) | pub(crate) fn get_pos(&self) -> Pos {
    method apply_sbst (line 301) | fn apply_sbst(&mut self, sbst: &Sbst) {
  type Lambda (line 372) | pub(crate) struct Lambda {
  type StrNode (line 382) | pub(crate) struct StrNode {
  type CharNode (line 389) | pub(crate) struct CharNode {
  type NumNode (line 396) | pub(crate) struct NumNode {
  type BoolNode (line 403) | pub(crate) struct BoolNode {
  type IDNode (line 410) | pub(crate) struct IDNode {
  type Extern (line 417) | pub(crate) struct Extern {
  type IfNode (line 424) | pub(crate) struct IfNode {
  type LetNode (line 433) | pub(crate) struct LetNode {
  type DefVar (line 441) | pub(crate) struct DefVar {
  type MatchNode (line 449) | pub(crate) struct MatchNode {
  type DataNode (line 457) | pub(crate) struct DataNode {
  type Pattern (line 465) | pub(crate) enum Pattern {
    method get_pos (line 477) | pub(crate) fn get_pos(&self) -> Pos {
    method get_type (line 490) | fn get_type(&self) -> &Option<Type> {
    method apply_sbst (line 503) | fn apply_sbst(&mut self, sbst: &Sbst) {
  type PatTupleNode (line 531) | pub(crate) struct PatTupleNode {
  type PatDataNode (line 538) | pub(crate) struct PatDataNode {
  type PatNilNode (line 546) | pub(crate) struct PatNilNode {
  type MatchCase (line 552) | pub(crate) struct MatchCase {
  type Apply (line 560) | pub(crate) struct Apply {
  type Exprs (line 568) | pub(crate) struct Exprs {
  type TIDNode (line 575) | pub(crate) struct TIDNode {
  type TEBoolNode (line 581) | pub(crate) struct TEBoolNode;
  type TEIntNode (line 584) | pub(crate) struct TEIntNode;
  type TEStringNode (line 587) | pub(crate) struct TEStringNode;
  type TECharNode (line 590) | pub(crate) struct TECharNode;
  type DataType (line 593) | pub(crate) struct DataType {
  type DataTypeName (line 600) | pub(crate) struct DataTypeName {
  type DataTypeMem (line 607) | pub(crate) struct DataTypeMem {
  type TypeExpr (line 614) | pub(crate) enum TypeExpr {
  type TEListNode (line 627) | pub(crate) struct TEListNode {
  type TETupleNode (line 633) | pub(crate) struct TETupleNode {
  type Effect (line 639) | enum Effect {
  type TEFunNode (line 645) | pub(crate) struct TEFunNode {
  type TEDataNode (line 653) | pub(crate) struct TEDataNode {
  type Defun (line 660) | pub(crate) struct Defun {
  type TApp (line 671) | trait TApp: Sized {
    method apply (line 672) | fn apply(&self, ty: &BTreeMap<String, TypeExpr>) -> Result<Self, Typin...
    method apply (line 676) | fn apply(&self, ty: &BTreeMap<String, TypeExpr>) -> Result<DataType, T...
    method apply (line 691) | fn apply(&self, ty: &BTreeMap<String, TypeExpr>) -> Result<DataTypeMem...
    method apply (line 706) | fn apply(&self, ty: &BTreeMap<String, TypeExpr>) -> Result<TypeExpr, T...
    method apply (line 722) | fn apply(&self, ty: &BTreeMap<String, TypeExpr>) -> Result<TEListNode,...
    method apply (line 731) | fn apply(&self, ty: &BTreeMap<String, TypeExpr>) -> Result<TETupleNode...
    method apply (line 745) | fn apply(&self, ty: &BTreeMap<String, TypeExpr>) -> Result<TEFunNode, ...
    method apply (line 761) | fn apply(&self, ty: &BTreeMap<String, TypeExpr>) -> Result<TEDataNode,...
  type CallbackFn (line 775) | pub type CallbackFn = Box<dyn Fn(&BigInt, &BigInt, &BigInt) -> Option<Bi...
  type FFIFn (line 776) | pub type FFIFn = BTreeMap<&'static str, fn(env: &mut Environment<'_>, ar...
  type Context (line 778) | pub struct Context {
    method new (line 792) | fn new(
    method set_callback (line 847) | pub fn set_callback(&mut self, func: CallbackFn) {
    method typing (line 851) | fn typing(&mut self) -> Result<(), TypingErr> {
    method check_match_exhaustive (line 865) | fn check_match_exhaustive(&self) -> Result<(), TypingErr> {
    method find_tail_call (line 872) | fn find_tail_call(&mut self) {
    method check_label (line 881) | fn check_label(&mut self) -> Result<(), TypingErr> {
    method typing_functions (line 900) | fn typing_functions(&mut self) -> Result<(), TypingErr> {
    method typing_extern (line 922) | fn typing_extern(&self, fun: &mut Extern) -> Result<(), TypingErr> {
    method typing_defun (line 929) | fn typing_defun(&self, defun: &mut Defun) -> Result<(), TypingErr> {
    method typing_expr (line 983) | fn typing_expr(
    method typing_lambda (line 1007) | fn typing_lambda(
    method typing_data (line 1052) | fn typing_data(
    method typing_app (line 1108) | fn typing_app(
    method typing_tuple (line 1168) | fn typing_tuple(
    method typing_list (line 1188) | fn typing_list(
    method typing_match (line 1241) | fn typing_match(
    method typing_var (line 1313) | fn typing_var(
    method typing_if (line 1420) | fn typing_if(
    method typing_let (line 1474) | fn typing_let(
    method typing_pat (line 1507) | fn typing_pat(
    method typing_pat_tuple (line 1526) | fn typing_pat_tuple(
    method typing_pat_id (line 1546) | fn typing_pat_id(
    method typing_pat_data (line 1565) | fn typing_pat_data(
    method typing_pat_nil (line 1626) | fn typing_pat_nil(&self, expr: &mut PatNilNode, sbst: Sbst, num_tv: &m...
    method to_type (line 1634) | fn to_type(&self, expr: &TypeExpr, num_tv: &mut ID) -> Result<Type, St...
    method get_type_of_label (line 1648) | fn get_type_of_label(&self, label: &str, num_tv: &mut ID) -> Result<(T...
    method check_data_def (line 1735) | fn check_data_def(&self) -> Result<(), TypingErr> {
    method check_data_def_data (line 1743) | fn check_data_def_data(&self, data: &DataType) -> Result<(), TypingErr> {
    method check_data_def_mem (line 1761) | fn check_data_def_mem(
    method check_def_type (line 1773) | fn check_def_type(
    method check_data_rec (line 1838) | fn check_data_rec(&self) -> Result<(), TypingErr> {
    method check_data_rec_data (line 1875) | fn check_data_rec_data(
    method check_data_rec_mem (line 1899) | fn check_data_rec_mem(
    method check_data_rec_ty (line 1917) | fn check_data_rec_ty(
    method type_data_node2data_type (line 1951) | fn type_data_node2data_type(&self, data: &TEDataNode) -> Result<DataTy...
    method check_defun_type (line 1980) | fn check_defun_type(&self) -> Result<(), TypingErr> {
    method check_defun_type_after_infer (line 1988) | fn check_defun_type_after_infer(&mut self) -> Result<(), TypingErr> {
    method check_type_infer (line 2004) | fn check_type_infer(&self, defun: &Defun, fun_types: &mut FunTypes) ->...
    method check_expr_type (line 2050) | fn check_expr_type(
    method check_lambda_type (line 2083) | fn check_lambda_type(
    method check_data_type (line 2104) | fn check_data_type(
    method check_apply_type (line 2122) | fn check_apply_type(
    method check_exprs_type (line 2140) | fn check_exprs_type(
    method check_match_type (line 2158) | fn check_match_type(
    method check_id_type (line 2182) | fn check_id_type(
    method check_defun_type_recur (line 2230) | fn check_defun_type_recur(
    method check_if_type (line 2307) | fn check_if_type(
    method check_let_type (line 2324) | fn check_let_type(
    method get_free_var_in_lambda (line 2351) | fn get_free_var_in_lambda(&mut self) {
  function get_tv2type_from_type_expr (line 2374) | fn get_tv2type_from_type_expr(
  function apply_tv2type_to_type_expr (line 2415) | fn apply_tv2type_to_type_expr(
  function check_pat_type (line 2464) | fn check_pat_type(
  function get_free_var_expr (line 2497) | fn get_free_var_expr(
  function get_free_var_apply (line 2521) | fn get_free_var_apply(
  function get_free_var_exprs (line 2534) | fn get_free_var_exprs(
  function get_free_var_match (line 2547) | fn get_free_var_match(
  function get_free_var_data (line 2565) | fn get_free_var_data(
  function get_free_var_id (line 2578) | fn get_free_var_id(
  function get_free_var_let (line 2595) | fn get_free_var_let(
  function get_free_var_if (line 2613) | fn get_free_var_if(
  function get_free_var_lambda (line 2647) | fn get_free_var_lambda(
  function get_free_var_pattern (line 2693) | fn get_free_var_pattern(pat: &Pattern, local_vars: &mut VarType) {
  function check_type_has_no_tvars (line 2718) | fn check_type_has_no_tvars(ty: &Option<Type>, pos: &Pos, sbst: &Sbst) ->...
  function check_type_has_io (line 2736) | fn check_type_has_io(
  function has_io (line 2763) | fn has_io(ty: &Type) -> bool {
  function has_tvar (line 2785) | fn has_tvar(ty: &Type) -> bool {
  function typing_expr (line 2801) | pub(crate) fn typing_expr(
  function exprs2context (line 2848) | pub fn exprs2context(typing_context: TypingContext) -> Result<Context, T...
  function expr2data (line 2932) | fn expr2data(expr: &parser::Expr) -> Result<DataType, TypingErr> {
  function expr2data_name (line 2962) | fn expr2data_name(expr: &parser::Expr) -> Result<DataTypeName, TypingErr> {
  function expr2type_id (line 3007) | fn expr2type_id(expr: &parser::Expr) -> Result<TIDNode, TypingErr> {
  function expr2id (line 3026) | fn expr2id(expr: &parser::Expr) -> Result<IDNode, TypingErr> {
  function expr2data_mem (line 3050) | fn expr2data_mem(expr: &parser::Expr) -> Result<DataTypeMem, TypingErr> {
  function expr2extern (line 3088) | fn expr2extern(expr: &parser::Expr) -> Result<Extern, TypingErr> {
  function expr2defun (line 3143) | fn expr2defun(expr: &parser::Expr) -> Result<Defun, TypingErr> {
  function expr2type_arrow (line 3217) | fn expr2type_arrow(expr: &parser::Expr) -> Result<(Vec<TypeExpr>, TypeEx...
  function expr2type_fun (line 3264) | fn expr2type_fun(expr: &parser::Expr) -> Result<TypeExpr, TypingErr> {
  function expr2types (line 3308) | fn expr2types(expr: &parser::Expr) -> Result<Vec<TypeExpr>, TypingErr> {
  function expr2type (line 3319) | fn expr2type(expr: &parser::Expr) -> Result<TypeExpr, TypingErr> {
  function list_types2vec_types (line 3411) | fn list_types2vec_types(exprs: &LinkedList<parser::Expr>) -> Result<Vec<...
  function expr2typed_expr (line 3423) | fn expr2typed_expr(expr: &parser::Expr) -> Result<LangExpr, TypingErr> {
  function expr2data_expr (line 3530) | fn expr2data_expr(expr: &parser::Expr) -> Result<LangExpr, TypingErr> {
  function expr2if (line 3555) | fn expr2if(expr: &parser::Expr) -> Result<LangExpr, TypingErr> {
  function expr2let (line 3585) | fn expr2let(expr: &parser::Expr) -> Result<LangExpr, TypingErr> {
  function expr2letpat (line 3632) | fn expr2letpat(expr: &parser::Expr) -> Result<Pattern, TypingErr> {
  function expr2def_vars (line 3693) | fn expr2def_vars(expr: &parser::Expr) -> Result<DefVar, TypingErr> {
  function expr2mpat (line 3717) | fn expr2mpat(expr: &parser::Expr) -> Result<Pattern, TypingErr> {
  function expr2case (line 3819) | fn expr2case(expr: &parser::Expr) -> Result<MatchCase, TypingErr> {
  function expr2match (line 3842) | fn expr2match(expr: &parser::Expr) -> Result<LangExpr, TypingErr> {
  function expr2lambda (line 3877) | fn expr2lambda(expr: &parser::Expr) -> Result<LangExpr, TypingErr> {
  function unify (line 3971) | fn unify(lhs: &Type, rhs: &Type) -> Option<Sbst> {
  function compose (line 4030) | fn compose(s1: &Sbst, s2: &Sbst) -> Sbst {
  function tail_call (line 4045) | fn tail_call(expr: &mut LangExpr) {
  function tail_call_expr (line 4055) | fn tail_call_expr(expr: &mut LangExpr) -> LinkedList<&mut LangExpr> {
  function exhaustive_expr (line 4083) | fn exhaustive_expr(expr: &LangExpr, ctx: &Context) -> Result<(), TypingE...
  function exhaustive_exprs (line 4097) | fn exhaustive_exprs(exprs: &[LangExpr], ctx: &Context) -> Result<(), Typ...
  function exhaustive_let (line 4104) | fn exhaustive_let(expr: &LetNode, ctx: &Context) -> Result<(), TypingErr> {
  function exhaustive_if (line 4114) | fn exhaustive_if(expr: &IfNode, ctx: &Context) -> Result<(), TypingErr> {
  function exhaustive_match (line 4121) | fn exhaustive_match(expr: &MatchNode, ctx: &Context) -> Result<(), Typin...
  type Patterns (line 4138) | struct Patterns<'a> {
  function new (line 4143) | fn new() -> Patterns<'a> {
  function insert (line 4149) | fn insert(&mut self, label: &str, idx: usize, p: &'a Pattern) {
  function check_pattern_exhaustive (line 4163) | fn check_pattern_exhaustive(

FILE: tests/embedded.rs
  function test_fun (line 5) | fn test_fun(
  function add_four_ints (line 17) | fn add_four_ints(a: BigInt, b: (BigInt, BigInt), c: Option<BigInt>) -> R...
  function no_return (line 27) | fn no_return() {}
  function test_embedded (line 30) | fn test_embedded() {

FILE: tests/transpile.rs
  function test_transpile (line 4) | fn test_transpile() {