SYMBOL INDEX (162 symbols across 12 files)

FILE: demo.js
  constant HTML (line 10) | const HTML = `
  class CubimlDemo (line 135) | class CubimlDemo extends HTMLElement {
    method constructor (line 136) | constructor() {
  function initializeRepl (line 153) | function initializeRepl(root, compiler, Printer) {
  class Printer (line 261) | class Printer {
    method constructor (line 262) | constructor() {
    method visit (line 267) | visit(e) {
    method println (line 308) | println(...args) {

FILE: src/ast.rs
  type Literal (line 4) | pub enum Literal {
  type Op (line 13) | pub enum Op {
  type OpType (line 30) | pub enum OpType {
  type LetDefinition (line 39) | type LetDefinition = (LetPattern, Box<Expr>);
  type VarDefinition (line 40) | type VarDefinition = (String, Box<Expr>);
  type LetPattern (line 43) | pub enum LetPattern {
  type MatchPattern (line 49) | pub enum MatchPattern {
  type Expr (line 55) | pub enum Expr {
  type Readability (line 74) | pub enum Readability {
  type TypeExpr (line 81) | pub enum TypeExpr {
  type Statement (line 93) | pub enum Statement {

FILE: src/codegen.rs
  type ModuleBuilder (line 7) | pub struct ModuleBuilder {
    method new (line 16) | pub fn new() -> Self {
    method compile_script (line 27) | pub fn compile_script(&mut self, def: &[ast::Statement]) -> js::Expr {
    method ml_scope (line 31) | fn ml_scope<T>(&mut self, cb: impl FnOnce(&mut Self) -> T) -> T {
    method fn_scope (line 44) | fn fn_scope<T>(&mut self, cb: impl FnOnce(&mut Self) -> T) -> T {
    method set_binding (line 58) | fn set_binding(&mut self, k: String, v: js::Expr) {
    method new_var_name (line 63) | fn new_var_name(&mut self) -> String {
    method new_temp_var (line 69) | fn new_temp_var(&mut self) -> js::Expr {
    method new_var (line 76) | fn new_var(&mut self, ml_name: &str) -> js::Expr {
    method new_scope_name (line 83) | fn new_scope_name(&mut self) -> String {
    method new_param_name (line 89) | fn new_param_name(&mut self) -> String {
  function compile (line 96) | fn compile(ctx: &mut ModuleBuilder, expr: &ast::Expr) -> js::Expr {
  function compile_let_pattern_flat (line 235) | fn compile_let_pattern_flat(ctx: &mut ModuleBuilder, out: &mut Vec<js::E...
  function compile_let_pattern (line 254) | fn compile_let_pattern(ctx: &mut ModuleBuilder, pat: &ast::LetPattern) -...
  function compile_statement (line 272) | fn compile_statement(ctx: &mut ModuleBuilder, exprs: &mut Vec<js::Expr>,...
  function compile_script (line 302) | fn compile_script(ctx: &mut ModuleBuilder, parsed: &[ast::Statement]) ->...
  function test (line 321) | fn test() {

FILE: src/core.rs
  type ID (line 8) | type ID = usize;
  type Value (line 11) | pub struct Value(ID);
  type Use (line 13) | pub struct Use(ID);
  type LazyFlow (line 15) | pub type LazyFlow = (Value, Use);
  type VTypeHead (line 18) | enum VTypeHead {
  type UTypeHead (line 41) | enum UTypeHead {
  function check_heads (line 68) | fn check_heads(
  type TypeNode (line 214) | enum TypeNode {
  type TypeCheckerCore (line 220) | pub struct TypeCheckerCore {
    method new (line 225) | pub fn new() -> Self {
    method flow (line 232) | pub fn flow(&mut self, lhs: Value, rhs: Use) -> Result<(), TypeError> {
    method new_val (line 251) | fn new_val(&mut self, val_type: VTypeHead, span: Span) -> Value {
    method new_use (line 258) | fn new_use(&mut self, constraint: UTypeHead, span: Span) -> Use {
    method var (line 265) | pub fn var(&mut self) -> (Value, Use) {
    method bool (line 272) | pub fn bool(&mut self, span: Span) -> Value {
    method float (line 275) | pub fn float(&mut self, span: Span) -> Value {
    method int (line 278) | pub fn int(&mut self, span: Span) -> Value {
    method null (line 281) | pub fn null(&mut self, span: Span) -> Value {
    method str (line 284) | pub fn str(&mut self, span: Span) -> Value {
    method bool_use (line 288) | pub fn bool_use(&mut self, span: Span) -> Use {
    method float_use (line 291) | pub fn float_use(&mut self, span: Span) -> Use {
    method int_use (line 294) | pub fn int_use(&mut self, span: Span) -> Use {
    method null_use (line 297) | pub fn null_use(&mut self, span: Span) -> Use {
    method str_use (line 300) | pub fn str_use(&mut self, span: Span) -> Use {
    method int_or_float_use (line 303) | pub fn int_or_float_use(&mut self, span: Span) -> Use {
    method func (line 307) | pub fn func(&mut self, arg: Use, ret: Value, span: Span) -> Value {
    method func_use (line 310) | pub fn func_use(&mut self, arg: Value, ret: Use, span: Span) -> Use {
    method obj (line 314) | pub fn obj(&mut self, fields: Vec<(String, Value)>, proto: Option<Valu...
    method obj_use (line 318) | pub fn obj_use(&mut self, field: (String, Use), span: Span) -> Use {
    method case (line 322) | pub fn case(&mut self, case: (String, Value), span: Span) -> Value {
    method case_use (line 325) | pub fn case_use(&mut self, cases: Vec<(String, (Use, LazyFlow))>, wild...
    method reference (line 330) | pub fn reference(&mut self, write: Option<Use>, read: Option<Value>, s...
    method reference_use (line 333) | pub fn reference_use(&mut self, write: Option<Value>, read: Option<Use...
    method null_check_use (line 337) | pub fn null_check_use(&mut self, nonnull: Use, span: Span) -> Use {
    method save (line 341) | pub fn save(&self) -> SavePoint {
    method restore (line 344) | pub fn restore(&mut self, mut save: SavePoint) {
  type SavePoint (line 350) | type SavePoint = (usize, reachability::Reachability);

FILE: src/js.rs
  type Op (line 4) | pub enum Op {
  function assign (line 21) | pub fn assign(lhs: Expr, rhs: Expr) -> Expr {
  function binop (line 24) | pub fn binop(lhs: Expr, rhs: Expr, op: Op) -> Expr {
  function call (line 27) | pub fn call(lhs: Expr, rhs: Expr) -> Expr {
  function comma_pair (line 30) | pub fn comma_pair(lhs: Expr, rhs: Expr) -> Expr {
  function unary_minus (line 33) | pub fn unary_minus(rhs: Expr) -> Expr {
  function eqop (line 36) | pub fn eqop(lhs: Expr, rhs: Expr) -> Expr {
  function field (line 39) | pub fn field(lhs: Expr, rhs: String) -> Expr {
  function lit (line 42) | pub fn lit(code: String) -> Expr {
  function ternary (line 45) | pub fn ternary(cond: Expr, e1: Expr, e2: Expr) -> Expr {
  function var (line 48) | pub fn var(s: String) -> Expr {
  function comma_list (line 52) | pub fn comma_list(mut exprs: Vec<Expr>) -> Expr {
  function println (line 62) | pub fn println(exprs: Vec<Expr>) -> Expr {
  function func (line 66) | pub fn func(arg: Expr, scope: String, body: Expr) -> Expr {
  function obj (line 70) | pub fn obj(spread: Option<Expr>, fields: Vec<(String, Expr)>) -> Expr {
  type Expr (line 83) | pub struct Expr(Expr2);
    method to_source (line 89) | pub fn to_source(mut self) -> String {
  type Token (line 99) | enum Token {
  type Precedence (line 106) | enum Precedence {
  type PropertyDefinition (line 125) | enum PropertyDefinition {
  type Expr2 (line 131) | enum Expr2 {
    method precedence (line 156) | fn precedence(&self) -> Precedence {
    method first (line 182) | fn first(&self) -> Token {
    method write (line 202) | fn write(&self, out: &mut String) {
    method wrap_in_parens (line 309) | fn wrap_in_parens(&mut self) {
    method ensure (line 316) | fn ensure(&mut self, required: Precedence) {
    method add_parens (line 322) | fn add_parens(&mut self) {

FILE: src/lib.rs
  function convert_parse_error (line 27) | fn convert_parse_error<T: Display>(mut sm: SpanMaker, e: ParseError<usiz...
  type State (line 55) | pub struct State {
    method new (line 67) | pub fn new() -> Self {
    method process_sub (line 80) | fn process_sub(&mut self, source: &str) -> Result<String, SpannedError> {
    method process (line 92) | pub fn process(&mut self, source: &str) -> bool {
    method get_output (line 106) | pub fn get_output(&mut self) -> Option<String> {
    method get_err (line 109) | pub fn get_err(&mut self) -> Option<String> {
    method reset (line 113) | pub fn reset(&mut self) {

FILE: src/main.rs
  function main (line 11) | fn main() {

FILE: src/reachability.rs
  type OrderedSet (line 4) | struct OrderedSet<T> {
  function insert (line 9) | fn insert(&mut self, value: T) -> bool {
  function iter (line 18) | fn iter(&self) -> std::slice::Iter<T> {
  type ID (line 23) | type ID = usize;
  type Reachability (line 26) | pub struct Reachability {
    method add_node (line 31) | pub fn add_node(&mut self) -> ID {
    method add_edge (line 38) | pub fn add_edge(&mut self, lhs: ID, rhs: ID, out: &mut Vec<(ID, ID)>) {
  function test (line 65) | fn test() {

FILE: src/spans.rs
  type Span (line 6) | pub struct Span(usize);
  type Spanned (line 8) | pub type Spanned<T> = (T, Span);
  type SpanManager (line 11) | pub struct SpanManager {
    method add_source (line 16) | pub fn add_source(&mut self, source: String) -> SpanMaker {
    method print (line 26) | pub fn print(&self, span: Span) -> String {
    method new_span (line 79) | fn new_span(&mut self, source_ind: usize, l: usize, r: usize) -> Span {
  type SpanMaker (line 87) | pub struct SpanMaker<'a> {
  function span (line 93) | pub fn span(&mut self, l: usize, r: usize) -> Span {
  type SpannedError (line 103) | pub struct SpannedError {
    method new1 (line 108) | pub fn new1(s1: impl Into<String>, s2: Span) -> Self {
    method new2 (line 113) | pub fn new2(s1: impl Into<String>, s2: Span, s3: impl Into<String>, s4...
    method print (line 119) | pub fn print(&self, sm: &SpanManager) -> String {
    method fmt (line 130) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

FILE: src/typeck.rs
  type Result (line 11) | type Result<T> = std::result::Result<T, SyntaxError>;
  type Scheme (line 14) | enum Scheme {
  type PolyLet (line 20) | struct PolyLet {
    method new (line 26) | fn new(saved_bindings: Bindings, saved_expr: ast::Expr, engine: &mut T...
    method check (line 36) | fn check(&mut self, engine: &mut TypeCheckerCore) -> Result<Value> {
  type PolyLetRec (line 44) | struct PolyLetRec {
    method new (line 50) | fn new(
    method check (line 64) | fn check(&mut self, engine: &mut TypeCheckerCore) -> Result<Vec<(Value...
  type UnwindPoint (line 88) | struct UnwindPoint(usize);
  type Bindings (line 89) | struct Bindings {
    method new (line 94) | fn new() -> Self {
    method get (line 101) | fn get(&self, k: &str) -> Option<&Scheme> {
    method insert_scheme (line 105) | fn insert_scheme(&mut self, k: String, v: Scheme) {
    method insert (line 110) | fn insert(&mut self, k: String, v: Value) {
    method unwind_point (line 114) | fn unwind_point(&mut self) -> UnwindPoint {
    method unwind (line 118) | fn unwind(&mut self, n: UnwindPoint) {
    method in_child_scope (line 129) | fn in_child_scope<T>(&mut self, cb: impl FnOnce(&mut Self) -> T) -> T {
  type TypeVarBindings (line 137) | struct TypeVarBindings {
    method new (line 143) | fn new() -> Self {
    method insert (line 150) | fn insert(&mut self, name: String, v: (Value, Use), span: Span) -> Opt...
  function parse_type (line 155) | fn parse_type(engine: &mut TypeCheckerCore, bindings: &mut TypeVarBindin...
  function parse_type_signature (line 331) | fn parse_type_signature(engine: &mut TypeCheckerCore, tyexpr: &ast::Type...
  function process_let_pattern (line 336) | fn process_let_pattern(engine: &mut TypeCheckerCore, bindings: &mut Bind...
  function check_expr (line 366) | fn check_expr(engine: &mut TypeCheckerCore, bindings: &mut Bindings, exp...
  function check_let_def (line 631) | fn check_let_def(
  function check_let_rec_defs (line 660) | fn check_let_rec_defs(
  function check_statement (line 680) | fn check_statement(engine: &mut TypeCheckerCore, bindings: &mut Bindings...
  type TypeckState (line 702) | pub struct TypeckState {
    method new (line 707) | pub fn new() -> Self {
    method check_script (line 714) | pub fn check_script(&mut self, parsed: &[ast::Statement]) -> Result<()> {

FILE: src/utils.rs
  function set_panic_hook (line 2) | pub fn set_panic_hook() {

FILE: tests/web.rs
  function pass (line 11) | fn pass() {