parser:
./a%20b
./"a%20b"
text interpolation and escapes
projection by expression unit tests
fix fakeurlencode test
s/QuotedVariable/VariableQuoted/
success/
    operators/
        PrecedenceAll1 a ? b || c + d ++ e # f && g ∧ h ⫽ i ⩓ j * k == l != m n.o
        PrecedenceAll2 a b != c == d * e ⩓ f ⫽ g ∧ h && i # j ++ k + l || m ? n
    LetNoAnnot let x = y in e
    LetAnnot let x: T = y in e
    EmptyRecordLiteral {=}
    ToMap toMap x
    ToMapAnnot toMap x : T
    VariableQuotedSpace ` x `
failure/
    AssertNoAnnotation assert

binary decoding:
decode old-style optional literals ?

import:
success/
    recover type error
    recover recursive import error
failure/
    don't recover cycle

normalization:
variables across import boundaries
    Text/show ""
    TextLitNested1 "${""}${x}"
    TextLitNested2 "${"${x}"}"
    TextLitNested3 "${"${""}"}${x}"
    regression/
        NaturalFoldExtraArg Natural/fold 0 (Bool -> Bool) (λ(_ : (Bool -> Bool)) → λ(_ : Bool) → True) (λ(_ : Bool) → False) True
            let T = Natural let ap = λ(f : T → List T) -> λ(x : T) -> f x in ap (λ(x : T) -> ap (λ(y : T) -> [x, y]) 1) 0

typecheck:
something that involves destructuring a recordtype after merge
add some of the more complicated Prelude tests back, like List/enumerate
success/
    regression/
        RecursiveRecordTypeMergeTripleCollision { x : { a : Bool } } ⩓ { x : { b : Bool } } ⩓ { x : { c : Bool } }
        somehow test that ({ x = { z = 1 } } ∧ { x = { y = 2 } }).x has a type
        somehow test that the recordtype from List/indexed has a type in both empty and nonempty cases
        somehow test types added to the Foo/build closures
            λ(x : ∀(a : Type) → a) → x
            let X = 0 in λ(T : Type) → λ(x : T) → 1
            (λ(T : Type) → let foo = 0 in λ(x : T) → x) : ∀(T : Type) → ∀(x : T) → T
failure/
    \(_: Bool) -> assert : (\(_: Bool) -> _) === (\(x: Bool) -> _)
    \(x: let x = 1 in Sort) -> 0
    merge { x = λ(x : Bool) → x } (< x: Bool | y: Natural >.x True)
    merge { x = λ(_ : Bool) → _, y = 1 } < x = True | y >
    merge { x = True, y = 1 } < x | y >.x
    merge {x=...,y=...} <x>.x
    merge {x=...,y=...} <x:T>.x
    MergeBoolIsNotUnion merge x True
    MergeOptionalIsNotUnion merge x (Some 1)
    SortInLet let x = Sort in 1

equivalence: