parser: ./a%20b ./"a%20b" text interpolation and escapes remove `double` remove imports/parenthesizeUsing remove multilet selection by expression unit tests split aslocation test into actual unit tests success/ imports/ Missing missing Headers https://example.com/foo using ./headers HeadersInteriorHash https://example.com/foo using (./headers sha256:0000000000000000000000000000000000000000000000000000000000000000) HeadersExteriorHash (https://example.com/foo using ./headers) sha256:0000000000000000000000000000000000000000000000000000000000000000 HeadersHashPrecedence https://example.com/foo using ./headers sha256:0000000000000000000000000000000000000000000000000000000000000000 HeadersDoubleHashPrecedence https://example.com/foo using ./headers sha256:0000000000000000000000000000000000000000000000000000000000000000 sha256:1111111111111111111111111111111111111111111111111111111111111111 DoubleLitPositive 1.23 DoubleLitNegative -1.23 DoubleLitExponent 1.23e4 DoubleLitExponentNoDot 1e4 DoubleLitExponentNegative 1.23e-4 DoubleLitInfinity Infinity DoubleLitNegInfinity -Infinity DoubleLitNaN NaN DoubleLitSecretelyInt 1.0 DoubleLitZero 0.0 BuiltinListBuild List/Build FunctionApplicationOneArg f x FunctionApplicationMultipleArgs f x y z Annotation x : T ListLitNonEmpty [x, y] ListLitNonEmptyAnnotated [x, y] : List T OptionalLitEmpty []: Optional T OptionalLitNonEmpty [x]: Optional T Field r.x FieldBuiltinName r.List FieldQuoted r.`x` Projection r.{x, y, z} Let let x: T = v in e LetNested let x: T = v in let y: U = w in e LetMulti let x: T = v let y: U = w in e LambdaUnicode λ(x : T) -> y FunctionTypePi forall(x: T) -> U FunctionTypePiUnicode ∀(x: T) -> U FunctionTypePiNested forall(x: T) -> ∀(y: U) -> V FunctionTypePiUnderscore forall(_: T) -> U FunctionTypeArrow T -> U RecordLit { x = 1, y = 2 } RecordType { x: T, y: U } operators/ ImportAlt x ? y ImportAltAssoc w ? x ? y ? z BoolOr x || y BoolOrAssoc w || x || y || z NaturalPlus x + y NaturalPlusAssoc w + x + y + z TextAppend x ++ y TextAppendAssoc w ++ x ++ y ++ z ListAppend x # y ListAppendAssoc w # x # y # z BoolAnd x && y BoolAndAssoc w && x && y && z NaturalTimes x * y NaturalTimesAssoc w * x * y * z BoolEQ x == y BoolEQAssoc w == x == y == z BoolNE x != y BoolNEAssoc w != x != y != z RecursiveRecordMerge x //\\ y RecursiveRecordMergeAssoc w //\\ x //\\ y //\\ z RecursiveRecordTypeMerge x /\ y RecursiveRecordTypeMergeAssoc w /\ x /\ y /\ z RightBiasedRecordMerge x // y RightBiasedRecordMergeAssoc w // x // y // z RecursiveRecordMergeUnicode x ∧ y RecursiveRecordMergeUnicodeAssoc w ∧ x /\ y ∧ z RightBiasedRecordMergeUnicode x ⫽ y RightBiasedRecordMergeUnicodeAssoc w ⫽ x // y ⫽ z RecursiveRecordTypeMergeUnicode x ⩓ y RecursiveRecordTypeMergeUnicodeAssoc w ⩓ x //\\ y ⩓ z 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 PrecedenceNat a + b * d + e f * (g + h) PrecedenceBool a && b || c d == e || f != g && h || i PrecedenceRecord a // b c /\ d ⫽ e.{x} ∧ f failure/ ProjectionByExpressionNeedsParens r.{ x: T } 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 "" Double/show -1.5e-10 TextLitNested1 "${""}${x}" TextLitNested2 "${"${x}"}" TextLitNested3 "${"${""}"}${x}" EquivalenceDouble if b then NaN else NaN EquivalenceAlpha if b then \(x: T) -> x else \(y: T) -> y typecheck: something that involves destructuring a recordtype after merge add some of the more complicated Prelude tests back, like List/enumerate failure on old-style optional literal success/ MergeEmptyAlternative merge { x = 1 } < x >.x MergeTrickyShadowing let _ = Bool in merge {_ = \(x: _) -> x} (<_: Bool>._ True) EquivalenceAlpha \(TODO: forall(x: Type) -> x) -> TODO : forall(y: Type) -> y failure/ MergeEmptyNeedsDirectAnnotation1 \(x: <>) -> (merge {=} x) : Bool MergeEmptyNeedsDirectAnnotation2 \(x: <>) -> let y: Bool = merge {=} x in 1 MergeBoolIsNotUnion merge x True MergeOptionalIsNotUnion merge x (Some 1) MergeMissingHandler1 merge {=} < x >.x MergeMissingHandler2 merge {x=...,} .x 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 merge {x=...,y=...} .x MergeHandlerFreeVar merge { x = None } < x = Bool > UnionTypeDuplicateVariants1 UnionTypeDuplicateVariants2 UnionLitDuplicateVariants RecordLitDuplicateFields { x: T, x: T } EquivalenceAlphaTrap \(TODO: forall(_: Type) -> _) -> TODO : forall(x: Type) -> _ equivalence: