371 files changed, 990 insertions(+), 446 deletions(-)

M .builds.dhall/debian-stable.dhall
M .builds/debian-stable.yml
A .gitignore
M Gemfile
A Makefile
M dhall-lang
M lib/dhall.rb
M lib/dhall/ast.rb
M lib/dhall/binary.rb
M lib/dhall/normalize.rb
A lib/dhall/parser.rb
M lib/dhall/util.rb
A scripts/generate_citrus_parser.rb
D test/normalization/alpha/FunctionBindingUnderscoreA.dhallb
D test/normalization/alpha/FunctionBindingUnderscoreB.dhallb
D test/normalization/alpha/FunctionBindingXA.dhallb
D test/normalization/alpha/FunctionBindingXB.dhallb
D test/normalization/alpha/FunctionNestedBindingXA.dhallb
D test/normalization/alpha/FunctionNestedBindingXB.dhallb
D test/normalization/alpha/FunctionTypeBindingUnderscoreA.dhallb
D test/normalization/alpha/FunctionTypeBindingUnderscoreB.dhallb
D test/normalization/alpha/FunctionTypeBindingXA.dhallb
D test/normalization/alpha/FunctionTypeBindingXB.dhallb
D test/normalization/alpha/FunctionTypeNestedBindingXA.dhallb
D test/normalization/alpha/FunctionTypeNestedBindingXB.dhallb
D test/normalization/beta/BoolA.dhallb
D test/normalization/beta/BoolB.dhallb
D test/normalization/beta/DoubleA.dhallb
D test/normalization/beta/DoubleB.dhallb
D test/normalization/beta/DoubleLiteralA.dhallb
D test/normalization/beta/DoubleLiteralB.dhallb
D test/normalization/beta/DoubleShowA.dhallb
D test/normalization/beta/DoubleShowB.dhallb
D test/normalization/beta/DoubleShowValueA.dhallb
D test/normalization/beta/DoubleShowValueB.dhallb
D test/normalization/beta/FunctionApplicationCaptureA.dhallb
D test/normalization/beta/FunctionApplicationCaptureB.dhallb
D test/normalization/beta/FunctionApplicationNoSubstituteA.dhallb
D test/normalization/beta/FunctionApplicationNoSubstituteB.dhallb
D test/normalization/beta/FunctionApplicationNormalizeArgumentsA.dhallb
D test/normalization/beta/FunctionApplicationNormalizeArgumentsB.dhallb
D test/normalization/beta/FunctionApplicationSubstituteA.dhallb
D test/normalization/beta/FunctionApplicationSubstituteB.dhallb
D test/normalization/beta/FunctionNormalizeArgumentsA.dhallb
D test/normalization/beta/FunctionNormalizeArgumentsB.dhallb
D test/normalization/beta/FunctionTypeNormalizeArgumentsA.dhallb
D test/normalization/beta/FunctionTypeNormalizeArgumentsB.dhallb
D test/normalization/beta/IfAlternativesIdenticalA.dhallb
D test/normalization/beta/IfAlternativesIdenticalB.dhallb
D test/normalization/beta/IfFalseA.dhallb
D test/normalization/beta/IfFalseB.dhallb
D test/normalization/beta/IfNormalizePredicateAndBranchesA.dhallb
D test/normalization/beta/IfNormalizePredicateAndBranchesB.dhallb
D test/normalization/beta/IfTrivialA.dhallb
D test/normalization/beta/IfTrivialB.dhallb
D test/normalization/beta/IfTrueA.dhallb
D test/normalization/beta/IfTrueB.dhallb
D test/normalization/beta/IntegerA.dhallb
D test/normalization/beta/IntegerB.dhallb
D test/normalization/beta/IntegerNegativeA.dhallb
D test/normalization/beta/IntegerNegativeB.dhallb
D test/normalization/beta/IntegerPositiveA.dhallb
D test/normalization/beta/IntegerPositiveB.dhallb
D test/normalization/beta/IntegerShow-12A.dhallb
D test/normalization/beta/IntegerShow-12B.dhallb
D test/normalization/beta/IntegerShow12A.dhallb
D test/normalization/beta/IntegerShow12B.dhallb
D test/normalization/beta/IntegerShowA.dhallb
D test/normalization/beta/IntegerShowB.dhallb
D test/normalization/beta/IntegerToDouble-12A.dhallb
D test/normalization/beta/IntegerToDouble-12B.dhallb
D test/normalization/beta/IntegerToDouble12A.dhallb
D test/normalization/beta/IntegerToDouble12B.dhallb
D test/normalization/beta/IntegerToDoubleA.dhallb
D test/normalization/beta/IntegerToDoubleB.dhallb
D test/normalization/beta/KindA.dhallb
D test/normalization/beta/KindB.dhallb
D test/normalization/beta/LetA.dhallb
D test/normalization/beta/LetB.dhallb
D test/normalization/beta/LetWithTypeA.dhallb
D test/normalization/beta/LetWithTypeB.dhallb
D test/normalization/beta/ListA.dhallb
D test/normalization/beta/ListB.dhallb
D test/normalization/beta/ListBuildA.dhallb
D test/normalization/beta/ListBuildB.dhallb
D test/normalization/beta/ListBuildFoldFusionA.dhallb
D test/normalization/beta/ListBuildFoldFusionB.dhallb
D test/normalization/beta/ListBuildImplementationA.dhallb
D test/normalization/beta/ListBuildImplementationB.dhallb
D test/normalization/beta/ListFoldA.dhallb
D test/normalization/beta/ListFoldB.dhallb
D test/normalization/beta/ListFoldEmptyA.dhallb
D test/normalization/beta/ListFoldEmptyB.dhallb
D test/normalization/beta/ListFoldOneA.dhallb
D test/normalization/beta/ListFoldOneB.dhallb
D test/normalization/beta/ListHeadA.dhallb
D test/normalization/beta/ListHeadB.dhallb
D test/normalization/beta/ListHeadEmptyA.dhallb
D test/normalization/beta/ListHeadEmptyB.dhallb
D test/normalization/beta/ListHeadOneA.dhallb
D test/normalization/beta/ListHeadOneB.dhallb
D test/normalization/beta/ListIndexedA.dhallb
D test/normalization/beta/ListIndexedB.dhallb
D test/normalization/beta/ListIndexedEmptyA.dhallb
D test/normalization/beta/ListIndexedEmptyB.dhallb
D test/normalization/beta/ListIndexedOneA.dhallb
D test/normalization/beta/ListIndexedOneB.dhallb
D test/normalization/beta/ListLastA.dhallb
D test/normalization/beta/ListLastB.dhallb
D test/normalization/beta/ListLastEmptyA.dhallb
D test/normalization/beta/ListLastEmptyB.dhallb
D test/normalization/beta/ListLastOneA.dhallb
D test/normalization/beta/ListLastOneB.dhallb
D test/normalization/beta/ListLengthA.dhallb
D test/normalization/beta/ListLengthB.dhallb
D test/normalization/beta/ListLengthEmptyA.dhallb
D test/normalization/beta/ListLengthEmptyB.dhallb
D test/normalization/beta/ListLengthOneA.dhallb
D test/normalization/beta/ListLengthOneB.dhallb
D test/normalization/beta/ListNormalizeElementsA.dhallb
D test/normalization/beta/ListNormalizeElementsB.dhallb
D test/normalization/beta/ListNormalizeTypeAnnotationA.dhallb
D test/normalization/beta/ListNormalizeTypeAnnotationB.dhallb
D test/normalization/beta/ListReverseA.dhallb
D test/normalization/beta/ListReverseB.dhallb
D test/normalization/beta/ListReverseEmptyA.dhallb
D test/normalization/beta/ListReverseEmptyB.dhallb
D test/normalization/beta/ListReverseTwoA.dhallb
D test/normalization/beta/ListReverseTwoB.dhallb
D test/normalization/beta/MergeA.dhallb
D test/normalization/beta/MergeB.dhallb
D test/normalization/beta/MergeNormalizeArgumentsA.dhallb
D test/normalization/beta/MergeNormalizeArgumentsB.dhallb
D test/normalization/beta/MergeWithTypeA.dhallb
D test/normalization/beta/MergeWithTypeB.dhallb
D test/normalization/beta/MergeWithTypeNormalizeArgumentsA.dhallb
D test/normalization/beta/MergeWithTypeNormalizeArgumentsB.dhallb
D test/normalization/beta/NaturalA.dhallb
D test/normalization/beta/NaturalB.dhallb
D test/normalization/beta/NaturalBuildA.dhallb
D test/normalization/beta/NaturalBuildB.dhallb
D test/normalization/beta/NaturalBuildFoldFusionA.dhallb
D test/normalization/beta/NaturalBuildFoldFusionB.dhallb
D test/normalization/beta/NaturalBuildImplementationA.dhallb
D test/normalization/beta/NaturalBuildImplementationB.dhallb
D test/normalization/beta/NaturalEvenA.dhallb
D test/normalization/beta/NaturalEvenB.dhallb
D test/normalization/beta/NaturalEvenOneA.dhallb
D test/normalization/beta/NaturalEvenOneB.dhallb
D test/normalization/beta/NaturalEvenZeroA.dhallb
D test/normalization/beta/NaturalEvenZeroB.dhallb
D test/normalization/beta/NaturalFoldA.dhallb
D test/normalization/beta/NaturalFoldB.dhallb
D test/normalization/beta/NaturalFoldOneA.dhallb
D test/normalization/beta/NaturalFoldOneB.dhallb
D test/normalization/beta/NaturalFoldZeroA.dhallb
D test/normalization/beta/NaturalFoldZeroB.dhallb
D test/normalization/beta/NaturalIsZeroA.dhallb
D test/normalization/beta/NaturalIsZeroB.dhallb
D test/normalization/beta/NaturalIsZeroOneA.dhallb
D test/normalization/beta/NaturalIsZeroOneB.dhallb
D test/normalization/beta/NaturalIsZeroZeroA.dhallb
D test/normalization/beta/NaturalIsZeroZeroB.dhallb
D test/normalization/beta/NaturalLiteralA.dhallb
D test/normalization/beta/NaturalLiteralB.dhallb
D test/normalization/beta/NaturalOddA.dhallb
D test/normalization/beta/NaturalOddB.dhallb
D test/normalization/beta/NaturalOddOneA.dhallb
D test/normalization/beta/NaturalOddOneB.dhallb
D test/normalization/beta/NaturalOddZeroA.dhallb
D test/normalization/beta/NaturalOddZeroB.dhallb
D test/normalization/beta/NaturalShowA.dhallb
D test/normalization/beta/NaturalShowB.dhallb
D test/normalization/beta/NaturalShowOneA.dhallb
D test/normalization/beta/NaturalShowOneB.dhallb
D test/normalization/beta/NaturalToIntegerA.dhallb
D test/normalization/beta/NaturalToIntegerB.dhallb
D test/normalization/beta/NaturalToIntegerOneA.dhallb
D test/normalization/beta/NaturalToIntegerOneB.dhallb
D test/normalization/beta/NoneA.dhallb
D test/normalization/beta/NoneB.dhallb
D test/normalization/beta/NoneNaturalA.dhallb
D test/normalization/beta/NoneNaturalB.dhallb
D test/normalization/beta/OperatorAndEquivalentArgumentsA.dhallb
D test/normalization/beta/OperatorAndEquivalentArgumentsB.dhallb
D test/normalization/beta/OperatorAndLhsFalseA.dhallb
D test/normalization/beta/OperatorAndLhsFalseB.dhallb
D test/normalization/beta/OperatorAndLhsTrueA.dhallb
D test/normalization/beta/OperatorAndLhsTrueB.dhallb
D test/normalization/beta/OperatorAndNormalizeArgumentsA.dhallb
D test/normalization/beta/OperatorAndNormalizeArgumentsB.dhallb
D test/normalization/beta/OperatorAndRhsFalseA.dhallb
D test/normalization/beta/OperatorAndRhsFalseB.dhallb
D test/normalization/beta/OperatorAndRhsTrueA.dhallb
D test/normalization/beta/OperatorAndRhsTrueB.dhallb
D test/normalization/beta/OperatorEqualEquivalentArgumentsA.dhallb
D test/normalization/beta/OperatorEqualEquivalentArgumentsB.dhallb
D test/normalization/beta/OperatorEqualLhsTrueA.dhallb
D test/normalization/beta/OperatorEqualLhsTrueB.dhallb
D test/normalization/beta/OperatorEqualNormalizeArgumentsA.dhallb
D test/normalization/beta/OperatorEqualNormalizeArgumentsB.dhallb
D test/normalization/beta/OperatorEqualRhsTrueA.dhallb
D test/normalization/beta/OperatorEqualRhsTrueB.dhallb
D test/normalization/beta/OperatorListConcatenateLhsEmptyA.dhallb
D test/normalization/beta/OperatorListConcatenateLhsEmptyB.dhallb
D test/normalization/beta/OperatorListConcatenateListListA.dhallb
D test/normalization/beta/OperatorListConcatenateListListB.dhallb
D test/normalization/beta/OperatorListConcatenateNormalizeArgumentsA.dhallb
D test/normalization/beta/OperatorListConcatenateNormalizeArgumentsB.dhallb
D test/normalization/beta/OperatorListConcatenateRhsEmptyA.dhallb
D test/normalization/beta/OperatorListConcatenateRhsEmptyB.dhallb
D test/normalization/beta/OperatorNotEqualEquivalentArgumentsA.dhallb
D test/normalization/beta/OperatorNotEqualEquivalentArgumentsB.dhallb
D test/normalization/beta/OperatorNotEqualLhsFalseA.dhallb
D test/normalization/beta/OperatorNotEqualLhsFalseB.dhallb
D test/normalization/beta/OperatorNotEqualNormalizeArgumentsA.dhallb
D test/normalization/beta/OperatorNotEqualNormalizeArgumentsB.dhallb
D test/normalization/beta/OperatorNotEqualRhsFalseA.dhallb
D test/normalization/beta/OperatorNotEqualRhsFalseB.dhallb
D test/normalization/beta/OperatorOrEquivalentArgumentsA.dhallb
D test/normalization/beta/OperatorOrEquivalentArgumentsB.dhallb
D test/normalization/beta/OperatorOrLhsFalseA.dhallb
D test/normalization/beta/OperatorOrLhsFalseB.dhallb
D test/normalization/beta/OperatorOrLhsTrueA.dhallb
D test/normalization/beta/OperatorOrLhsTrueB.dhallb
D test/normalization/beta/OperatorOrNormalizeArgumentsA.dhallb
D test/normalization/beta/OperatorOrNormalizeArgumentsB.dhallb
D test/normalization/beta/OperatorOrRhsFalseA.dhallb
D test/normalization/beta/OperatorOrRhsFalseB.dhallb
D test/normalization/beta/OperatorOrRhsTrueA.dhallb
D test/normalization/beta/OperatorOrRhsTrueB.dhallb
D test/normalization/beta/OperatorPlusLhsZeroA.dhallb
D test/normalization/beta/OperatorPlusLhsZeroB.dhallb
D test/normalization/beta/OperatorPlusNormalizeArgumentsA.dhallb
D test/normalization/beta/OperatorPlusNormalizeArgumentsB.dhallb
D test/normalization/beta/OperatorPlusOneAndOneA.dhallb
D test/normalization/beta/OperatorPlusOneAndOneB.dhallb
D test/normalization/beta/OperatorPlusRhsZeroA.dhallb
D test/normalization/beta/OperatorPlusRhsZeroB.dhallb
D test/normalization/beta/OperatorTextConcatenateLhsEmptyA.dhallb
D test/normalization/beta/OperatorTextConcatenateLhsEmptyB.dhallb
D test/normalization/beta/OperatorTextConcatenateNormalizeArgumentsA.dhallb
D test/normalization/beta/OperatorTextConcatenateNormalizeArgumentsB.dhallb
D test/normalization/beta/OperatorTextConcatenateRhsEmptyA.dhallb
D test/normalization/beta/OperatorTextConcatenateRhsEmptyB.dhallb
D test/normalization/beta/OperatorTextConcatenateTextTextA.dhallb
D test/normalization/beta/OperatorTextConcatenateTextTextB.dhallb
D test/normalization/beta/OperatorTimesLhsOneA.dhallb
D test/normalization/beta/OperatorTimesLhsOneB.dhallb
D test/normalization/beta/OperatorTimesLhsZeroA.dhallb
D test/normalization/beta/OperatorTimesLhsZeroB.dhallb
D test/normalization/beta/OperatorTimesNormalizeArgumentsA.dhallb
D test/normalization/beta/OperatorTimesNormalizeArgumentsB.dhallb
D test/normalization/beta/OperatorTimesRhsOneA.dhallb
D test/normalization/beta/OperatorTimesRhsOneB.dhallb
D test/normalization/beta/OperatorTimesRhsZeroA.dhallb
D test/normalization/beta/OperatorTimesRhsZeroB.dhallb
D test/normalization/beta/OperatorTimesTwoAndTwoA.dhallb
D test/normalization/beta/OperatorTimesTwoAndTwoB.dhallb
D test/normalization/beta/OptionalA.dhallb
D test/normalization/beta/OptionalB.dhallb
D test/normalization/beta/OptionalBuildA.dhallb
D test/normalization/beta/OptionalBuildB.dhallb
D test/normalization/beta/OptionalBuildFoldFusionA.dhallb
D test/normalization/beta/OptionalBuildFoldFusionB.dhallb
D test/normalization/beta/OptionalBuildImplementationA.dhallb
D test/normalization/beta/OptionalBuildImplementationB.dhallb
D test/normalization/beta/OptionalFoldA.dhallb
D test/normalization/beta/OptionalFoldB.dhallb
D test/normalization/beta/OptionalFoldNoneA.dhallb
D test/normalization/beta/OptionalFoldNoneB.dhallb
D test/normalization/beta/OptionalFoldSomeA.dhallb
D test/normalization/beta/OptionalFoldSomeB.dhallb
D test/normalization/beta/RecordA.dhallb
D test/normalization/beta/RecordB.dhallb
D test/normalization/beta/RecordEmptyA.dhallb
D test/normalization/beta/RecordEmptyB.dhallb
D test/normalization/beta/RecordProjectionA.dhallb
D test/normalization/beta/RecordProjectionB.dhallb
D test/normalization/beta/RecordProjectionEmptyA.dhallb
D test/normalization/beta/RecordProjectionEmptyB.dhallb
D test/normalization/beta/RecordProjectionNormalizeArgumentsA.dhallb
D test/normalization/beta/RecordProjectionNormalizeArgumentsB.dhallb
D test/normalization/beta/RecordSelectionA.dhallb
D test/normalization/beta/RecordSelectionB.dhallb
D test/normalization/beta/RecordSelectionNormalizeArgumentsA.dhallb
D test/normalization/beta/RecordSelectionNormalizeArgumentsB.dhallb
D test/normalization/beta/RecordTypeA.dhallb
D test/normalization/beta/RecordTypeB.dhallb
D test/normalization/beta/RecordTypeEmptyA.dhallb
D test/normalization/beta/RecordTypeEmptyB.dhallb
D test/normalization/beta/RecursiveRecordMergeCollisionA.dhallb
D test/normalization/beta/RecursiveRecordMergeCollisionB.dhallb
D test/normalization/beta/RecursiveRecordMergeLhsEmptyA.dhallb
D test/normalization/beta/RecursiveRecordMergeLhsEmptyB.dhallb
D test/normalization/beta/RecursiveRecordMergeNoCollisionA.dhallb
D test/normalization/beta/RecursiveRecordMergeNoCollisionB.dhallb
D test/normalization/beta/RecursiveRecordMergeNormalizeArgumentsA.dhallb
D test/normalization/beta/RecursiveRecordMergeNormalizeArgumentsB.dhallb
D test/normalization/beta/RecursiveRecordMergeRhsEmptyA.dhallb
D test/normalization/beta/RecursiveRecordMergeRhsEmptyB.dhallb
D test/normalization/beta/RecursiveRecordTypeMergeCollisionA.dhallb
D test/normalization/beta/RecursiveRecordTypeMergeCollisionB.dhallb
D test/normalization/beta/RecursiveRecordTypeMergeLhsEmptyA.dhallb
D test/normalization/beta/RecursiveRecordTypeMergeLhsEmptyB.dhallb
D test/normalization/beta/RecursiveRecordTypeMergeNoCollisionA.dhallb
D test/normalization/beta/RecursiveRecordTypeMergeNoCollisionB.dhallb
D test/normalization/beta/RecursiveRecordTypeMergeNormalizeArgumentsA.dhallb
D test/normalization/beta/RecursiveRecordTypeMergeNormalizeArgumentsB.dhallb
D test/normalization/beta/RecursiveRecordTypeMergeRhsEmptyA.dhallb
D test/normalization/beta/RecursiveRecordTypeMergeRhsEmptyB.dhallb
D test/normalization/beta/RightBiasedRecordMergeCollisionA.dhallb
D test/normalization/beta/RightBiasedRecordMergeCollisionB.dhallb
D test/normalization/beta/RightBiasedRecordMergeLhsEmptyA.dhallb
D test/normalization/beta/RightBiasedRecordMergeLhsEmptyB.dhallb
D test/normalization/beta/RightBiasedRecordMergeNoCollisionA.dhallb
D test/normalization/beta/RightBiasedRecordMergeNoCollisionB.dhallb
D test/normalization/beta/RightBiasedRecordMergeNormalizeArgumentsA.dhallb
D test/normalization/beta/RightBiasedRecordMergeNormalizeArgumentsB.dhallb
D test/normalization/beta/RightBiasedRecordMergeRhsEmptyA.dhallb
D test/normalization/beta/RightBiasedRecordMergeRhsEmptyB.dhallb
D test/normalization/beta/SomeNormalizeArgumentsA.dhallb
D test/normalization/beta/SomeNormalizeArgumentsB.dhallb
D test/normalization/beta/SortA.dhallb
D test/normalization/beta/SortB.dhallb
D test/normalization/beta/TextA.dhallb
D test/normalization/beta/TextB.dhallb
D test/normalization/beta/TextInterpolateA.dhallb
D test/normalization/beta/TextInterpolateB.dhallb
D test/normalization/beta/TextLiteralA.dhallb
D test/normalization/beta/TextLiteralB.dhallb
D test/normalization/beta/TextNormalizeInterpolationsA.dhallb
D test/normalization/beta/TextNormalizeInterpolationsB.dhallb
D test/normalization/beta/TextShowA.dhallb
D test/normalization/beta/TextShowAllEscapesA.dhallb
D test/normalization/beta/TextShowAllEscapesB.dhallb
D test/normalization/beta/TextShowB.dhallb
D test/normalization/beta/TrueA.dhallb
D test/normalization/beta/TrueB.dhallb
D test/normalization/beta/TypeA.dhallb
D test/normalization/beta/TypeAnnotationA.dhallb
D test/normalization/beta/TypeAnnotationB.dhallb
D test/normalization/beta/TypeB.dhallb
D test/normalization/beta/UnionNormalizeAlternativesA.dhallb
D test/normalization/beta/UnionNormalizeAlternativesB.dhallb
D test/normalization/beta/UnionNormalizeArgumentsA.dhallb
D test/normalization/beta/UnionNormalizeArgumentsB.dhallb
D test/normalization/beta/UnionProjectConstructorA.dhallb
D test/normalization/beta/UnionProjectConstructorB.dhallb
D test/normalization/beta/UnionProjectConstructorNormalizeArgumentsA.dhallb
D test/normalization/beta/UnionProjectConstructorNormalizeArgumentsB.dhallb
D test/normalization/beta/UnionSortAlternativesA.dhallb
D test/normalization/beta/UnionSortAlternativesB.dhallb
D test/normalization/beta/UnionTypeA.dhallb
D test/normalization/beta/UnionTypeB.dhallb
D test/normalization/beta/UnionTypeEmptyA.dhallb
D test/normalization/beta/UnionTypeEmptyB.dhallb
D test/normalization/beta/UnionTypeNormalizeArgumentsA.dhallb
D test/normalization/beta/UnionTypeNormalizeArgumentsB.dhallb
D test/normalization/beta/VariableA.dhallb
D test/normalization/beta/VariableB.dhallb
D test/normalization/dhall-encode
D test/normalization/dhall-hash
D test/normalization/gen
D test/normalization/standard/.gitignore
M test/test_as_json.rb
M test/test_binary.rb
M test/test_normalization.rb
A test/test_parser.rb
M test/test_resolvers.rb
M test/test_suite.rb

