HazelTests.ListUtil
  ✅ rev_if with false
  ✅ rev_if with true
  ✅ dedup
  ✅ dedup_f
  ✅ group_by with constant function preserves list
  ✅ group_by groups into evens/odds
  ✅ group_by groups into mod 10 reverses group ordering
  ✅ range generates sequential integers [1,6)
  ✅ range defaults lower bound to 0
  ✅ range lo = hi is empty
  ✅ Invalid range raises error
  ✅ split with no found element returns the original list
  ✅ split with first found returns the head and tail
  ✅ splits on the middle element
  ✅ combine_opt
  ✅ join with empty list
  ✅ join with single element list
  ✅ join with multiple element list
  ✅ hd_opt with empty list
  ✅ hd_opt with non-empty list
  ✅ split_n_opt with empty list
  ✅ split_n_opt with non-empty list
  ✅ split_n_opt with out of bounds index
  ✅ split_n_opt with zero index
  ✅ split_n with empty list
  ✅ split_n with non-empty list
  ✅ split_n with out of bounds index
  ✅ split_n with zero index
  ✅ split_sublist_opt with empty list
  ✅ split_sublist_opt with non-empty list
  ✅ split_sublist_opt with out of bounds index
  ✅ split_sublist_opt with zero index
  ✅ split_sublist with empty list
  ✅ split_sublist with non-empty list
  ✅ split_sublist with out of bounds index
  ✅ split_sublist with zero index
  ✅ sublist with empty list
  ✅ sublist with non-empty list
  ✅ sublist with out of bounds index
  ✅ find with rest
  ✅ last_opt with empty list
  ✅ last_opt with single element
  ✅ last_opt with multiple elements
  ✅ last with single element
  ✅ last with multiple elements
  ✅ last with empty list raises exception
  ✅ map_alt with single x element
  ✅ map_alt alternates functions correctly
  ✅ map_alt with equal length lists raises exception
  ✅ map_alt with xs shorter than ys raises exception
  ✅ interleave with single x element
  ✅ interleave basic case
  ✅ interleave inherits map_alt length constraint
HazelTests.OptUtil
  ✅ get with Some
  ✅ get with None
  ✅ get_or_fail with Some
  ✅ get_or_fail with None
  ✅ get_or_raise with Some
  ✅ get_or_raise with None
  ✅ map2 with both Some
  ✅ map2 with first None
  ✅ map2 with second None
  ✅ some_if with true
  ✅ some_if with false
  ✅ zip with both Some
  ✅ zip with first None
  ✅ zip with second None
  ✅ unzip with Some
  ✅ unzip with None
  ✅ traverse with empty list
  ✅ traverse with all successful transformations
  ✅ traverse with one failure
  ✅ sequence with empty list
  ✅ sequence with all Some values
  ✅ sequence with one None value
  ✅ and_then with Some
  ✅ and_then with None
  ✅ replace with Some
  ✅ replace with None
  ✅ fold_left_opt with successful accumulation
  ✅ fold_left_opt with failure
  ✅ syntax let* with Some
  ✅ syntax let* with None
  ✅ syntax let+ with Some
  ✅ syntax let+ with None
  ✅ syntax and+ with both Some
  ✅ syntax and+ with one None
HazelTests.CsvUtil
  ✅ Basic csv with header
  ✅ Basic csv without header
HazelTests.Grammar
  ✅ Expression classes are correct
  ✅ Pattern classes are correct
  ✅ Type classes are correct
  ✅ Type pattern classes are correct
  ✅ Map annotation to something and back
HazelTests.ExpToSegment
  ✅ Literals
  ⚪ Negative ints
  ✅ Empty Ids on ExpToSegment constructor
  ✅ Tuple
  ✅ Basic Labeled Tuples
  ✅ Labels in types with single quotes
  ✅ Labels in  patterns with single quotes
  ✅ Function call with label arguments
  ✅ Doc page labeled tuple example
  ✅ Match statement
  ✅ Deferred application
  ✅ Test
  ✅ Filter
  ✅ Right associativity
  ✅ Unit type
  ✅ Function call
  ✅ Unit pattern
  ✅ Dot operator on float
  ✅ ProdProjection - basic product type
  ✅ ProdProjection - empty label
  ✅ ProdProjection - label with spaces
  ✅ ProdProjection - type variable
  ✅ ProdExtension - product types
  ✅ ProdExtension - type variables
  ✅ ProdExtension - with special labels
  ✅ Singleton unlabeled tuple
  ✅ Singleton unlabeled tuple type
HazelTests.LabeledTuple
  ✅ Singleton unlabeled
  ✅ Singleton labeled
  ✅ unlabeled remains same order
  ✅ fully labeled retains ordering
  ✅ Missing labels get added
  ✅ Present labels get reordered
  ✅ Partial labels get reordered
  ✅ Extra labels get reordered
  ✅ pair labeled, unlabeled
  ✅ Independent label sets with some overlap
  ✅ LabeledTuple get_duplicate_and_unique_labels
HazelTests.MakeTerm
  ✅ Integer Literal
  ✅ Float literal
  ✅ Empty Hole
  ✅ Free Variable
  ✅ Parenthesized Expression
  ✅ Floating operation
  ✅ Let Expression
  ✅ Function Application
  ✅ Named Function Definition
  ✅ Incomplete Function Definition
  ✅ Constructor
  ✅ Type Alias
  ✅ Singleton Labeled Tuple ascription in let
  ✅ Assigning labeled tuple to variable
  ✅ Multiple labels tuple
  ✅ Multiple labels in let tuple
  ✅ Unparenthesized labeled tuple element in list
  ✅ Malformed label in singleton tuple
  ✅ Quoted label in tuple
  ✅ Quoted label in projection
  ✅ Quoted label with non-alpha characters
  ✅ Tuple extension and function application precedence
  ✅ Quoted label in pattern
  ✅ Quoted label in type
  ✅ Dot projection with Quoted label
  ✅ Scientific notation floating point
  ✅ group_by_label flips variable to label sort
  ✅ Livelit name parsing
  ✅ Livelit ap parsing
  ✅ Product extension in ascription
  ✅ Singleton unlabeled tuple
  ✅ Multiple unlabeled tuple entries
  ✅ Explicit unlabeled in type
  ✅ Explicit unlabeled in pattern
HazelTests.MenhirParser
  ✅ Integer Literal
  ✅ Fun
  ✅ String Literal
  ✅ Bool Literal
  ✅ Empty Hole
  ✅ Var
  ✅ Parens
  ✅ bin_op
  ✅ Let
  ✅ Tuple
  ✅ Match
  ✅ If
  ✅ Deferred Ap
  ✅ Cons
  ✅ ListLit
  ✅ Unit
  ✅ Constructor
  ✅ Constructor ascription
  ✅ Constructor of specific sum type
  ✅ Constructor with Type Variable
  ✅ Type Variable
  ✅ Type Alias
  ✅ Test
  ✅ Filter
  ✅ List Concat
  ✅ times and divide precendence
  ✅ plus and minus precendence
  ✅ Integer Ops
  ✅ Float
  ✅ Float Ops
  ✅ Let binding with type ascription
  ✅ named_function
  ✅ basic sum type
  ✅ Fold Projector Exp
  ✅ Fold Projector Typ
  ✅ Fold Projector Pat
  ✅ Empty Type Hole
  ✅ Pattern with type ascription
  ✅ Type Hole in arrow ascription
  ✅ multiargument function
  ✅ partial sum type
  ✅ Function with type variable
  ✅ Sequence addition precedence
  ✅ And app precedence
  ✅ Negation precedence with multiplication
  ✅ Concatenation association
  ✅ and less than precedence
  ✅ Singleton labeled tuple
  ✅ Altered Documentation Buffer: Basic Reference
  ✅ Altered Documentation Buffer: Projectors
  ✅ Altered Documentation Buffer: Types & Static Errors
  ✅ Altered Documentation Buffer: adt dynamics
  ✅ Altered Documentation Buffer: Polymorphism
  ⚪ Prefixed keyword parses
  ⚪ Sum type messed up in make term
  ⚪ List concat and typap
  ⚪ Sum in product in typeap
  ⚪ Non-unique constructors currently throws in equality
  ✅ Menhir and maketerm are equivalent
  ✅ Menhir through ExpToSegment and back
HazelTests.StringUtil
  ✅ empty string splits
  ✅ split on empty string
  ✅ split with no matches
  ✅ split with one match
  ✅ split with multiple matches
  ✅ split with empty inbetweens
  ✅ regexp special character in separator
  ✅ compress string
  ✅ decompress string
  ✅ sanitize
  ✅ trim trailing whitespace should not trim leading whitespace
HazelTests.PatternMatch
  ✅ Labeled Tuple with casts
HazelTests.Typ.join
  ✅ Typ join on polymorphic types
  ✅ Typ join on product projection with fully known types
  ✅ Typ join on product projection with unknown types
  ✅ Typ join on product projection with unknown label
  ✅ Typ join on product extension with fully known extension types
  ✅ Typ join on two product extensions with known extension types
HazelTests.Typ.fast_equal
  ✅ Equality alpha equivalent
HazelTests.Info.status_typ
  ✅ Typ join on polymorphic types
  ✅ EmptyHole under LabelExpected => EmptyLabel
  ✅ EmptyHole under TypeExpected => Type(ty)
  ✅ MultiHole => ParseFailure
  ✅ Var alias under TypeExpected => TypeAlias
  ✅ Free type var under TypeExpected => FreeTypeVariable
  ✅ Abstract tvar under TypeExpected => Type(Var)
  ✅ Var non-label under LabelExpected => WantLabel
  ✅ Var under ConstructorExpected Unique => Variant(name, sum)
  ✅ Var under ConstructorExpected Duplicate => DuplicateConstructor
  ✅ Label under TypeExpected => Type(ty)
  ✅ Label under LabelExpected Unique => Type(ty)
  ✅ Label under LabelExpected Duplicate (present) => Duplicate
  ✅ Label under LabelExpected Duplicate (absent) => WantLabel
  ✅ Label under LabelProjectionExpected (included) => Type(ty)
  ✅ Label under LabelProjectionExpected (not included) => InvalidLabel
  ✅ Label under ConstructorExpected => WantConstructorFoundType
  ✅ Label under VariantExpected => WantConstructorFoundType
  ✅ Other type under TypeExpected => Type(ty)
  ✅ Other type under LabelExpected => WantLabel
  ✅ Other type under LabelProjectionExpected => WantLabel
  ✅ Other type under ConstructorExpected => WantConstructorFoundType
HazelTests.Statics.Functions
  ✅ Function with unknown param
  ✅ Function with known param
  ✅ Function with labeled param
  ✅ bifunction
  ✅ bifunction
  ✅ function application
  ✅ function deferral
  ✅ Fixpoint in function position
  ✅ Deferrals applied to known type
  ✅ Deferrals applied to unknown type
  ✅ Wrong number of deferrals
  ✅ Unknown arg could be any arity for deferrals
  ✅ Deferral outside of function args
HazelTests.Statics.Tuples
  ✅ Typechecking fails for unlabeled variable being assigned to labeled tuple
  ✅ Assigning labeled tuple to variable
  ✅ Singleton Labeled Tuple ascription in let
  ✅ Singleton Labeled Tuple ascription in let with wrong type should fail
  ✅ Singleton Labeled Tuple with specified label
  ✅ Labeled tuple with multiple labels
  ✅ Let statement that adds labels during elaboration
  ✅ Duplicate singleton labels
  ✅ Reconstructed labeled tuple without values
  ✅ Singleton labeled argument let with unknown type
  ✅ nested different singleton labeled arguments
  ✅ nested different singleton labeled arguments
  ✅ Singleton labeled argument function application with unknown type
  ✅ Singleton labeled argument function application with no labeled param
  ✅ Singleton labeled argument not labeled in pattern
  ✅ Unknown label in last position
  ✅ Duplicate label synthesis
  ✅ Bad label projection
  ✅ Singleton Bad label synthesis
  ✅ Bad label synthesis
  ✅ Extra Label
  ✅ tuple ascribed to non-tuple
  ✅ Projection from list of labeled tuples
  ✅ Projection of labeled tuple with annotation
  ✅ Projection of labeled tuple list with annotation
  ✅ Label not in tuple
  ✅ Projection of unknown
  ✅ Projection of list of unknown
  ✅ Tuple extension
  ✅ Tuple extension with type alias
  ✅ Tuple extension with non-tuple args
  ✅ Tuple extension with hole
  ✅ Tuple extension with hole in label position
  ✅ Consistent Type-level product projection
  ✅ Inconsistent Type-level product projection
  ✅ Missing label projection
  ✅ Explicitly unlabeled tuple in let binding
  ✅ Multiple elements explicitly unlabeled
  ✅ Explicitly unlabeled elements with implicit type
  ✅ Implicitly unlabeled elements with explicitly unlabeled types
  ✅ Marks are placed on elements
  ✅ Explicitly unlabeled tuple extension
HazelTests.Statics.Lists
  ✅ A @ A
  ✅ Free variable list concatenation
  ✅ list cons inconsistent tail
  ✅ list cons consistent tail
HazelTests.Statics.Polymorphism
  ✅ Example error annotations
  ✅ Forall alpha equivalent in ascription
  ✅ Forall alpha equivalent in let
  ✅ Polymorphic Equality type inconsistency 1
  ✅ Polymorphic Equality type inconsistency 2
  ✅ Polymorphic Equality type inconsistency 3
  ✅ Polymorphic Equality type inconsistency 4
  ✅ Polymorphic Equality type inconsistency 5
  ✅ Polymorphic Equality type inconsistency 6
  ✅ Polymorphic Equality type contains arrow 1
  ✅ Polymorphic Equality type contains arrow 2
  ✅ Polymorphic Equality type contains arrow 3
  ✅ Polymorphic Equality type contains arrow 4
  ✅ Polymorphic Equality type contains arrow 5
  ✅ Polymorphic Equality type contains arrow 6
  ✅ Polymorphic Equality type contains arrow 7
HazelTests.Statics.Sums
  ✅ nested_sum_constructors
  ✅ type hole
  ✅ single null sum type
  ✅ single sum type
  ✅ partial sum type
  ✅ double alias
  ✅ vertical leading
  ✅ tuple as type name
  ✅ not a sum
  ✅ shadows base type
  ✅ unbound type var
  ✅ base type instead of constructor
  ✅ base type instead of constructor in ap
  ✅ parenthesis instead of constructor
  ✅ ap instead of constructor
  ✅ unbound type var in compound alias
  ✅ analytic sum types
  ✅ unbound type var in function
  ✅ analytic sum types in function
  ✅ unbound type var in sum
  ✅ analytic sum types in sum
  ✅ analytic sum types in sum with cons
  ✅ unbound type var in sum with cons
  ✅ analytic shadowing
  ✅ exp tests: happy
  ✅ inconsistent type with arrow
  ✅ undefined constructor
  ✅ type incons with string
  ✅ constructor missing argument
  ✅ pattern constructor tests: happy
  ✅ pattern constructor tests: errors
  ✅ pattern constructor tests: undefined
  ✅ pattern constructor tests: type incons
  ✅ pattern constructor tests: type incons
  ✅ pattern constructor tests: type incons
  ✅ pattern constructor tests: type incons
  ✅ pattern constructor tests: type incons
  ✅ constructor with unneeded argument
  ⚪ Known Bug: bad type name
  ⚪ Known Bug: duplicate constructors
  ⚪ Known Bug: invalid constructor
HazelTests.Statics.Types
  ⚪ Known Bug: Typ.weak_head_normalize infinite recursion
  ⚪ Known Bug: Coverage.all_ctrs_of_typ infinite recursion
  ⚪ Known Bug: all_ctrs_of_type called with a non-normalized type
  ⚪ Known Bug: Type join of ap
HazelTests.Statics.Builtins.to_lvs
  ✅ to_lvs operation with elements of the same type
  ✅ to_lvs operation with type alias and autolabels
  ✅ to_lvs operation with missing labels
  ✅ to_lvs operation applied to non-tuple
  ✅ to_lvs operation applied to value with unknown type
  ✅ to_lvs operation applied to tuple with unknown entry
  ✅ to_lvs operation with hole in tuple label position
HazelTests.Statics.Builtins.project_labels
  ✅ project_labels with appropriate labels
  ✅ project_labels with single appropriate labels
  ✅ project_labels with non-label
  ✅ project_labels with holes for labels
  ✅ project_labels with label not in tuple
  ✅ project_labels with a single tuple and no labels
  ✅ project_labels with a single tuple in parens and no labels
  ✅ project_labels called with single arg
  ✅ project_labels with no args
  ✅ project_labels with first arg unknown type
  ✅ project_labels with hole in tuple label position
  ✅ project labels with a single labeled entry
  ✅ project_labels with deferral as first arg
  ✅ project_labels with deferral in subsequent args
  ✅ project_labels with single deferral - arity error
HazelTests.Statics.Builtins.select_labels
  ✅ select_labels with appropriate labels
  ✅ select_labels with more appropriate labels
  ✅ select_labels with non-label
  ✅ select_labels with holes for labels
  ✅ select_labels with label not in tuple
  ✅ select_labels with a single tuple and no labels
  ✅ select_labels called with single arg
  ✅ select_labels with no args
  ✅ select_labels with first arg unknown type
  ✅ select_labels with hole in tuple label position
  ✅ select_labels with deferral as first arg
  ✅ select_labels with deferral in subsequent args
  ✅ select_labels with single deferral - arity error
HazelTests.Statics.Builtins.group_by_label
  ✅ group_by_label with single tuple
  ✅ group_by_label with multiple tuples
  ✅ group_by_label with missing label
  ✅ group_by_label with non-string pivot field
  ✅ group_by_label with non-label second argument
  ✅ group_by_label with non-list first argument
  ✅ group_by_label with extra arguments
  ✅ group_by_label with hole in tuple label position
  ✅ primitive pivot with unknown type in first arg
  ✅ primitive pivot with unknown type inside list
  ✅ primitive pivot with ascription to unknown in label position
  ✅ group_by_label with single deferral - arity error
  ✅ group_by_label with three deferrals - arity error
HazelTests.Statics.Builtins.omit_labels
  ✅ omit_labels with appropriate labels
  ✅ omit_labels with non-label
  ✅ omit_labels with holes for labels to omit
  ✅ omit_labels with label not in tuple
  ✅ omit_labels with hole in tuple label position
  ✅ omit_labels with a single tuple and no labels
  ✅ omit_labels called with single arg
  ✅ omit_labels with no args
  ✅ omit_labels with first arg unknown type
  ✅ Omit labels with non-labeled elements
  ✅ omit_labels to singleton unlabeled
  ✅ omit_labels with deferral as first arg
  ✅ omit_labels with deferral in subsequent args
  ✅ omit_labels with single deferral - arity error
  ✅ omit_labels with no args - arity error
HazelTests.Statics.Builtins.omit_all_labels
  ✅ Omit all labels with some labels
  ✅ omit_all_labels to singleton
  ✅ Omit all labels with type alias and autolabels
  ✅ Omit all labels operation with no labels
  ✅ Omit all labels applied to non-tuple
  ✅ Omit all labels operation applied to value with unknown type
  ✅ Omit all labels operation with hole in tuple label position
HazelTests.Statics.Builtins.from_lvs
  ✅ From labeled values with list of tuples
  ✅ From labeled values with list of tuples and multiple entries
HazelTests.Statics.Fixpoint
  ✅ Fixpoint with no arguments
HazelTests.Statics.Properties
  ✅ Statics does not crash
HazelTests.Elaboration tests
  ✅ Single integer
  ✅ Empty hole
  ✅ Free variable
  ✅ Let expression
  ✅ Consistent if statement
  ✅ An unapplied function
  ✅ Application of function on free variable
  ✅ Inconsistent case statement
  ✅ Let expression for a function
  ✅ Function application with a deferred argument
  ✅ Function application with a single remaining argument after deferral
  ✅ Inconsistent type ascription
  ✅ Inconsistent let ascription
  ✅ Inconsistent list ascription
  ✅ Inlines type aliases
  ✅ Function application with a deferral of a hole
  ✅ Labeled tuple elaboration
  ✅ Rearranged labeled tuple
  ✅ Singleton labeled tuple adds labels
  ✅ Singleton labeled tuple
  ✅ Singleton labeled tuple analysis adds label
  ✅ Singleton labeled tuple analysis adds label with type alias
  ✅ Singleton labeled tuple analysis adds label with type alias
  ✅ Singleton labeled argument function application with known type
  ✅ Singleton labeled argument function application with no label in ap
  ✅ nested different singleton labeled arguments
  ✅ Singleton labeled argument function application with unknown type
  ✅ Singleton labeled argument let with unknown type
  ✅ Automatically add label in pattern inside type annotation
  ✅ Does not add labels with different cardinality
  ⚪ Known Bug: Nontermination in typ normalization
  ⚪ Known Bug: Invalid typ ap
  ⚪ Known Bug: Type join of ap
  ✅ Elaboration does not crash
HazelTests.Menhir elaboration tests
  ✅ Filter test (menhir)
  ✅ Test failed (menhir)
  ✅ Dynamic error hole (menhir)
  ✅ Constructor test (menhir)
  ✅ Type ap test (menhir)
  ✅ Let expression for a tuple (menhir)
  ✅ Single integer (menhir)
  ✅ Empty hole (menhir)
  ✅ Free var (menhir)
  ✅ Bin op (menhir)
  ✅ Consistent if (menhir)
  ✅ Undefined test (menhir)
  ✅ List exp (menhir)
  ✅ Invalid test (menhir)
  ✅ Type alias test (menhir)
  ✅ List concat test (menhir)
  ✅ Unary operation test (menhir)
  ✅ Sequence test (menhir)
  ✅ FixF test (menhir)
HazelTests.Evaluator.LabeledTuples
  ✅ Automatic label insertion in pattern for labeled tuple
  ✅ Ascription removal for labels in let pattern
  ✅ Labeled tuple field access
  ✅ Anonymous function with explicit label
  ✅ Anonymous function without explicit label
  ✅ Inconsistent labels
  ✅ Dot operation for missing label
  ✅ Desructuring labeled tuple
  ✅ Labeled tuple projection
  ✅ hole field projection
  ✅ Indet projection
  ✅ Extension
  ✅ labeled tuple multi-label selection
  ✅ labeled tuple multi-label projection
  ✅ Omit labels
  ✅ Omit all labels
  ✅ Explicitly unlabeled tuple entry
HazelTests.Evaluator.Probes
  ✅ Simple probe
  ✅ Probes in factorial function
  ✅ Evaluate probe around inferred labeled tuple
  ✅ Evaluate probe around inferred labeled tuple
  ✅ Evaluate probe around inferred singleton labeled tuple in pattern
  ✅ Probe around ascription to unknown type
HazelTests.Evaluator.Livelit
  ✅ Ensure evaluation of livelit is as expected
HazelTests.Evaluator.Builtins
  ✅ Builtin Function application
  ✅ Multi-arg builtin with ascription
  ✅ String_concat builtin
  ✅ Multi arg builtin ascription
  ✅ string_escaped
  ✅ string_uppercase
  ✅ string_lowercase
  ✅ string_capitalize
  ✅ string_uncapitalize
  ✅ string_match true
  ✅ string_match false
  ✅ string_replace
  ✅ string_search found
  ✅ string_search not found
HazelTests.Evaluator.ListBuiltins
  ✅ length of empty list
  ✅ length of multi-element list
  ✅ map with identity function
  ✅ map with increment function
  ✅ filter even numbers
  ✅ fold_left sum
  ✅ flat_map duplicate elements
  ✅ zip two lists
  ✅ unzip list of pairs
  ✅ reverse list
  ✅ take first two elements
  ✅ drop first two elements
  ✅ range from 1 to 3
  ✅ enumerate list
  ✅ any with true predicate
  ✅ all with false predicate
  ✅ intersperse with separator
  ✅ cons element to list
  ✅ hd of non-empty list
  ✅ tl of non-empty list
  ✅ is_empty of empty list
  ✅ nth element at index 1
  ✅ fold_right subtract
  ✅ append two lists
  ✅ concat list of lists
  ✅ mapi with index
  ✅ filteri even indices
  ✅ mem element in list
  ✅ partition even and odd
  ✅ rev_append reversed list
  ✅ fold_left2 sum pairs
  ✅ fold_right2 subtract pairs
  ✅ map2 add pairs
  ✅ all2 compare pairs
  ✅ any2 find equal pairs
  ✅ find first even number
  ✅ take_while positive numbers
  ✅ drop_while positive numbers
  ✅ init with identity function
  ✅ init with square function
  ✅ init empty list
  ✅ slice middle of list
  ✅ slice from beginning
  ✅ slice to end
  ✅ slice empty result
  ✅ slice with length 0
  ✅ filter_map with Some values
  ✅ nth_opt valid index
  ✅ nth_opt invalid index
  ✅ find_opt found element
  ✅ find_opt not found
  ✅ find_index found element
  ✅ find_index not found
  ✅ find_map found element
  ✅ find_map not found
  ✅ find_mapi found element
  ✅ find_mapi not found
  ✅ hd_opt of non-empty list
  ✅ hd_opt of empty list
  ✅ tl_opt of non-empty list
  ✅ tl_opt of empty list
  ✅ assoc found key
  ✅ assoc_opt found key
  ✅ assoc_opt not found
  ✅ mem_assoc found key
  ✅ mem_assoc not found
  ✅ remove_assoc removes first occurrence
  ✅ remove_assoc removes all occurrences
  ✅ remove_assoc key not found
  ✅ partition_map with Left and Right values
  ✅ partition_map with all Left values
  ✅ partition_map with all Right values
  ✅ partition_map with empty list
  ✅ sort empty list
  ✅ sort singleton list
  ⚪ sort sorted list of 2 numbers
  ⚪ sort unsorted list of 2 numbers
  ⚪ sort unsorted list of 3 numbers
  ⚪ sort ascending
  ⚪ sort descending
HazelTests.Evaluator.OptionType
  ✅ Option type is available in context
  ✅ Option type Some constructor
  ✅ Option type pattern matching
  ✅ option_map with Some value
  ✅ option_map with None
  ✅ option_bind with Some value
  ✅ option_bind with None
  ✅ option_bind with function returning None
  ✅ option_to_list with Some value
  ✅ option_to_list with None
HazelTests.Evaluator.Case
  ✅ Case expression with constructors of different type
  ✅ Case expression with constructors with payloads
  ✅ Case expression with constructors with payloads
  ✅ Case expression with constructors with payloads and recursive types
  ✅ Inconsistent pattern ascription in case expression
  ✅ Inconsistent pattern match
  ✅ Unevaluated if closure
  ✅ Ascriptions collapse lazily through if
  ✅ Indet case passes ascriptions through
  ✅ Indet case of different arity tuples
  ✅ Preservation of type with unknown in if expression
  ✅ Preservation of type with unknown in case expression
HazelTests.Evaluator.Functions
  ✅ Function deferral
  ✅ Ascribed lambda applied
  ✅ eg
  ✅ Deferral applied to hole
  ✅ Deferral applied to unknown type
  ✅ Ascription around deferral
  ✅ Variable capture
  ✅ Unbound lookup
  ✅ Typfun application
  ✅ ADT Buffer
  ✅ Single deferral produces single value not singleton tuple
HazelTests.Evaluator.Fixpoints
  ✅ Inconsistent type in fixpoint pattern
  ✅ Fixpoint with boolean short circuiting
  ✅ Fixpoint with function
  ✅ Mutual recursion
  ✅ Fixpoint with wildcard unit type
  ✅ Fixpoint pattern ascription
  ✅ Fixpoint with type ascription
  ✅ Substitution
  ✅ Mutual recursion substitution
  ✅ Fixpoint that evaluates to the correct form
HazelTests.Evaluator.List
  ✅ Ascription goes through cons
  ✅ Inconsistent list ascription
  ✅ List ascription through indet cons
  ✅ Ascription through indet list concatenation
  ✅ Inconsistent list ascription with alias
  ✅ List cons passes type inside
HazelTests.Evaluator.Atom
  ✅ Integer literal
  ✅ Use
  ✅ Inconsistent type ascription
  ✅ Consistent type ascription
  ✅ Type-directed
HazelTests.Evaluator.Let
  ✅ Inconsisent type ascription on let
HazelTests.Evaluator.Operators
  ✅ Integer sum
  ✅ Negative integer literal
  ✅ Inconsistent type ascription in subterm
  ✅ Ascriptions around indet operators collapse
HazelTests.Evaluator.Poly_Equal
  ✅ Basic Polymorphic
  ✅ Polymorphic Equality Type Inconsistency Dynamics
