✅ convert DoubleLiteral to Scala
✅ convert other literals to Scala
✅ convert kinds to DhallKinds
✅ convert type names to Scala type tags
✅ convert type constructors to Scala type tags
✅ convert built-in functions to Scala functions
✅ fail to convert imports and alternatives
✅ make sure we typecheck when doing .asScala
✅ convert arithmetic
✅ lists
✅ Optional
✅ convert record literals to Scala
✅ fail on ill-typed Dhall expressions
✅ fail on non-closed Dhall expressions
✅ fail on invalid function types
✅ convert functions to Scala functions 1
✅ convert functions to Scala functions 2
✅ convert functions to Scala functions 3
✅ todo: convert generic functions to Scala generic functions
✅ field access for records 1
✅ field access for records 2
✅ field access for records 3
✅ built-in functions with type parameters

✅ convert Scala Double type to Dhall
✅ convert Scala case class
✅ convert Scala types that are not supported
✅ convert Scala type constructors that are not supported

✅ simple examples from readme
✅ factorial example from readme
✅ ill-typed example from readme
✅ Scala factorial example from readme

✅ convert simple Dhall expressions to Scala source code

✅ run the Main.process function
✅ Main.process with parse failure
✅ Main.process with evaluation failure
✅ obtain type
✅ obtain hash 1
✅ obtain hash 2
✅ encode / decode roundtrip
✅ export text
✅ fail to export text if Dhall expression is not text
✅ yaml output for literals
✅ fail to export yaml if Dhall expression contains unsupported types
✅ json main test cases
✅ yaml main test cases
✅ yaml corner cases from dhall-haskell/yaml
✅ parse command-line argument

✅ create yaml from realistic example 1

✅ import resolution success
✅ import resolution failure

✅ convert standard examples for successful parsing into CBOR
✅ validate CBOR writing for standard examples
✅ validate CBOR reading for standard examples
✅ validate binary decoding/success
✅ validate binary decoding/failure

✅ parse standard examples for successful parsing
✅ parse standard examples for failed parsing
✅ convert standard examples for successful parsing into CBOR
✅ validate CBOR writing for standard examples
✅ validate CBOR reading for standard examples
✅ validate binary decoding/success
✅ validate binary decoding/failure

✅ dhall standard acceptance tests for semantic hash

✅ alpha normalization success
✅ beta normalization success

✅ type inference success
✅ type inference failure

✅ do notation
✅ do notation having no `with` lines
✅ parse do notation correctly

✅ yaml output for record of lists with indent

✅ time literals with nanos
✅ time literals with truncated nanos
✅ cbor encoding for time literals with long fraction using cbor1
✅ cbor encoding for time literals with long fraction using cbor2
✅ cbor encoding for time literals of varying precision for 00:00:00.000000000000
✅ cbor encoding for time literals of varying precision for 00:00:01.000000000000
✅ type inference must use correct de Bruijn index, no imports
✅ type inference must use correct de Bruijn index, use imports
✅ failure in Mode/equal.dhall

✅ tracing the parse of deeply nested parentheses
✅ simple grammar with no exponential slowness
✅ simple grammar with exponential slowness
✅ simple grammar with exponential slowness and manual memoization

✅ quoted_label_char
✅ requireKeyword
✅ end_of_line
✅ valid_non_ascii
✅ valid_non_ascii with large Unicode values from UTF-16 surrogates
✅ valid_non_ascii with large Unicode values from file
✅ tab
✅ block_comment
✅ whsp
✅ comment fails when not closed
✅ comment fails when incomplete
✅ whitespace_chunk
✅ whsp1
✅ keyword
✅ simple_label
✅ builtin names
✅ constant names
✅ parse Location as a field name
✅ numeric_double_literal
✅ natural_literal
✅ integer_literal
✅ identifier
✅ identifier with backquotes
✅ variable with backquotes
✅ nonreserved_label with backquotes
✅ label with backquotes
✅ identifier special cases
✅ bytes_literal
✅ primitive_expression
✅ selector_expression
✅ completion_expression

✅ import_only
✅ import_hashed
✅ import_expression
✅ plus_expression
✅ primitive_expression
✅ let_binding
✅ expression_let_binding
✅ interpolation
✅ double-quoted text with interpolations
✅ single-quoted multiline text with interpolations
✅ text_literal

✅ print Dhall expressions
✅ print assert expressions

✅ produce an expression with a large normal form
✅ beta-normalizing performance
✅ no more stack overflow in Scala MurmurHash3 or hashCode()
✅ stack overflow in Scala MurmurHash3

✅ CBOR roundtrips 1
✅ CBOR roundtrips 2
✅ CBOR roundtrips 2a
✅ CBOR roundtrips for half-precision floats
✅ CBOR roundtrips for half-precision double
✅ CBOR roundtrips 3
✅ CBOR roundtrips 4
✅ CBOR roundtrips 5
✅ CBOR roundtrips 6
✅ CBOR for dictionaries
✅ CBOR for tagged array
✅ CBOR for strings containing newlines
✅ CBOR1 for strings containing newlines