@@ 14,13 14,9 @@
 		{ build =
 			''
 			cd dhall-ruby
-			wget https://github.com/dhall-lang/dhall-haskell/releases/download/1.21.0/dhall-1.21.0-x86_64-linux.tar.bz2
-			tar -xvf dhall-1.21.0-x86_64-linux.tar.bz2
-			export PATH="$(pwd)/bin:$PATH"
-			test/normalization/gen
 			rubocop
 			bundle install --path="../.gems"
-			bundle exec ruby -Ilib test/test_suite.rb
+			make test
 			''
 		}
 	]

@@ 4,13 4,9 @@ sources:
 tasks:
 - build: |
     cd dhall-ruby
-    wget https://github.com/dhall-lang/dhall-haskell/releases/download/1.21.0/dhall-1.21.0-x86_64-linux.tar.bz2
-    tar -xvf dhall-1.21.0-x86_64-linux.tar.bz2
-    export PATH="$(pwd)/bin:$PATH"
-    test/normalization/gen
     rubocop
     bundle install --path="../.gems"
-    bundle exec ruby -Ilib test/test_suite.rb
+    make test
 packages:
 - bundler
 - git-extras

@@ 0,0 1,4 @@
+lib/dhall/parser.citrus
+Gemfile.lock
+.bundle/*
+.gems/*

@@ 2,7 2,9 @@
 
 source "https://rubygems.org"
 
+gem "abnf"
 gem "cbor"
+gem "citrus"
 gem "promise.rb"
 gem "value_semantics"
 gem "webmock"

@@ 0,0 1,7 @@
+.PHONY: test
+
+lib/dhall/parser.citrus: dhall-lang/standard/dhall.abnf
+	bundle exec ruby -Ilib scripts/generate_citrus_parser.rb < $< > $@
+
+test: lib/dhall/parser.citrus
+	bundle exec ruby -Ilib test/test_suite.rb

@@ 1,1 1,1 @@
-Subproject commit c21b3f5c8b19997816b6ceae87709db3c5afb150
+Subproject commit 30841349fd02fd4eb965cba23a8dc557e99fbd15

@@ 2,6 2,7 @@
 
 require "dhall/ast"
 require "dhall/builtins"
+require "dhall/parser"
 require "dhall/binary"
 require "dhall/normalize"
 require "dhall/resolve"

@@ 4,7 4,6 @@ require "uri"
 require "value_semantics"
 
 require "dhall/util"
-require "dhall/visitor"
 
 module Dhall
 	class Expression


@@ 111,6 110,16 @@ module Dhall
 			argument Expression
 		end)
 
+		def self.for(function:, argument:)
+			if function == Variable["Some"]
+				Optional.new(value: argument)
+			elsif function == Variable["None"]
+				OptionalNone.new(value_type: argument)
+			else
+				new(function: function, argument: argument)
+			end
+		end
+
 		def flatten
 			f, args = if function.is_a?(Application)
 				function.flatten


@@ 132,7 141,7 @@ module Dhall
 
 	class Function < Expression
 		include(ValueSemantics.for_attributes do
-			var  ::String
+			var  Util::AllOf.new(::String, Util::Not.new(Util::BuiltinName))
 			type Either(nil, Expression) # nil is not allowed in proper Dhall
 			body Expression
 		end)


@@ 630,7 639,7 @@ module Dhall
 
 	class UnionType < Expression
 		include(ValueSemantics.for_attributes do
-			alternatives Util::HashOf.new(::String, Expression)
+			alternatives Util::HashOf.new(::String, Either(Expression, nil))
 		end)
 
 		def record


@@ 650,11 659,15 @@ module Dhall
 		end
 
 		def fetch(k, default=nil)
-			Function.new(
-				var:  k,
-				type: alternatives.fetch(k),
-				body: Union.from(self, k, Variable[k])
-			).normalize
+			if (type = alternatives.fetch(k))
+				Function.new(
+					var:  k,
+					type: type,
+					body: Union.from(self, k, Variable[k])
+				).normalize
+			else
+				Union.from(self, k, nil)
+			end
 		rescue KeyError
 			block_given? ? yield : (default || raise)
 		end


@@ 666,21 679,21 @@ module Dhall
 		end
 
 		def as_json
-			[11, Hash[alternatives.to_a.map { |k, v| [k, v.as_json] }.sort]]
+			[11, Hash[alternatives.to_a.map { |k, v| [k, v&.as_json] }.sort]]
 		end
 	end
 
 	class Union < Expression
 		include(ValueSemantics.for_attributes do
 			tag          ::String
-			value        Expression
+			value        Either(Expression, nil)
 			alternatives UnionType
 		end)
 
 		def self.from(alts, tag, value)
 			new(
 				tag:          tag,
-				value:        TypeAnnotation.new(
+				value:        value && TypeAnnotation.new(
 					value: value,
 					type:  alts.alternatives[tag]
 				),


@@ 707,10 720,7 @@ module Dhall
 		end
 	end
 
-	class Number < Expression
-	end
-
-	class Natural < Number
+	class Natural < Expression
 		include(ValueSemantics.for_attributes do
 			value (0..Float::INFINITY)
 		end)


@@ 757,7 767,7 @@ module Dhall
 		end
 	end
 
-	class Integer < Number
+	class Integer < Expression
 		include(ValueSemantics.for_attributes do
 			value ::Integer
 		end)


@@ 771,7 781,7 @@ module Dhall
 		end
 	end
 
-	class Double < Number
+	class Double < Expression
 		include(ValueSemantics.for_attributes do
 			value ::Float
 		end)


@@ 780,16 790,25 @@ module Dhall
 			value.to_s
 		end
 
+		def to_f
+			value
+		end
+
+		def coerce(other)
+			return [other, self] if other.is_a?(Double)
+			[Double.new(value: other.to_f), self]
+		end
+
 		def single?
 			[value].pack("g").unpack("g").first == value
 		end
 
 		def as_json
-			value
+			self
 		end
 
-		def as_cbor
-			self
+		def to_json
+			value.to_json
 		end
 
 		def to_cbor(packer=nil)


@@ 810,7 829,7 @@ module Dhall
 
 	class Text < Expression
 		include(ValueSemantics.for_attributes do
-			value ::String
+			value ::String, coerce: ->(s) { s.encode("utf-8") }
 		end)
 
 		def <<(other)


@@ 832,30 851,58 @@ module Dhall
 
 	class TextLiteral < Expression
 		include(ValueSemantics.for_attributes do
-			chunks ArrayOf(Expression)
+			chunks Util::ArrayOf.new(Expression, min: 3)
 		end)
 
+		def self.for(*chunks)
+			fixed =
+				chunks
+				.flat_map { |c| ["", c, ""] }
+				.map { |c| c.is_a?(Expression) ? c : Text.new(value: c.to_s) }
+				.chunk { |x| x.is_a?(Text) }.flat_map do |(is_text, group)|
+					is_text ? group.reduce(&:<<) : group
+				end
+
+			return Text.new(value: "") if fixed.empty?
+			fixed.length == 1 ? fixed.first : new(chunks: fixed)
+		end
+
 		def as_json
-			raise "TextLiteral must start with a Text" unless chunks.first.is_a?(Text)
 			[18, *chunks.map { |chunk| chunk.is_a?(Text) ? chunk.value : chunk.as_json }]
 		end
 	end
 
 	class Import < Expression
-		def initialize(integrity_check, import_type, path)
-			@integrity_check = integrity_check
-			@import_type = import_type
-			@path = path
-		end
+		class IntegrityCheck
+			include(ValueSemantics.for_attributes do
+				protocol Either("sha256", :nocheck)
+				data     Either(::String, nil)
+			end)
 
-		def as_json
-			[
-				24,
-				@integrity_check&.as_json,
-				IMPORT_TYPES.index(@import_type),
-				PATH_TYPES.index(@path.class),
-				*@path.as_json
-			]
+			class FailureException < StandardError; end
+
+			def initialize(protocol=:nocheck, data=nil)
+				super(
+					protocol: protocol,
+					data: data
+				)
+			end
+
+			def to_s
+				"#{@protocol}:#{@data}"
+			end
+
+			def check(expr)
+				if @protocol != :nocheck && expr.cache_key != to_s
+					raise FailureException, "#{expr} does not match #{self}"
+				end
+
+				expr
+			end
+
+			def as_json
+				@protocol == :nocheck ? nil : [@protocol, @data]
+			end
 		end
 
 		class URI


@@ 864,7 911,6 @@ module Dhall
 				authority ::String
 				path      ArrayOf(::String)
 				query     Either(nil, ::String)
-				fragment  Either(nil, ::String)
 			end)
 
 			HeaderType = RecordType.new(


@@ 874,13 920,12 @@ module Dhall
 				}
 			)
 
-			def initialize(headers, authority, *path, query, fragment)
+			def initialize(headers, authority, *path, query)
 				super(
 					headers:   headers,
 					authority: authority,
 					path:      path,
 					query:     query,
-					fragment:  fragment
 				)
 			end
 


@@ 890,7 935,6 @@ module Dhall
 					authority,
 					*path,
 					query,
-					fragment
 				)
 			end
 


@@ 913,7 957,7 @@ module Dhall
 			end
 
 			def as_json
-				[@headers.as_json, authority, *path, query, fragment]
+				[@headers&.as_json, authority, *path, query]
 			end
 		end
 


@@ 976,7 1020,7 @@ module Dhall
 			end
 
 			def to_uri(scheme, authority)
-				scheme.new(nil, authority, *path, nil, nil)
+				scheme.new(nil, authority, *path, nil)
 			end
 		end
 


@@ 999,6 1043,18 @@ module Dhall
 		end
 
 		class EnvironmentVariable
+			ESCAPES = {
+				"\"" => "\"",
+				"\\" => "\\",
+				"a"  => "\a",
+				"b"  => "\b",
+				"f"  => "\f",
+				"n"  => "\n",
+				"r"  => "\r",
+				"t"  => "\t",
+				"v"  => "\v"
+			}.freeze
+
 			def initialize(var)
 				@var = var
 			end


@@ 1017,7 1073,9 @@ module Dhall
 			end
 
 			def as_json
-				var
+				@var.gsub(/[\"\\\a\b\f\n\r\t\v]/) do |c|
+					"\\" + ESCAPES.find { |(_, v)| v == c }.first
+				end
 			end
 		end
 


@@ 1031,31 1089,6 @@ module Dhall
 			end
 		end
 
-		class IntegrityCheck
-			class FailureException < StandardError; end
-
-			def initialize(protocol=:nocheck, data=nil)
-				@protocol = protocol
-				@data = data
-			end
-
-			def to_s
-				"#{@protocol}:#{@data}"
-			end
-
-			def check(expr)
-				if @protocol != :nocheck && expr.cache_key != to_s
-					raise FailureException, "#{expr} does not match #{self}"
-				end
-
-				expr
-			end
-
-			def as_json
-				@protocol == :nocheck ? nil : [@protocol, @data]
-			end
-		end
-
 		class Expression
 			def self.call(import_value)
 				Dhall.from_binary(import_value)


@@ 1078,11 1111,35 @@ module Dhall
 			AbsolutePath, RelativePath, RelativeToParentPath, RelativeToHomePath,
 			EnvironmentVariable, MissingImport
 		].freeze
+
+		include(ValueSemantics.for_attributes do
+			integrity_check IntegrityCheck, default: IntegrityCheck.new
+			import_type     Class
+			path            Either(*PATH_TYPES)
+		end)
+
+		def initialize(integrity_check, import_type, path)
+			super(
+				integrity_check: integrity_check || IntegrityCheck.new,
+				import_type:     import_type,
+				path:            path
+			)
+		end
+
+		def as_json
+			[
+				24,
+				integrity_check&.as_json,
+				IMPORT_TYPES.index(import_type),
+				PATH_TYPES.index(path.class),
+				*path.as_json
+			]
+		end
 	end
 
 	class Let < Expression
 		include(ValueSemantics.for_attributes do
-			var    ::String
+			var    Util::AllOf.new(::String, Util::Not.new(Util::BuiltinName))
 			assign Expression
 			type   Either(nil, Expression)
 		end)


@@ 1115,11 1172,15 @@ module Dhall
 				let.assign.shift(1, let.var, 0)
 			).shift(-1, let.var, 0)
 		end
+
+		def as_json
+			[25, *let.as_json, body.as_json]
+		end
 	end
 
 	class LetBlock < Expression
 		include(ValueSemantics.for_attributes do
-			lets ArrayOf(Let)
+			lets Util::ArrayOf.new(Let, min: 2)
 			body Expression
 		end)
 

@@ 27,14 27,10 @@ module Dhall
 		end
 
 		def to_cbor(io=nil)
-			CBOR.encode(as_cbor, io)
+			CBOR.encode(as_json, io)
 		end
 		alias to_binary to_cbor
 
-		def as_cbor
-			as_json
-		end
-
 		def digest(digest: Digest::SHA2.new(256))
 			(digest << normalize.to_binary).freeze
 		end


@@ 48,7 44,7 @@ module Dhall
 		def self.decode(function, *args)
 			function = Dhall.decode(function)
 			args.map(&Dhall.method(:decode)).reduce(function) do |f, arg|
-				new(function: f, argument: arg)
+				self.for(function: f, argument: arg)
 			end
 		end
 	end


@@ 149,7 145,9 @@ module Dhall
 
 	class UnionType
 		def self.decode(record)
-			new(alternatives: Hash[record.map { |k, v| [k, Dhall.decode(v)] }])
+			new(alternatives: Hash[record.map { |k, v|
+				[k, v.nil? ? v : Dhall.decode(v)]
+			}])
 		end
 	end
 


@@ 189,6 187,13 @@ module Dhall
 	class Import
 		def self.decode(integrity_check, import_type, path_type, *parts)
 			parts[0] = Dhall.decode(parts[0]) if path_type < 2 && !parts[0].nil?
+			if PATH_TYPES[path_type] == EnvironmentVariable
+				parts = parts.map do |part|
+					part.gsub(/\\[\"\\abfnrtv]/) do |escape|
+						EnvironmentVariable::ESCAPES.fetch(escape[1])
+					end
+				end
+			end
 
 			new(
 				IntegrityCheck.new(*integrity_check),


@@ 200,16 205,20 @@ module Dhall
 
 	class LetBlock
 		def self.decode(*parts)
-			new(
-				body: Dhall.decode(parts.pop),
-				lets: parts.each_slice(3).map do |(var, type, assign)|
-					Let.new(
-						var:    var,
-						assign: Dhall.decode(assign),
-						type:   type.nil? ? nil : Dhall.decode(type)
-					)
-				end
-			)
+			body = Dhall.decode(parts.pop)
+			lets = parts.each_slice(3).map do |(var, type, assign)|
+				Let.new(
+					var:    var,
+					assign: Dhall.decode(assign),
+					type:   type.nil? ? nil : Dhall.decode(type)
+				)
+			end
+
+			if lets.length == 1
+				LetIn.new(let: lets.first, body: body)
+			else
+				new(lets: lets, body: body)
+			end
 		end
 	end
 

@@ 12,8 12,11 @@ module Dhall
 				Util::ArrayOf.new(Expression)                          => lambda do |x|
 					x.map(&block)
 				end,
-				Util::HashOf.new(ValueSemantics::Anything, Expression) => lambda do |x|
-					Hash[x.map { |k, v| [k, block[v]] }]
+				Util::HashOf.new(
+					ValueSemantics::Anything,
+					ValueSemantics::Either.new([Expression, nil])
+				) => lambda do |x|
+					Hash[x.map { |k, v| [k, v.nil? ? v : block[v]] }]
 				end
 			)
 		end


@@ 263,9 266,13 @@ module Dhall
 		def normalize
 			normalized = super
 			if normalized.record.is_a?(Record) && normalized.input.is_a?(Union)
-				normalized.record.fetch(normalized.input.tag).call(
-					normalized.input.value
-				)
+				if normalized.input.value.nil?
+					normalized.record.fetch(normalized.input.tag)
+				else
+					normalized.record.fetch(normalized.input.tag).call(
+						normalized.input.value
+					)
+				end
 			else
 				normalized
 			end


@@ 331,17 338,7 @@ module Dhall
 
 	class TextLiteral
 		def normalize
-			chunks =
-				super
-				.flatten.chunks.chunk { |x| x.is_a?(Text) }.flat_map do |(_, group)|
-					if group.first.is_a?(Text)
-						[Text.new(value: group.map(&:value).join)]
-					else
-						group
-					end
-				end
-
-			chunks.length == 1 ? chunks.first : with(chunks: chunks)
+			TextLiteral.for(*super.flatten.chunks)
 		end
 
 		def flatten

@@ 0,0 1,530 @@
+# frozen_string_literal: true
+
+require "dhall/ast"
+require "dhall/builtins"
+
+module Dhall
+	module Parser
+		def self.parse(*args)
+			CitrusParser.parse(*args)
+		end
+
+		def self.parse_file(*args)
+			CitrusParser.parse_file(*args)
+		end
+
+		module CompleteExpression
+			def value
+				capture(:expression).value
+			end
+		end
+
+		def self.operator_expression(capture, ast_class)
+			Module.new do
+				define_method(:value) do
+					captures(capture).map(&:value).reduce do |lhs, rhs|
+						Operator.const_get(ast_class).new(lhs: lhs, rhs: rhs)
+					end
+				end
+			end
+		end
+
+		ImportAltExpression = operator_expression(:or_expression, :ImportFallback)
+		OrExpression = operator_expression(:plus_expression, :Or)
+		PlusExpression = operator_expression(:text_append_expression, :Plus)
+		TextAppendExpression = operator_expression(:list_append_expression, :TextConcatenate)
+		ListAppendExpression = operator_expression(:and_expression, :ListConcatenate)
+		AndExpression = operator_expression(:combine_expression, :And)
+		CombineExpression = operator_expression(:prefer_expression, :RecursiveRecordMerge)
+		PreferExpression = operator_expression(:combine_types_expression, :RightBiasedRecordMerge)
+		CombineTypesExpression = operator_expression(:times_expression, :RecursiveRecordTypeMerge)
+		TimesExpression = operator_expression(:equal_expression, :Times)
+		EqualExpression = operator_expression(:not_equal_expression, :Equal)
+		NotEqualExpression = operator_expression(:application_expression, :NotEqual)
+
+		module ApplicationExpression
+			def value
+				some = capture(:some) ? [Variable["Some"]] : []
+				els = some + captures(:import_expression).map(&:value)
+				els.reduce do |f, arg|
+					Application.for(function: f, argument: arg)
+				end
+			end
+		end
+
+		module SelectorExpression
+			def value
+				record = first.value
+				selectors = matches[1].matches
+				selectors.reduce(record) do |rec, sel|
+					if sel.captures.key?(:labels)
+						sels = sel.capture(:labels).captures(:any_label).map(&:value)
+						return EmptyRecordProjection.new(record: rec) if sels.empty?
+						RecordProjection.new(record: rec, selectors: sels)
+					else
+						RecordSelection.new(
+							record:   rec,
+							selector: sel.capture(:any_label).value
+						)
+					end
+				end
+			end
+		end
+
+		module Label
+			def value
+				if first.string == "`"
+					matches[1].string
+				else
+					string
+				end
+			end
+		end
+
+		module NonreservedLabel
+			def value
+				if captures.key?(:label)
+					capture(:label).value
+				else
+					string
+				end
+			end
+		end
+
+		module NaturalLiteral
+			def value
+				Natural.new(value: string.to_i)
+			end
+		end
+
+		module IntegerLiteral
+			def value
+				Integer.new(value: string.to_i)
+			end
+		end
+
+		module DoubleLiteral
+			def value
+				key = captures.keys.select { |k| k.is_a?(Symbol) }.first
+				Double.new(value: case key
+					when :infinity
+						string == "-Infinity" ? -Float::INFINITY : Float::INFINITY
+					when :nan
+						Float::NAN
+					else
+						float = string.to_f
+						if float.nan? || float.infinite?
+							raise Citrus::ParseError, input
+						end
+						float
+					end
+				)
+			end
+		end
+
+		module DoubleQuoteLiteral
+			def value
+				TextLiteral.for(
+					*captures(:double_quote_chunk)
+					.map(&:value)
+					.chunk { |s| s.is_a?(String) }
+					.flat_map { |(is_string, group)|
+						is_string ? group.join : group
+					}
+				)
+			end
+		end
+
+		module DoubleQuoteChunk
+			ESCAPES = {
+				"\"" => "\"",
+				"$"  => "$",
+				"\\" => "\\",
+				"/"  => "/",
+				"b"  => "\b",
+				"f"  => "\f",
+				"n"  => "\n",
+				"r"  => "\r",
+				"t"  => "\t"
+			}.freeze
+
+			def value
+				if first&.string == "\\" && matches[1].string =~ /\Au\h+\Z/i
+					[matches[1].string[1..-1]].pack("H*").force_encoding("UTF-16BE")
+				elsif first&.string == "\\"
+					ESCAPES.fetch(matches[1].string) do
+						raise "Invalid escape: #{string}"
+					end.encode("UTF-16BE")
+				elsif first&.string == "${"
+					matches[1].value
+				else
+					string.encode("UTF-16BE")
+				end
+			end
+		end
+
+		module SingleQuoteLiteral
+			def value
+				chunks = capture(:single_quote_continue).value.flatten
+				indent = chunks.join.split(/\n/, -1).map { |line|
+					line.match(/^( *|\t*)/).to_s.length
+				}.min
+
+				TextLiteral.for(
+					*chunks
+					.chunk { |c| c != "\n" }
+					.flat_map { |(line, chunk)| line ? chunk[indent..-1] : chunk }
+				)
+			end
+		end
+
+		module SingleQuoteContinue
+			ESCAPES = {
+				"'''"  => "''",
+				"''${" => "${"
+			}.freeze
+
+			def value
+				if matches.length == 2
+					[ESCAPES.fetch(first.string, first.string), matches[1].value]
+				elsif matches.length == 0
+					[]
+				else
+					[
+						capture(:complete_expression).value,
+						capture(:single_quote_continue).value
+					]
+				end
+			end
+		end
+
+		module NonEmptyListLiteral
+			def value
+				List.new(elements: captures(:expression).map(&:value))
+			end
+		end
+
+		module Identifier
+			def value
+				name = capture(:any_label).value
+
+				return Dhall::Bool.new(value: true) if name == "True"
+				return Dhall::Bool.new(value: false) if name == "False"
+
+				Dhall::Builtins::ALL[name]&.new ||
+					Variable.new(
+						name:  name,
+						index: capture(:natural_literal)&.string.to_i
+					)
+			end
+		end
+
+		module PrimitiveExpression
+			def value
+				if first&.string == "("
+					capture(:expression).value
+				elsif first&.string == "{"
+					capture(:record_type_or_literal).value
+				elsif first&.string == "<"
+					capture(:union_type_or_literal).value
+				else
+					super
+				end
+			end
+		end
+
+		module UnionTypeOrLiteral
+			def value
+				if captures[0].string == ""
+					UnionType.new(alternatives: {})
+				else
+					super
+				end
+			end
+		end
+
+		module NonEmptyUnionTypeOrLiteral
+			def value
+				cont = matches[1].first
+
+				if cont && cont.matches[1].first.string == "="
+					Union.new(
+						tag:          captures(:any_label).first.value,
+						value:        captures(:expression).first.value,
+						alternatives: UnionType.new(alternatives: ::Hash[
+							captures(:any_label)[1..-1].map(&:value).zip(
+								captures(:expression)[1..-1].map(&:value)
+							)
+						])
+					)
+				else
+					type = UnionType.new(alternatives: ::Hash[
+						captures(:any_label).map(&:value).zip(
+							captures(:expression).map(&:value)
+						)
+					])
+					rest = cont && cont.matches[1].capture(:non_empty_union_type_or_literal)&.value
+					if rest.is_a?(Union)
+						rest.with(alternatives: type.merge(rest.alternatives))
+					elsif rest
+						type.merge(rest)
+					else
+						type
+					end
+				end
+			end
+		end
+
+		module RecordTypeOrLiteral
+			def value
+				if captures[0].string == "="
+					EmptyRecord.new
+				elsif captures[0].string == ""
+					EmptyRecordType.new
+				else
+					super
+				end
+			end
+		end
+
+		module NonEmptyRecordTypeOrLiteral
+			def value
+				if captures.key?(:non_empty_record_literal)
+					capture(:non_empty_record_literal).value(
+						capture(:any_label).value
+					)
+				else
+					capture(:non_empty_record_type).value(
+						capture(:any_label).value
+					)
+				end
+			end
+		end
+
+		module NonEmptyRecordLiteral
+			def value(first_key)
+				keys = [first_key] + captures(:any_label).map(&:value)
+				values = captures(:expression).map(&:value)
+				Record.new(record: ::Hash[keys.zip(values)])
+			end
+		end
+
+		module NonEmptyRecordType
+			def value(first_key)
+				keys = [first_key] + captures(:any_label).map(&:value)
+				values = captures(:expression).map(&:value)
+				RecordType.new(record: ::Hash[keys.zip(values)])
+			end
+		end
+
+		module EmptyCollection
+			def value
+				if captures.key?(:list)
+					EmptyList.new(element_type: capture(:import_expression).value)
+				else
+					OptionalNone.new(value_type: capture(:import_expression).value)
+				end
+			end
+		end
+
+		module NonEmptyOptional
+			def value
+				Optional.new(
+					value:      capture(:expression).value,
+					value_type: capture(:import_expression).value
+				)
+			end
+		end
+
+		module AnnotatedExpression
+			def value
+				if captures.key?(:empty_collection)
+					capture(:empty_collection).value
+				elsif captures.key?(:non_empty_optional)
+					capture(:non_empty_optional).value
+				elsif matches.length == 2
+					TypeAnnotation.new(
+						value: first.value,
+						type:  matches[1].capture(:expression).value
+					)
+				else
+					super
+				end
+			end
+		end
+
+		module Expression
+			def value
+				keys = captures.keys.select { |k| k.is_a?(Symbol) }
+				if keys.length == 1
+					capture(keys.first).value
+				elsif captures.key?(:let)
+					lets = first.matches.map { |let_match|
+						exprs = let_match.captures(:expression)
+						Let.new(
+							var:    let_match.capture(:nonreserved_label).value,
+							assign: exprs.last.value,
+							type:   exprs.length > 1 ? exprs.first.value : nil,
+						)
+					}
+
+					if lets.length == 1
+						LetIn.new(let: lets.first, body: matches.last.value)
+					else
+						LetBlock.new(lets: lets, body: matches.last.value)
+					end
+				elsif captures.key?(:lambda)
+					Function.new(
+						var:  capture(:nonreserved_label).value,
+						type: captures(:expression)[0].value,
+						body: captures(:expression)[1].value
+					)
+				elsif captures.key?(:forall)
+					Forall.new(
+						var:  capture(:nonreserved_label).value,
+						type: captures(:expression)[0].value,
+						body: captures(:expression)[1].value
+					)
+				elsif captures.key?(:arrow)
+					Forall.of_arguments(
+						capture(:operator_expression).value,
+						body: capture(:expression).value
+					)
+				elsif captures.key?(:if)
+					If.new(
+						predicate: captures(:expression)[0].value,
+						then:      captures(:expression)[1].value,
+						else:      captures(:expression)[2].value,
+					)
+				elsif captures.key?(:merge)
+					Merge.new(
+						record: captures(:import_expression)[0].value,
+						input:  captures(:import_expression)[1].value,
+						type:   capture(:application_expression)&.value
+					)
+				else
+					super
+				end
+			end
+		end
+
+		module Import
+			def value
+				import_type = if captures.key?(:text)
+					Dhall::Import::Text
+				else
+					Dhall::Import::Expression
+				end
+
+				capture(:import_hashed).value(import_type)
+			end
+		end
+
+		module ImportHashed
+			def value(import_type)
+				integrity_check = capture(:hash)&.value
+				path = capture(:import_type).value
+				Dhall::Import.new(integrity_check, import_type, path)
+			end
+		end
+
+		module Hash
+			def value
+				protocol, data = string.split(/:/, 2)
+				Dhall::Import::IntegrityCheck.new(protocol, data)
+			end
+		end
+
+		module Http
+			SCHEME = {
+				"http"  => Dhall::Import::Http,
+				"https" => Dhall::Import::Https,
+			}.freeze
+
+			def self.escape(s)
+				URI.encode_www_form_component(s).gsub("+", "%20")
+			end
+
+			def value
+				http = capture(:http_raw)
+				SCHEME.fetch(http.capture(:scheme).value).new(
+					if captures.key?(:import_hashed)
+						capture(:import_hashed).value(Dhall::Import::Expression)
+					end,
+					http.capture(:authority).value,
+					*http.capture(:path).captures(:path_component).map { |c|
+						# https://github.com/dhall-lang/dhall-lang/issues/456
+						c.value # (Http.method(:escape))
+					},
+					http.capture(:query)&.value
+				)
+			end
+		end
+
+		module Env
+			def value
+				Dhall::Import::EnvironmentVariable.new(
+					if captures.key?(:bash_environment_variable)
+						capture(:bash_environment_variable).string
+					else
+						capture(:posix_environment_variable).value.encode("utf-8")
+					end
+				)
+			end
+		end
+
+		module PosixEnvironmentVariable
+			def value
+				matches.map(&:value).join
+			end
+		end
+
+		module PosixEnvironmentVariableCharacter
+			ESCAPES = Dhall::Import::EnvironmentVariable::ESCAPES
+
+			def value
+				if first&.string == "\\"
+					ESCAPES.fetch(matches[1].string) do
+						raise "Invalid escape: #{string}"
+					end.encode("UTF-16BE")
+				else
+					string
+				end
+			end
+		end
+
+		module Local
+			KLASS = {
+				"/"  => Dhall::Import::AbsolutePath,
+				"."  => Dhall::Import::RelativePath,
+				".." => Dhall::Import::RelativeToParentPath,
+				"~"  => Dhall::Import::RelativeToHomePath
+			}.freeze
+
+			def value
+				path = capture(:path).captures(:path_component).map(&:value)
+				klass = KLASS.find { |prefix, _| string.start_with?(prefix) }.last
+				klass.new(*path)
+			end
+		end
+
+		module PathComponent
+			def value(escaper=:itself.to_proc)
+				if captures.key?(:quoted_path_character)
+					escaper.call(matches[1].matches[1].value)
+				else
+					matches[1].value
+				end
+			end
+		end
+
+		module Missing
+			def value
+				Dhall::Import::MissingImport.new
+			end
+		end
+	end
+end
+
+require "citrus"
+Citrus.require "dhall/parser"

@@ 51,6 51,58 @@ module Dhall
 			end
 		end
 
+		class Not
+			def initialize(validator)
+				@validator = validator
+			end
+
+			def ===(other)
+				!(@validator === other)
+			end
+		end
+
+		module BuiltinName
+			NAMES = [
+				"Natural/build",
+				"Natural/fold",
+				"Natural/isZero",
+				"Natural/even",
+				"Natural/odd",
+				"Natural/toInteger",
+				"Natural/show",
+				"Integer/toDouble",
+				"Integer/show",
+				"Double/show",
+				"List/build",
+				"List/fold",
+				"List/length",
+				"List/head",
+				"List/last",
+				"List/indexed",
+				"List/reverse",
+				"Optional/fold",
+				"Optional/build",
+				"Text/show",
+				"Bool",
+				"Optional",
+				"Natural",
+				"Integer",
+				"Double",
+				"Text",
+				"List",
+				"True",
+				"False",
+				"None",
+				"Type",
+				"Kind",
+				"Sort"
+			].freeze
+
+			def self.===(other)
+				NAMES.include?(other)
+			end
+		end
+
 		def self.match_results(xs=nil, ys=nil)
 			Array(xs).each_with_index.map do |r, idx|
 				yield r, ys[idx]

@@ 0,0 1,166 @@
+require "abnf"
+
+require "dhall/parser"
+require "dhall/util"
+
+class RegexpTree::CharClass
+	def encode_elt(e)
+		case e
+		when 0x09; '\t'
+		when 0x0a; '\n'
+		when 0x0d; '\r'
+		when 0x0c; '\f'
+		when 0x0b; '\v'
+		when 0x07; '\a'
+		when 0x1b; '\e'
+		when 0x21, 0x22, 0x25, 0x26, 0x27, 0x2c, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x2f, 0x30..0x39, 0x40, 0x41..0x5a, 0x5f, 0x60, 0x61..0x7a, 0x7e
+			sprintf("%c", e)
+		else
+			sprintf("\\u{%02x}", e)
+		end
+	end
+end
+
+class Sequence
+	attr_reader :seq
+
+	def initialize(*seq)
+		@seq = seq
+	end
+
+	def +(other)
+		if other.is_a?(Sequence)
+			self.class.new(*seq, *other.seq)
+		else
+			self.class.new(*seq, other)
+		end
+	end
+
+	def to_s
+		@seq.join(' ')
+	end
+end
+
+class Terminal
+	SAFE = /\A[\w_:']+\Z/
+
+	def initialize(regex)
+		@regex = regex
+	end
+
+	def +(other)
+		if options == other.options
+			self.class.new(Regexp.compile("#{source}#{other.source}", options))
+		else
+			Sequence.new(self, other)
+		end
+	end
+
+	def options
+		@regex.options
+	end
+
+	def source
+		if SAFE =~ @regex.source
+			@regex.source
+		else
+			"(?:#{@regex.source})"
+		end
+	end
+
+	def to_s
+		if SAFE =~ @regex.source
+			if @regex.casefold?
+				"`#{@regex.source}`"
+			else
+				@regex.source.inspect
+			end
+		else
+			@regex.inspect
+		end
+	end
+end
+
+class RuleFormatter
+	def initialize(abnf)
+		@abnf = abnf
+		@bogus = 0
+	end
+
+	def bogus_name
+		"____#{@bogus += 1}".intern
+	end
+
+	def format_anon_rule(rule)
+		name = bogus_name
+		@abnf[name] = rule
+		formatted = format_rule(name, rule)
+		formatted.is_a?(Terminal) ? formatted : "(#{formatted})"
+	end
+
+	def format_rule(name, rule)
+		if name == :"simple-label"
+			return "keyword simple_label_next_char+ | !keyword (simple_label_first_char simple_label_next_char*)"
+		end
+
+		if name == :"nonreserved-label"
+			return "reserved_identifier simple_label_next_char+ | !reserved_identifier label"
+		end
+
+		case rule
+		when ABNF::Term
+			Terminal.new(@abnf.regexp(name))
+		when ABNF::Var
+			rule.name.to_s.gsub(/-/, '_')
+		when ABNF::Seq
+			if rule.elts.empty?
+				'""'
+			else
+				rule.elts.map(&method(:format_anon_rule)).chunk { |x| x.is_a?(Terminal) }.flat_map { |(terminal, chunk)|
+					terminal ? chunk.reduce(:+) : Sequence.new(chunk)
+				}.join(' ')
+			end
+		when ABNF::Alt
+			rule.elts.map(&method(:format_anon_rule)).join(' | ')
+		when ABNF::Rep
+			base = format_anon_rule(rule.elt)
+			if rule.min == 0 && rule.max.nil?
+				"#{base}*"
+			elsif rule.min == 1 && rule.max.nil?
+				"#{base}+"
+			elsif rule.min == 0 && rule.max == 1
+				"#{base}?"
+			else
+				"#{base} #{rule.min}*#{rule.max}"
+			end
+		else
+			raise "Unknown rule type: #{rule.inspect}"
+		end
+
+	end
+end
+
+puts "grammar Dhall::Parser::CitrusParser"
+puts "\troot complete_expression"
+
+abnf = ABNF.parse(STDIN.read)
+formatter = RuleFormatter.new(abnf)
+abnf.each do |name, rule|
+	next if name.to_s.start_with?("____")
+	puts "rule #{name.to_s.gsub(/-/, '_')}"
+	print "\t(#{formatter.format_rule(name, rule)})"
+	extension = name.to_s.split(/-/).map(&:capitalize).join
+	if Dhall::Parser.const_defined?(extension)
+		puts " <Dhall::Parser::#{extension}>"
+	else
+		puts
+	end
+	puts "end"
+end
+
+puts "rule reserved_identifier"
+print "\t"
+puts Dhall::Util::BuiltinName::NAMES.map { |name| "\"#{name}\"" }.join(" |\n\t")
+puts "end"
+
+puts "end"

@@ 1,1 0,0 @@
-�aAab>
\ No newline at end of file

@@ 1,1 0,0 @@
-�aAab>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axaAax>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axaA�aBax>
\ No newline at end of file

@@ 1,1 0,0 @@
-�aA�aB>
\ No newline at end of file

@@ 1,1 0,0 @@
-�aAaB>
\ No newline at end of file

@@ 1,1 0,0 @@
-�aAaB>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axaAax>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axaA�aBax>
\ No newline at end of file

@@ 1,1 0,0 @@
-�aA�aB>
\ No newline at end of file

@@ 1,1 0,0 @@
-dBool>
\ No newline at end of file

@@ 1,1 0,0 @@
-dBool>
\ No newline at end of file

@@ 1,1 0,0 @@
-fDouble>
\ No newline at end of file

@@ 1,1 0,0 @@
-fDouble>
\ No newline at end of file

@@ 1,1 0,0 @@
-�?�333333>
\ No newline at end of file

@@ 1,1 0,0 @@
-�?�333333>
\ No newline at end of file

@@ 1,1 0,0 @@
-kDouble/show>
\ No newline at end of file

@@ 1,1 0,0 @@
-kDouble/show>
\ No newline at end of file

@@ 1,1 0,0 @@
-�c1.2>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-ay>
\ No newline at end of file

@@ 1,1 0,0 @@
-ay>
\ No newline at end of file

@@ 1,1 0,0 @@
-���aXaY��aAaB>
\ No newline at end of file

@@ 1,1 0,0 @@
-�aXaA>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axayay>
\ No newline at end of file

@@ 1,1 0,0 @@
-ay>
\ No newline at end of file

@@ 1,1 0,0 @@
-���>
\ No newline at end of file

@@ 1,1 0,0 @@
-�>
\ No newline at end of file

@@ 1,1 0,0 @@
-���axay��aaab��acad>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axaaac>
\ No newline at end of file

@@ 1,1 0,0 @@
-�ax��>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-����>
\ No newline at end of file

@@ 1,1 0,0 @@
-�>
\ No newline at end of file

@@ 1,1 0,0 @@
-gInteger>
\ No newline at end of file

@@ 1,1 0,0 @@
-gInteger>
\ No newline at end of file

@@ 1,1 0,0 @@
-� >
\ No newline at end of file

@@ 1,1 0,0 @@
-� >
\ No newline at end of file

@@ 1,1 0,0 @@
-�>
\ No newline at end of file

@@ 1,1 0,0 @@
-�>
\ No newline at end of file

@@ 1,1 0,0 @@
-�c-12>
\ No newline at end of file

@@ 1,1 0,0 @@
-�c+12>
\ No newline at end of file

@@ 1,1 0,0 @@
-lInteger/show>
\ No newline at end of file

@@ 1,1 0,0 @@
-lInteger/show>
\ No newline at end of file

@@ 1,1 0,0 @@
-pInteger/toDouble>
\ No newline at end of file

@@ 1,1 0,0 @@
-pInteger/toDouble>
\ No newline at end of file

@@ 1,1 0,0 @@
-dKind>
\ No newline at end of file

@@ 1,1 0,0 @@
-dKind>
\ No newline at end of file

@@ 1,1 0,0 @@
-�ax�ayax>
\ No newline at end of file

@@ 1,1 0,0 @@
-ay>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axaAayax>
\ No newline at end of file

@@ 1,1 0,0 @@
-ay>
\ No newline at end of file

@@ 1,1 0,0 @@
-dList>
\ No newline at end of file

@@ 1,1 0,0 @@
-dList>
\ No newline at end of file

@@ 1,1 0,0 @@
-jList/build>
\ No newline at end of file

@@ 1,1 0,0 @@
-jList/build>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-iList/fold>
\ No newline at end of file

@@ 1,1 0,0 @@
-iList/fold>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-iList/head>
\ No newline at end of file

@@ 1,1 0,0 @@
-iList/head>
\ No newline at end of file

@@ 1,1 0,0 @@
-�aT>
\ No newline at end of file

@@ 1,1 0,0 @@
-���>
\ No newline at end of file

@@ 1,1 0,0 @@
-lList/indexed>
\ No newline at end of file

@@ 1,1 0,0 @@
-lList/indexed>
\ No newline at end of file

@@ 1,1 0,0 @@
-���eindexgNaturalevalueaT>
\ No newline at end of file

@@ 1,1 0,0 @@
-iList/last>
\ No newline at end of file

@@ 1,1 0,0 @@
-iList/last>
\ No newline at end of file

@@ 1,1 0,0 @@
-�aT>
\ No newline at end of file

@@ 1,1 0,0 @@
-���>
\ No newline at end of file

@@ 1,1 0,0 @@
-kList/length>
\ No newline at end of file

@@ 1,1 0,0 @@
-kList/length>
\ No newline at end of file

@@ 1,1 0,0 @@
-�>
\ No newline at end of file

@@ 1,1 0,0 @@
-����axay>
\ No newline at end of file

@@ 1,1 0,0 @@
-��ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-���axay>
\ No newline at end of file

@@ 1,1 0,0 @@
-�ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-lList/reverse>
\ No newline at end of file

@@ 1,1 0,0 @@
-lList/reverse>
\ No newline at end of file

@@ 1,1 0,0 @@
-�aT>
\ No newline at end of file

@@ 1,1 0,0 @@
-����>
\ No newline at end of file

@@ 1,1 0,0 @@
-ay>
\ No newline at end of file

@@ 1,1 0,0 @@
-���axay��azab>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axaz>
\ No newline at end of file

@@ 1,1 0,0 @@
-ay>
\ No newline at end of file

@@ 1,1 0,0 @@
-���axay��azab��aXaY>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axazaX>
\ No newline at end of file

@@ 1,1 0,0 @@
-gNatural>
\ No newline at end of file

@@ 1,1 0,0 @@
-gNatural>
\ No newline at end of file

@@ 1,1 0,0 @@
-mNatural/build>
\ No newline at end of file

@@ 1,1 0,0 @@
-mNatural/build>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-lNatural/even>
\ No newline at end of file

@@ 1,1 0,0 @@
-lNatural/even>
\ No newline at end of file

@@ 1,1 0,0 @@
-�>
\ No newline at end of file

@@ 1,1 0,0 @@
-�>
\ No newline at end of file

@@ 1,1 0,0 @@
-lNatural/fold>
\ No newline at end of file

@@ 1,1 0,0 @@
-lNatural/fold>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-nNatural/isZero>
\ No newline at end of file

@@ 1,1 0,0 @@
-nNatural/isZero>
\ No newline at end of file

@@ 1,1 0,0 @@
-�>
\ No newline at end of file

@@ 1,1 0,0 @@
-�>
\ No newline at end of file

@@ 1,1 0,0 @@
-�>
\ No newline at end of file

@@ 1,1 0,0 @@
-�>
\ No newline at end of file

@@ 1,1 0,0 @@
-kNatural/odd>
\ No newline at end of file

@@ 1,1 0,0 @@
-kNatural/odd>
\ No newline at end of file

@@ 1,1 0,0 @@
-�>
\ No newline at end of file

@@ 1,1 0,0 @@
-�>
\ No newline at end of file

@@ 1,1 0,0 @@
-lNatural/show>
\ No newline at end of file

@@ 1,1 0,0 @@
-lNatural/show>
\ No newline at end of file

@@ 1,1 0,0 @@
-�a1>
\ No newline at end of file

@@ 1,1 0,0 @@
-qNatural/toInteger>
\ No newline at end of file

@@ 1,1 0,0 @@
-qNatural/toInteger>
\ No newline at end of file

@@ 1,1 0,0 @@
-�>
\ No newline at end of file

@@ 1,1 0,0 @@
-dNone>
\ No newline at end of file

@@ 1,1 0,0 @@
-dNone>
\ No newline at end of file

@@ 1,1 0,0 @@
-�gNatural>
\ No newline at end of file

@@ 1,1 0,0 @@
-�gNatural>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axax>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-��ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-�>
\ No newline at end of file

@@ 1,1 0,0 @@
-��ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-���ax��ay>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axay>
\ No newline at end of file

@@ 1,1 0,0 @@
-�ax�>
\ No newline at end of file

@@ 1,1 0,0 @@
-�>
\ No newline at end of file

@@ 1,1 0,0 @@
-�ax�>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axax>
\ No newline at end of file

@@ 1,1 0,0 @@
-�>
\ No newline at end of file

@@ 1,1 0,0 @@
-�ax�>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-���ax��ay>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axay>
\ No newline at end of file

@@ 1,1 0,0 @@
-��ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-�ax�aT>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-���ax��ay>
\ No newline at end of file

@@ 1,1 0,0 @@
-��axay>
\ No newline at end of file

@@ 1,1 0,0 @@
-���aTax��aTay>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axay>
\ No newline at end of file

@@ 1,1 0,0 @@
-��aTax>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axax>
\ No newline at end of file

@@ 1,1 0,0 @@
-�>
\ No newline at end of file

@@ 1,1 0,0 @@
-��ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-���ax��ay>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axay>
\ No newline at end of file

@@ 1,1 0,0 @@
-�ax�>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-�>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-�>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axay>
\ No newline at end of file

@@ 1,1 0,0 @@
-���>
\ No newline at end of file

@@ 1,1 0,0 @@
-�>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-��`ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-���`ax��`ay>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axay>
\ No newline at end of file

@@ 1,1 0,0 @@
-�ax�`>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-��ax�ay>
\ No newline at end of file

@@ 1,1 0,0 @@
-�bxy>
\ No newline at end of file

@@ 1,1 0,0 @@
-��ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-���ax��ay>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axay>
\ No newline at end of file

@@ 1,1 0,0 @@
-�ax�>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-���>
\ No newline at end of file

@@ 1,1 0,0 @@
-�>
\ No newline at end of file

@@ 1,1 0,0 @@
-hOptional>
\ No newline at end of file

@@ 1,1 0,0 @@
-hOptional>
\ No newline at end of file

@@ 1,1 0,0 @@
-nOptional/build>
\ No newline at end of file

@@ 1,1 0,0 @@
-nOptional/build>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-mOptional/fold>
\ No newline at end of file

@@ 1,1 0,0 @@
-mOptional/fold>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-��aa��ayazabax>
\ No newline at end of file

@@ 1,1 0,0 @@
-��aaayabax>
\ No newline at end of file

@@ 1,1 0,0 @@
-��>
\ No newline at end of file

@@ 1,1 0,0 @@
-��>
\ No newline at end of file

@@ 1,2 0,0 @@
-�
-��axaaayabazacaxaz>
\ No newline at end of file

@@ 1,1 0,0 @@
-��axaaazac>
\ No newline at end of file

@@ 1,2 0,0 @@
-�
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-��>
\ No newline at end of file

@@ 1,2 0,0 @@
-�
-��ayazaxay>
\ No newline at end of file

@@ 1,2 0,0 @@
-�
-ayaxay>
\ No newline at end of file

@@ 1,1 0,0 @@
-�	��axavax>
\ No newline at end of file

@@ 1,1 0,0 @@
-av>
\ No newline at end of file

@@ 1,1 0,0 @@
-�	��ayazax>
\ No newline at end of file

@@ 1,1 0,0 @@
-�	ayax>
\ No newline at end of file

@@ 1,1 0,0 @@
-��aa��aAaBabaT>
\ No newline at end of file

@@ 1,1 0,0 @@
-��aaaAabaT>
\ No newline at end of file

@@ 1,1 0,0 @@
-��>
\ No newline at end of file

@@ 1,1 0,0 @@
-��>
\ No newline at end of file

@@ 1,1 0,0 @@
-���ax��az���ax��ay�>
\ No newline at end of file

@@ 1,1 0,0 @@
-��ax��ay�az�>
\ No newline at end of file

@@ 1,1 0,0 @@
-���ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-���ax��az���ab��ay�>
\ No newline at end of file

@@ 1,1 0,0 @@
-��ab��ay�ax��az�>
\ No newline at end of file

@@ 1,1 0,0 @@
-��ax�����ab>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axab>
\ No newline at end of file

@@ 1,1 0,0 @@
-�ax��>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,2 0,0 @@
-�
-��ax��azaA��ax��ayaB>
\ No newline at end of file

@@ 1,1 0,0 @@
-��ax��ayaBazaA>
\ No newline at end of file

@@ 1,2 0,0 @@
-�
-��ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,2 0,0 @@
-�
-��ax��azaA��ab��ayaB>
\ No newline at end of file

@@ 1,1 0,0 @@
-��ab��ayaBax��azaA>
\ No newline at end of file

@@ 1,4 0,0 @@
-�
-�
-ax���
-��ab>
\ No newline at end of file

@@ 1,2 0,0 @@
-�
-axab>
\ No newline at end of file

@@ 1,2 0,0 @@
-�
-ax��>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-�	��ax�ay���ax�>
\ No newline at end of file

@@ 1,1 0,0 @@
-��ax�ay�>
\ No newline at end of file

@@ 1,1 0,0 @@
-�	��ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-�	��ax�ay���aa�>
\ No newline at end of file

@@ 1,1 0,0 @@
-��aa�ax�ay�>
\ No newline at end of file

@@ 1,1 0,0 @@
-�	�	ax���	ay��>
\ No newline at end of file

@@ 1,1 0,0 @@
-�	axay>
\ No newline at end of file

@@ 1,1 0,0 @@
-�	ax��>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-����axay>
\ No newline at end of file

@@ 1,1 0,0 @@
-��ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-dSort>
\ No newline at end of file

@@ 1,1 0,0 @@
-dSort>
\ No newline at end of file

@@ 1,1 0,0 @@
-dText>
\ No newline at end of file

@@ 1,1 0,0 @@
-dText>
\ No newline at end of file

@@ 1,1 0,0 @@
-�as�abax``>
\ No newline at end of file

@@ 1,1 0,0 @@
-�bsbax`>
\ No newline at end of file

@@ 1,1 0,0 @@
-�as>
\ No newline at end of file

@@ 1,1 0,0 @@
-�as>
\ No newline at end of file

@@ 1,1 0,0 @@
-�as��axay`>
\ No newline at end of file

@@ 1,1 0,0 @@
-�asax`>
\ No newline at end of file

@@ 1,1 0,0 @@
-iText/show>
\ No newline at end of file

@@ 1,1 0,0 @@
-�x("\"\u0024\\\b\f\n\r\tツa\u0007b\u0010c">
\ No newline at end of file

@@ 1,1 0,0 @@
-iText/show>
\ No newline at end of file

@@ 1,1 0,0 @@
-�>
\ No newline at end of file

@@ 1,1 0,0 @@
-�>
\ No newline at end of file

@@ 1,1 0,0 @@
-dType>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axaA>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-dType>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axay�ay��aXaY>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axay�ayaX>
\ No newline at end of file

@@ 1,1 0,0 @@
-�ax��ayaz�>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axay�>
\ No newline at end of file

@@ 1,1 0,0 @@
-�	��axaTax>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axaT�axax�>
\ No newline at end of file

@@ 1,1 0,0 @@
-�	��ayazax>
\ No newline at end of file

@@ 1,1 0,0 @@
-�	ayax>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axay�ayaBazaA>
\ No newline at end of file

@@ 1,1 0,0 @@
-�axay�ayaBazaA>
\ No newline at end of file

@@ 1,1 0,0 @@
-��axaBazaA>
\ No newline at end of file

@@ 1,1 0,0 @@
-��axaBazaA>
\ No newline at end of file

@@ 1,1 0,0 @@
-��>
\ No newline at end of file

@@ 1,1 0,0 @@
-��>
\ No newline at end of file

@@ 1,1 0,0 @@
-��ax��aBaZazaA>
\ No newline at end of file

@@ 1,1 0,0 @@
-��axaBazaA>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,1 0,0 @@
-ax>
\ No newline at end of file

@@ 1,3 0,0 @@
-#!/bin/sh
-
-dhall encode < "$1" > "$1"b

@@ 1,7 0,0 @@
-#!/bin/sh
-
-out="$(echo "$1" | sed -e's/\.dhallb$/.hash/')"
-dhall decode < "$1" | dhall hash > "$out" 2>/dev/null
-if [ $(wc -c < "$out") -eq 0 ]; then
-	rm -f "$out"
-fi

@@ 1,9 0,0 @@
-#!/bin/sh
-
-cp -r "$(git root)"/dhall-lang/tests/normalization/success "$(git root)"/test/normalization/standard
-
-cd "$(git root)"/test/normalization/standard
-find . -name '*.dhall' -exec "$(git root)"/test/normalization/dhall-encode '{}' \;
-
-cd "$(git root)"/test/normalization
-find . -name '*.dhallb' -exec "$(git root)"/test/normalization/dhall-hash '{}' \;

@@ 1,2 0,0 @@
-*.dhall
-*.dhallb

@@ 9,14 9,16 @@ require "dhall/binary"
 
 class TestAsJson < Minitest::Test
 	DIRPATH = Pathname.new(File.dirname(__FILE__))
-	TESTS = DIRPATH + "normalization/"
+	TESTS = DIRPATH + "../dhall-lang/tests/**/success/"
 
 	Pathname.glob(TESTS + "**/*.dhallb").each do |path|
 		test = path.relative_path_from(TESTS).to_s.sub(/.dhallb$/, "")
 		define_method("test_#{test}") do