HazelTests.Evaluator.SumTypes
  ✅ Ascribed constructor
  ✅ Constructors can pass through consistent ascriptions
  ✅ Constructors don't pass through inconsistent ascriptions
  ✅ Invalid constructor match
  ✅ Historical unboxing failures
HazelTests.Evaluator.BuiltinsTupleOperations
  ✅ Projection from list of labeled tuples
  ✅ Primitive pivot of list of labeled tuple
  ✅ Projection of pivoted list of labeled tuples
  ✅ Nested projection of pivoted list of labeled tuples
  ✅ Pivoting list bound to variable
  ✅ pivoted list of labeled tuples with multiple entries
  ✅ lvs labeled tuple with multiple entries
  ✅ Intermediate cast doesn't break evaluation
  ✅ Minimized to_lvs
  ✅ Projection of labeled values
  ✅ From labeled values with singleton list of tuples
  ✅ From labeled values with multiple entries
  ✅ From labeled values with empty list
  ✅ From labeled values with bad data
  ✅ From labeled values with label holes
  ✅ Project labels to singleton
  ✅ Omit labels to unlabeled singleton
  ✅ Omit all labels to singleton
HazelTests.Evaluator.TypAp
  ✅ Explicit polymorphism with type alias
HazelTests.Evaluator.Stepper
  ✅ Simple arithmetic
  ✅ Simple arithmetic with unboxing
  ✅ Single step ascription of list
HazelTests.Evaluator.Properties
  ✅ Evaluator does not crash
  ✅ Evaluator and stepper are consistent
  ✅ Pattern equivalence
HazelTests.Evaluator.Performance
  ✅ lists don't accumulate from patterns
HazelTests.Editing.Basic
  ✅ Initialize caret position from string
  ✅ Paste string duo-splitting empty tuple
  ✅ Paste string splitting token
  ✅ Paste string splitting consecutive delimiters
  ✅ Paste string with a backpack glom false friend
  ✅ Split two prefix op !s into bin op !!
  ✅ Delete leading constructor in sum type with prefix plus
  ✅ Split ++ op in type sort context
  ✅ Split !! infix op !s into prefix ops !]
  ✅ Merge 2 prefix ops ! into infix op !!
  ✅ Merge + + ops in type sort context