✅ simple invalid expression: 1+1
✅ simple expression: { foo, bar }
✅ simple expression: x
✅ simple expression: let x = 1 in x with hand-written grammar
✅ simple expression: let x = 1 in y
✅ simple expression: (x)
✅ parse a string interpolation
✅ parse a sample file
✅ expression and a block comment
✅ expression and a line comment
✅ expression followed by comment
✅ parse assert : x
✅ parse x === y
✅ parse assert : x === y
✅ simple_label
✅ empty record literal
✅ variables or missing import ambiguity 1
✅ variables or missing import ambiguity 2
✅ variables or missing import ambiguity 3
✅ variable name missing//foo, conflict with import declaration
✅ invalid utf-8
✅ quoted multiline string ends with newline
✅ empty url path
✅ posix env var names
✅ leading delimiter in union type
✅ records have sorted fields in CBOR
✅ application to an import
✅ import with a long file path
✅ do notation

✅ environment presets are parsed correctly for testing
✅ import chaining must compute correct paths
✅ no loops in importing
✅ alpha-normalize and beta-normalize imported file
✅ exponential blowup in normal form
✅ import alternatives inside expressions
✅ import . or .. or other invalid imports should fail
✅ do not recover from sha mismatch
✅ correct sha256 check

✅ read List/partition.dhall and beta-normalize it alone
✅ typecheck List/partition.dhall imports
✅ read Natural/sort.dhall and beta-normalize it alone
✅ typecheck Natural/sort.dhall imports
✅ import dhall-lang/Prelude/Natural/package.dhall without hanging
✅ import dhall-lang/Prelude/package.dhall without hanging
✅ resolve imports (but do not typecheck) each file from the standard prelude except two package.dhall files

✅ substitute in a variable
✅ substitute in a lambda
✅ alpha-normalize a nested lambda
✅ alpha-normalize record access
✅ correct precedence for imports with fallback
✅ alpha-normalization and beta-normalization should refuse imports
✅ beta-normalize with unique subexpressions
✅ shortcut in Natural/fold if the result no longer changes
✅ shortcut in Natural/fold if the result no longer changes, with symbolic lambda
✅ shortcut in Natural/fold with a function 1
✅ shortcut in Natural/fold with a function 2
✅ avoid expanding Natural/fold when the result grows as a symbolic expression
✅ compute expression count
✅ foldWhile performance test with bitLength
✅ safe division using dependent types
✅ safe division using assert
✅ beta-normalization with Natural/fold and shortcut
✅ beta-normalization for appended lists
✅ Text/replace various cases
✅ invalid field name is an error 1
✅ invalid field name is an error 2
✅ invalid field name is an error 3
✅ invalid field name is an error 4
✅ record types field access
✅ no support for kind-polymorphic functions
✅ a function is equivalent to its eta expansion
✅ eta expansion with two curried arguments
✅ assert with eta expansion with two curried arguments
✅ failure in eta expansion with two curried arguments
✅ eta expansion with free occurrences of external bound variable
✅ failure 1 with f x in eta expansion with free occurrences of external bound variable
✅ failure 2 with f x in eta expansion with free occurrences of external bound variable
✅ eta-reduction works regardless of types
✅ identity law of function composition
✅ associativity rewrite 1
✅ associativity rewrite 2
✅ associativity law of monoids
✅ equivalence for Double literals
✅ `with` for Optional works if it does not change type
✅ fail `with` for Optional if it changes type
✅ `with` for Optional works if it does not change type, with deep record access
✅ fail `with` for Optional if it changes type, with deep record access

✅ typecheck record of types
✅ shift in type variable
✅ shift in type variable without pun
✅ shift in type variable with index 1 without generics
✅ shift in type variable with index 1 without pun
✅ shift in type variable with index 1 with pun
✅ shift in type variable with union constructor
✅ shift in type variable with union constructor and pun
✅ simplify equivalence type
✅ type inference failure with RecordSelectionNotRecord.dhall
✅ empty selection from record types or record values
✅ empty selection is not allowed when the base is not a record type literal
✅ do not alpha-normalize when inferring type

✅ print long expressions without stack overflow, without parentheses
✅ print long expressions without stack overflow, with parentheses
✅ print long expressions without stack overflow, right-associated with parentheses
✅ print with the new tail-recursive function print1
✅ print1 long expressions without stack overflow, without parentheses
✅ deeply nested lists
✅ deeply nested parentheses
✅ deeply nested records
✅ deeply nested record types
✅ deeply nested applications
✅ deeply nested applications under lambda
✅ deeply nested lambdas

✅ yaml output for comment headers 1
✅ yaml output for comment headers 2
✅ yaml output for comment headers 3
✅ yaml output for record of lists with indent 4
✅ yaml output for strings with special characters
✅ json output with longer indentation

✅ determine subclasses of a sealed trait

✅ example in the code
✅ fake environment variables can be added
✅ exceptions are passed through but fake variables are still removed
✅ fake environment variables can be removed
✅ fake environment variables can be nested, added, and removed

✅ get resource as file
✅ enumerate resource files by pattern
✅ change current working directory

✅ print throwables, stack traces, and causes