+			skip "double as_json" if test =~ /doubleB/
+			skip "deprecated syntax" if test =~ /collectionImportTypeB|annotationsB/
 			assert_equal(
-				CBOR.decode(path.read).inspect,
-				Dhall.from_binary(path.read).as_json.inspect
+				CBOR.decode(path.read),
+				Dhall.from_binary(path.read).as_json
 			)
 		end
 	end

@@ 8,7 8,7 @@ require "dhall/binary"
 
 class TestBinary < Minitest::Test
 	DIRPATH = Pathname.new(File.dirname(__FILE__))
-	TESTS = DIRPATH + "normalization/"
+	TESTS = DIRPATH + "../dhall-lang/tests/**/success/"
 
 	Pathname.glob(TESTS + "**/*.dhallb").each do |path|
 		test = path.relative_path_from(TESTS).to_s.sub(/.dhallb$/, "")

@@ 4,26 4,26 @@ require "minitest/autorun"
 require "pathname"
 
 require "dhall/ast"
-require "dhall/binary"
+require "dhall/parser"
 require "dhall/normalize"
 
 class TestNormalization < Minitest::Test
 	DIRPATH = Pathname.new(File.dirname(__FILE__))
-	TESTS = DIRPATH + "normalization/"
+	TESTS = DIRPATH + "../dhall-lang/tests/{α-,}normalization/"
 