HazelTests.Editing.Insertion
  ✅ Insert whitespace
  ✅ Insert comment
  ✅ Insert string
  ✅ Insert string after concave grout
  ✅ Insert char at end of token
  ✅ Insert char at start of token
  ✅ Insert char inside token
  ✅ Inserting string quote inserts closing quote as well
  ✅ Delimiter prefix molding 1
  ✅ Delimiter prefix molding 2
  ✅ Delimiter prefix molding 3
  ✅ Split empty list
  ✅ Split case end
  ✅ Split number literal
  ✅ Split 1st and 2nd delims of 3-delim form with space
  ✅ Split mono child and 2nd delim of 3-delim form
  ✅ Split 1st and 2nd delims of 3-delim form with instant expander
  ✅ Split two leading delated expander delims with bin op
  ✅ Inserting if before existing if doesn't steal delimiters
  ✅ Inserting let before existing let doesn't steal delimiters
  ✅ Inserting let before existing type doesn't steal delimiters
  ✅ Split 2nd delim of 3-delim form with space
  ✅ Amphibious Plus 0
  ✅ Amphibious Plus - At End - 1
  ✅ Amphibious Plus - At End - 2
  ✅ Amphibious Plus - At End - 3
  ✅ Amphibious Plus - At End - 4
  ✅ Amphibious Plus - At End - 5
  ✅ Amphibious Plus - Before - 1
  ✅ Amphibious Plus - Before - 2
  ✅ Amphibious Plus - Before - 3 (Prelude)
  ✅ Amphibious Plus - Before - 3
  ✅ Amphibious Plus - Before - 4
  ✅ Insert between non-leading delims when leading in backpack
  ✅ Insert let binding before prefix negation
  ✅ Prepending to leading delimiter: if
  ✅ Prepending to middle delimiter: if
  ✅ Prepending to trailing delimiter: if
  ✅ Within leading delimiter: if
  ✅ Within middle delimiter: if
  ✅ Within trailing delimiter: if
  ✅ Postpending to leading delimiter: if
  ✅ Postpending to middle delimiter: if
  ✅ Postpending to trailing delimiter: if
  ✅ Grout inserted on correct side of caret when adding if before
  ✅ Split ap (Make sure outside gets remolded)
  ✅ Prelude for: Merge across concave grout on insert
  ✅ Merge across concave grout on insert
  ✅ Nested parens edge case (See Insert.parens_edge_case)
  ✅ Issue #1914 regression test
  ✅ Forall regrouting edge case (debatable behavior) (#1913)
  ✅ Forall regrouting edge case (non-debatable) (#1913)
  ✅ Split paren rematch (Regression guard for #1948)
HazelTests.Editing.Destruction
  ✅ Delete comment
  ✅ Delete string
  ✅ Deleting comment delimiter deletes comment
  ✅ Deleting string delimiter deletes string
  ✅ Delete char from token by backspacing
  ✅ Merge to empty list by backspacing
  ✅ Merge to empty tuple by deleting
  ✅ Merge number literals across bin op by backspacing
  ✅ Destruct leading delim in convex 2-form
  ✅ Destruct leading delim in prefix 3-form
  ✅ Amphibious Plus Destruct 1
  ✅ Amphibious Plus Destruct 2
  ✅ Amphibious Plus Destruct 3
  ✅ Amphibious Plus Destruct 4
  ✅ Amphibious Plus Destruct 5
  ✅ Amphibious Plus Destruct 6
  ✅ Amphibious Plus Destruct 7
  ✅ Amphibious Plus Destruct 8
  ✅ Amphibious Plus Destruct 8
  ✅ Amphibious Plus Destruct 9
  ✅ Amphibious Plus Destruct 10
  ✅ Regrouting edge case 1
  ✅ Regrouting edge case 2
  ✅ Inner Caret position maintenance
  ✅ Within leading delimiter: if
  ✅ Within middle delimiter: if
  ✅ Within trailing delimiter: if
  ✅ At end of leading delimiter: if
  ✅ At end of middle delimiter: if
  ✅ At end of trailing delimiter: if
HazelTests.Editing.Move
  ✅ Caret movement by token 1
  ✅ Caret movement by token 2
  ✅ Caret movement by token 3
  ✅ Caret movement by token 4
  ✅ Caret movement by token 5
  ✅ Caret movement by token 6
  ✅ Caret movement by token 7
  ✅ Caret movement by token 8
  ✅ Caret movement by token 9
  ✅ Caret movement by token 10
  ✅ Caret movement by token 11
  ✅ Caret movement by token Left 1
  ✅ Caret movement by token Left 2
  ✅ Caret movement by token Left 3
  ✅ Caret movement by token Left 4
  ✅ Caret movement by token Left 5
  ✅ Caret movement by token Left 6
  ✅ Caret movement by token Left 7
  ✅ Caret movement by token Left 8
  ✅ Caret movement by token Left 9
  ✅ Caret movement by token Left 10
  ✅ Caret movement by token Left 11
  ✅ ByToken escapes token left
  ✅ ByToken escapes token right
  ✅ Caret movement 3-delim R 1
  ✅ Caret movement 3-delim R 2
  ✅ Caret movement 3-delim R 3
  ✅ Caret movement 3-delim L 1
  ✅ Caret movement 3-delim L 2
  ✅ Caret movement 3-delim L 3
  ✅ Caret movement takes into account which shards are down - Right
  ✅ Caret movement takes into account which shards are down - Left
HazelTests.Editing.Selection
  ✅ Move to right from selection
  ✅ Select term with selection
  ✅ Select term from right
  ✅ Select subterm with selection
  ✅ Select term with let binding does not select body
  ✅ Select term when on comma in tuple selects whole tuple
  ✅ Move to left from selection starting at left
  ✅ Move to left from selection starting at right
  ✅ Move to right from selection starting at right
  ✅ Move to right from selection starting at right
  ✅ ht by token from selection
  ✅ Move left by token from selection
  ✅ Move left by token when selecting everything
  ✅ Move right by token when selecting everything
  ✅ Move extreme left with multiline selection
  ✅ Extend selection left by token
HazelTests.Editing.Indentation
  ✅ Top level doesn't auto indent
  ✅ Bidelimited context same-line terminator indents
  ✅ Double bidelimited context same-line terminator doesn't double indents
  ✅ Nested bidelimited contex with linebreaks
  ✅ let
  ✅ if then else
  ✅ if expression in bidelimited context
  ✅ Bidelimited context indents
  ✅ Double bidelimited context doesn't double indents
  ✅ Operators don't indent 1
  ✅ Operators don't indent 2
  ✅ Operators in nested context
  ✅ Function application
  ✅ Nested function application
  ✅ Case rules with and without linebreaks after `=>`
  ✅ Nested cases
  ✅ Even: commas, function literals, if expression
  ✅ Indentation of Complete Tuples 1
  ✅ Indentation of Complete Tuples 2
  ✅ Indentation of Complete Tuples 3 (Commas reset)
  ✅ Indentation of Complete Tuples 3 (Commas on own linereset)
  ✅ Indentation Incomplete Flow 0
  ✅ Indentation Incomplete Flow 1
  ✅ Indentation Incomplete Flow 2
  ✅ Indentation Incomplete Flow 3
  ✅ Indentation Incomplete Flow 4
  ✅ Indentation - Wrapping immediate next lines
  ✅ Indentation - Don't wrap over blank line 1
  ✅ Indentation - Don't wrap over blank line 2
  ✅ Commas should reset indentation
HazelTests.Pattern Coverage Checker
  ✅ Bare let has no error on pattern
  ✅ Bare fun has no error on pattern
  ✅ Annotated let has no error on pattern
  ✅ Annotated fun has no error on pattern
  ✅ Let binding a tuple has no error on pattern
  ✅ Fun binding a tuple has no error on pattern
  ✅ Annotated let binding a tuple has no error on pattern
  ✅ Annotated fun binding a tuple has no error on pattern
  ✅ Peanut Figure 1a: Exhaustive + Irredundant Tree
  ✅ Peanut Figure 1b: Inexhaustive + Redundant (Second Pattern)
  ✅ Peanut Figure 2a: Indeterminately Exhaustive
  ✅ Peanut Figure 2b: Necessarily Exhaustive
  ✅ Peanut Figure 2c: Necessarily Exhaustive
  ✅ Peanut Figure 3a: Necessarily Irredundant (first two patterns) + Indeterminately Redundant (third pattern)
  ✅ Peanut Figure 3b: Necessarily Redundant (third pattern)
  ✅ Loooong List: Exhaustive
  ✅ List: Inexhaustive Nil
  ✅ List: Inexhaustive Cons
  ✅ List: Inexhaustive Cons Long
  ✅ List: Inexhaustive In Tuple with Second Element
  ✅ List: Inexhaustive Triple
  ✅ List: Inexhaustive In Triple with First Element
  ✅ List: Inexhaustive List Middle Element In Quad
  ✅ Integers: Exhaustive
  ✅ Integers: Non-Exhaustive
  ✅ Integers: Non-Exhaustive Tuple
  ✅ Integers: Redundant
  ✅ Floats: Exhaustive
  ✅ Floats: Non-Exhaustive
  ✅ Floats: Non-Exhaustive Tuple
  ✅ Floats: Redundant
  ✅ Strings: Exhaustive
  ✅ Strings: Non-Exhaustive
  ✅ Strings: Non-Exhaustive Empty
  ✅ Strings: Non-Exhaustive Tuple
  ✅ Strings: Redundant
  ✅ Bools: Exhaustive
  ✅ Bools: Non-Exhaustive
  ✅ Bools: Redundant
  ✅ Unit: Exhaustive
  ✅ Unit: Redundant
  ✅ Rank Compare -- Andrew's Example from Issue #1473
  ✅ Rank Compare -- Andrew's Example from Issue #1473 with cases removed
  ✅ Rank Compare -- Let Inexhaustive
  ✅ Rank Compare -- Fun Inexhaustive
  ✅ Nested Constructors: Inexhaustive
  ✅ Multiple Holes: Irredundant
  ✅ Unknown Scrutinee is Exhaustive
  ✅ Unknown Scrutinee is Exhaustive
  ✅ Unknown Scrutinee: Tuples of Many Lengths
  ✅ Partially Unknown Scrutinee: Inxhaustive
  ✅ Partially Unknown Scrutinee: Redundancy
  ✅ Labeled Tuple Exhaustiveness Stress Test
  ✅ Labeled Tuple Inexhaustiveness Stress Test
  ✅ Labeled Tuple Redundancy Stress Test
  ✅ Function Scrutinee
  ✅ Exhaustive fun w/ labeled tuple
  ✅ Exhaustive Int Tuples with Wilds
  ✅ Exhaustive Strings Tuples with Wilds
  ✅ Exhaustive Bools Tuples with Wilds
HazelTests.Unboxing
  ✅ ListLit to ListLit
  ✅ ListLit to ListLitn, incorrect length
  ✅ Cons to ListLit
  ✅ Ascribed Hole to ListLit
  ✅ ListLit to ListLitn, correct length
  ✅ Cons to ListLitn, length > cons: indet match
  ✅ Cons to ListLitn, length < cons: does not match
  ✅ ListLitn to Cons, correct length
  ✅ Ascribed Hole to ListLitn
  ✅ ListLit to Cons: empty tail
  ✅ ListLit to Cons: non-empty tail
  ✅ EmptyList to Cons
  ✅ Cons to Cons
  ✅ Ascribed Hole to Cons
  ✅ Unboxing integer
  ✅ Pivot request
  ✅ Dot projection of casted tup label
HazelTests.Introduce.introduce_expression
  ✅ Arrow type
  ✅ Product types
  ✅ Labeled tuples
  ✅ Singleton Variant
  ✅ Type fun
  ✅ String
  ✅ List
HazelTests.Introduce.introduce.expression
  ✅ Tuple
  ✅ Function
  ✅ Already parenthesized tuple
  ✅ Nested tuple
  ✅ Explicit hole
  ✅ Singleton variant
HazelTests.Introduce.introduce.pattern
  ✅ Tuple Pattern
  ✅ Tuple Pattern already parenthesized
  ✅ Singleton Variant
HazelTests.DocSlides.ReparseBackuptext
  ✅ Projectors
  ✅ ADTs
  ✅ Tuples
  ✅ Tables
  ✅ Polymorphism
  ✅ Cards
  ✅ Probes
  ✅ Livelits
  ✅ B2T2 / Datasheet
  ✅ B2T2 / Example Tables
  ✅ B2T2 / Table API / Constructors / emptyTable
  ✅ B2T2 / Table API / Constructors / addRows
  ✅ B2T2 / Table API / Constructors / addColumn
  ✅ B2T2 / Table API / Constructors / buildColumn
  ✅ B2T2 / Table API / Constructors / vcat
  ✅ B2T2 / Table API / Constructors / hcat
  ✅ B2T2 / Table API / Constructors / values
  ✅ B2T2 / Table API / Constructors / crossJoin
  ✅ B2T2 / Table API / Constructors / leftJoin
  ✅ B2T2 / Table API / Properties
  ✅ B2T2 / Table API / Access Subcomponents
  ✅ B2T2 / Table API / Subtable
  ✅ B2T2 / Table API / Ordering
  ✅ B2T2 / Table API / Aggregate
  ✅ B2T2 / Table API / Missing Values
  ✅ B2T2 / Table API / Data Cleaning
  ✅ B2T2 / Table API / Utilities / Flatten
  ✅ B2T2 / Table API / Utilities / transformColumn
  ✅ B2T2 / Table API / Utilities / renameColumns
  ✅ B2T2 / Table API / Utilities / find
  ✅ B2T2 / Table API / Utilities / groupByRetentive
  ✅ B2T2 / Table API / Utilities / groupBySubtractive
  ✅ B2T2 / Table API / Utilities / update
  ✅ B2T2 / Table API / Utilities / select
  ✅ B2T2 / Table API / Utilities / selectMany
  ✅ B2T2 / Table API / Utilities / groupJoin
  ✅ B2T2 / Table API / Utilities / join
  ✅ B2T2 / Example Programs / Dot Product
  ✅ B2T2 / Example Programs / pHackingHomogeneous
  ✅ B2T2 / Example Programs / pHackingHeterogeneous
  ✅ B2T2 / Example Programs / quizScoreFilter
  ✅ B2T2 / Example Programs / quizScoreSelect
  ✅ B2T2 / Example Programs / groupByRetentive
  ✅ B2T2 / Example Programs / groupBySubtractive
  ✅ B2T2 / Errors / Malformed Tables
  ✅ B2T2 / Errors / Using Tables / Part 1
  ✅ B2T2 / Errors / Using Tables / Part 2
  ✅ B2T2 / Errors / Using Tables / Part 3
HazelTests.MatchExp
  ✅ Match a variable
  ✅ Doesn't resolve if different
  ✅ Does resolve if same
  ✅ alpha equivalence
  ✅ Let alpha equivalence
  ✅ Shadowing
  ✅ Shadow alpha equivalence
  ✅ deep alpha equivalence
  ✅ ignores casts
  ✅ Nested function alpha equivalence
  ✅ FixF alpha equivalence
  ✅ Match expression alpha equivalence