-	Pathname.glob(TESTS + "**/*A.dhallb").each do |path|
-		test = path.relative_path_from(TESTS).to_s.sub(/A\.dhallb$/, "")
+	Pathname.glob(TESTS + "success/**/*A.dhall").each do |path|
+		test = path.relative_path_from(TESTS).to_s.sub(/A\.dhall$/, "")
 		next if test =~ /prelude\//
 		next if test =~ /remoteSystems/
 		next if test =~ /multiline\//
 
 		define_method("test_#{test}") do
-			Dhall::Function.disable_alpha_normalization! if test =~ /^standard\//
+			Dhall::Function.disable_alpha_normalization! if test !~ /α/
 			assert_equal(
-				Dhall.from_binary((TESTS + "#{test}B.dhallb").binread),
-				Dhall.from_binary(path.binread).normalize
+				Dhall::Parser.parse_file(TESTS + "#{test}B.dhall").value,
+				Dhall::Parser.parse_file(path).value.normalize
 			)
-			Dhall::Function.enable_alpha_normalization! if test =~ /^standard\//
+			Dhall::Function.enable_alpha_normalization! if test !~ /α/
 		end
 	end
 

@@ 0,0 1,36 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "pathname"
+
+require "dhall/parser"
+require "dhall/binary"
+
+class TestParser < Minitest::Test
+	DIRPATH = Pathname.new(File.dirname(__FILE__))
+	TESTS = DIRPATH + "../dhall-lang/tests/parser/"
+
+	Pathname.glob(TESTS + "success/**/*A.dhall").each do |path|
+		test = path.relative_path_from(TESTS).to_s.sub(/A\.dhall$/, "")
+		define_method("test_#{test}") do
+			skip "very slow" if !ENV["CI"] && test =~ /largeExpression/
+			skip "deprecated syntax" if test =~ /collectionImportType|annotations/
+			match = Dhall::Parser.parse_file(path)
+			assert(match)
+			assert_kind_of(Dhall::Expression, match.value)
+			assert_equal(
+				(TESTS + "#{test}B.dhallb").binread,
+				match.value.to_binary
+			)
+		end
+	end
+
+	Pathname.glob(TESTS + "failure/**/*.dhall").each do |path|
+		test = path.relative_path_from(TESTS).to_s.sub(/A\.dhall$/, "")
+		define_method("test_#{test}") do
+			assert_raises Citrus::ParseError do
+				Dhall::Parser.parse_file(path).value
+			end
+		end
+	end
+end

@@ 39,7 39,7 @@ class TestResolvers < Minitest::Test
 				sources.map { |source| Promise.resolve(source) }
 			end
 		)
-		source = Dhall::Import::Http.new(nil, "example.com", "x.dhall", nil, nil)
+		source = Dhall::Import::Http.new(nil, "example.com", "x.dhall", nil)
 		promise = source.resolve(resolver)
 		resolver.finish!
 		assert_equal source, promise.sync


@@ 51,7 51,7 @@ class TestResolvers < Minitest::Test
 				sources.map { |source| Promise.resolve(source) }
 			end
 		)
-		source = Dhall::Import::Https.new(nil, "example.com", "x.dhall", nil, nil)
+		source = Dhall::Import::Https.new(nil, "example.com", "x.dhall", nil)
 		promise = source.resolve(resolver)
 		resolver.finish!
 		assert_equal source, promise.sync


@@ 63,7 63,7 @@ class TestResolvers < Minitest::Test
 				sources.map { |source| Promise.resolve(source) }
 			end
 		)
-		source = Dhall::Import::Https.new(nil, "example.com", "x.dhall", nil, nil)
+		source = Dhall::Import::Https.new(nil, "example.com", "x.dhall", nil)
 		promise = source.resolve(resolver)
 		resolver.finish!
 		assert_equal source, promise.sync


@@ 71,7 71,7 @@ class TestResolvers < Minitest::Test
 
 	def test_local_only_resolver_rejects_http
 		resolver = Dhall::Resolvers::LocalOnly.new
-		source = Dhall::Import::Http.new(nil, "example.com", "x.dhall", nil, nil)
+		source = Dhall::Import::Http.new(nil, "example.com", "x.dhall", nil)
 		promise = source.resolve(resolver)
 		resolver.finish!
 		assert_raises Dhall::ImportBannedException do

@@ 4,5 4,6 @@ require "pathname"
 
 DIRPATH = Pathname.new(File.dirname(__FILE__))
 Pathname.glob(DIRPATH + "test_*.rb").each do |path|
+	next if path.basename.to_s == "test_suite.rb"
 	require_relative path.basename
 end