~singpolyma/dhall-ruby

c979c0c40060439b06d039a133a38d2c564123b7 — Stephen Paul Weber 3 years ago 71947f5
Working parser
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
M .builds.dhall/debian-stable.dhall => .builds.dhall/debian-stable.dhall +1 -5
@@ 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
			''
		}
	]

M .builds/debian-stable.yml => .builds/debian-stable.yml +1 -5
@@ 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

A .gitignore => .gitignore +4 -0
@@ 0,0 1,4 @@
lib/dhall/parser.citrus
Gemfile.lock
.bundle/*
.gems/*

M Gemfile => Gemfile +2 -0
@@ 2,7 2,9 @@

source "https://rubygems.org"

gem "abnf"
gem "cbor"
gem "citrus"
gem "promise.rb"
gem "value_semantics"
gem "webmock"

A Makefile => Makefile +7 -0
@@ 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

M dhall-lang => dhall-lang +1 -1
@@ 1,1 1,1 @@
Subproject commit c21b3f5c8b19997816b6ceae87709db3c5afb150
Subproject commit 30841349fd02fd4eb965cba23a8dc557e99fbd15

M lib/dhall.rb => lib/dhall.rb +1 -0
@@ 2,6 2,7 @@

require "dhall/ast"
require "dhall/builtins"
require "dhall/parser"
require "dhall/binary"
require "dhall/normalize"
require "dhall/resolve"

M lib/dhall/ast.rb => lib/dhall/ast.rb +131 -70
@@ 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)


M lib/dhall/binary.rb => lib/dhall/binary.rb +26 -17
@@ 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


M lib/dhall/normalize.rb => lib/dhall/normalize.rb +13 -16
@@ 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

A lib/dhall/parser.rb => lib/dhall/parser.rb +530 -0
@@ 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"

M lib/dhall/util.rb => lib/dhall/util.rb +52 -0
@@ 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]

A scripts/generate_citrus_parser.rb => scripts/generate_citrus_parser.rb +166 -0
@@ 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"

D test/normalization/alpha/FunctionBindingUnderscoreA.dhallb => test/normalization/alpha/FunctionBindingUnderscoreA.dhallb +0 -1
@@ 1,1 0,0 @@
�aAab
\ No newline at end of file

D test/normalization/alpha/FunctionBindingUnderscoreB.dhallb => test/normalization/alpha/FunctionBindingUnderscoreB.dhallb +0 -1
@@ 1,1 0,0 @@
�aAab
\ No newline at end of file

D test/normalization/alpha/FunctionBindingXA.dhallb => test/normalization/alpha/FunctionBindingXA.dhallb +0 -1
@@ 1,1 0,0 @@
�axaAax
\ No newline at end of file

D test/normalization/alpha/FunctionBindingXB.dhallb => test/normalization/alpha/FunctionBindingXB.dhallb +0 -0
D test/normalization/alpha/FunctionNestedBindingXA.dhallb => test/normalization/alpha/FunctionNestedBindingXA.dhallb +0 -1
@@ 1,1 0,0 @@
�axaA�aBax
\ No newline at end of file

D test/normalization/alpha/FunctionNestedBindingXB.dhallb => test/normalization/alpha/FunctionNestedBindingXB.dhallb +0 -1
@@ 1,1 0,0 @@
�aA�aB
\ No newline at end of file

D test/normalization/alpha/FunctionTypeBindingUnderscoreA.dhallb => test/normalization/alpha/FunctionTypeBindingUnderscoreA.dhallb +0 -1
@@ 1,1 0,0 @@
�aAaB
\ No newline at end of file

D test/normalization/alpha/FunctionTypeBindingUnderscoreB.dhallb => test/normalization/alpha/FunctionTypeBindingUnderscoreB.dhallb +0 -1
@@ 1,1 0,0 @@
�aAaB
\ No newline at end of file

D test/normalization/alpha/FunctionTypeBindingXA.dhallb => test/normalization/alpha/FunctionTypeBindingXA.dhallb +0 -1
@@ 1,1 0,0 @@
�axaAax
\ No newline at end of file

D test/normalization/alpha/FunctionTypeBindingXB.dhallb => test/normalization/alpha/FunctionTypeBindingXB.dhallb +0 -0
D test/normalization/alpha/FunctionTypeNestedBindingXA.dhallb => test/normalization/alpha/FunctionTypeNestedBindingXA.dhallb +0 -1
@@ 1,1 0,0 @@
�axaA�aBax
\ No newline at end of file

D test/normalization/alpha/FunctionTypeNestedBindingXB.dhallb => test/normalization/alpha/FunctionTypeNestedBindingXB.dhallb +0 -1
@@ 1,1 0,0 @@
�aA�aB
\ No newline at end of file

D test/normalization/beta/BoolA.dhallb => test/normalization/beta/BoolA.dhallb +0 -1
@@ 1,1 0,0 @@
dBool
\ No newline at end of file

D test/normalization/beta/BoolB.dhallb => test/normalization/beta/BoolB.dhallb +0 -1
@@ 1,1 0,0 @@
dBool
\ No newline at end of file

D test/normalization/beta/DoubleA.dhallb => test/normalization/beta/DoubleA.dhallb +0 -1
@@ 1,1 0,0 @@
fDouble
\ No newline at end of file

D test/normalization/beta/DoubleB.dhallb => test/normalization/beta/DoubleB.dhallb +0 -1
@@ 1,1 0,0 @@
fDouble
\ No newline at end of file

D test/normalization/beta/DoubleLiteralA.dhallb => test/normalization/beta/DoubleLiteralA.dhallb +0 -1
@@ 1,1 0,0 @@
�?�333333
\ No newline at end of file

D test/normalization/beta/DoubleLiteralB.dhallb => test/normalization/beta/DoubleLiteralB.dhallb +0 -1
@@ 1,1 0,0 @@
�?�333333
\ No newline at end of file

D test/normalization/beta/DoubleShowA.dhallb => test/normalization/beta/DoubleShowA.dhallb +0 -1
@@ 1,1 0,0 @@
kDouble/show
\ No newline at end of file

D test/normalization/beta/DoubleShowB.dhallb => test/normalization/beta/DoubleShowB.dhallb +0 -1
@@ 1,1 0,0 @@
kDouble/show
\ No newline at end of file

D test/normalization/beta/DoubleShowValueA.dhallb => test/normalization/beta/DoubleShowValueA.dhallb +0 -0
D test/normalization/beta/DoubleShowValueB.dhallb => test/normalization/beta/DoubleShowValueB.dhallb +0 -1
@@ 1,1 0,0 @@
�c1.2
\ No newline at end of file

D test/normalization/beta/FunctionApplicationCaptureA.dhallb => test/normalization/beta/FunctionApplicationCaptureA.dhallb +0 -0
D test/normalization/beta/FunctionApplicationCaptureB.dhallb => test/normalization/beta/FunctionApplicationCaptureB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/FunctionApplicationNoSubstituteA.dhallb => test/normalization/beta/FunctionApplicationNoSubstituteA.dhallb +0 -0
D test/normalization/beta/FunctionApplicationNoSubstituteB.dhallb => test/normalization/beta/FunctionApplicationNoSubstituteB.dhallb +0 -1
@@ 1,1 0,0 @@
ay
\ No newline at end of file

D test/normalization/beta/FunctionApplicationNormalizeArgumentsA.dhallb => test/normalization/beta/FunctionApplicationNormalizeArgumentsA.dhallb +0 -0
D test/normalization/beta/FunctionApplicationNormalizeArgumentsB.dhallb => test/normalization/beta/FunctionApplicationNormalizeArgumentsB.dhallb +0 -0
D test/normalization/beta/FunctionApplicationSubstituteA.dhallb => test/normalization/beta/FunctionApplicationSubstituteA.dhallb +0 -0
D test/normalization/beta/FunctionApplicationSubstituteB.dhallb => test/normalization/beta/FunctionApplicationSubstituteB.dhallb +0 -1
@@ 1,1 0,0 @@
ay
\ No newline at end of file

D test/normalization/beta/FunctionNormalizeArgumentsA.dhallb => test/normalization/beta/FunctionNormalizeArgumentsA.dhallb +0 -0
D test/normalization/beta/FunctionNormalizeArgumentsB.dhallb => test/normalization/beta/FunctionNormalizeArgumentsB.dhallb +0 -0
D test/normalization/beta/FunctionTypeNormalizeArgumentsA.dhallb => test/normalization/beta/FunctionTypeNormalizeArgumentsA.dhallb +0 -1
@@ 1,1 0,0 @@
���aXaY��aAaB
\ No newline at end of file

D test/normalization/beta/FunctionTypeNormalizeArgumentsB.dhallb => test/normalization/beta/FunctionTypeNormalizeArgumentsB.dhallb +0 -1
@@ 1,1 0,0 @@
�aXaA
\ No newline at end of file

D test/normalization/beta/IfAlternativesIdenticalA.dhallb => test/normalization/beta/IfAlternativesIdenticalA.dhallb +0 -1
@@ 1,1 0,0 @@
�axayay
\ No newline at end of file

D test/normalization/beta/IfAlternativesIdenticalB.dhallb => test/normalization/beta/IfAlternativesIdenticalB.dhallb +0 -1
@@ 1,1 0,0 @@
ay
\ No newline at end of file

D test/normalization/beta/IfFalseA.dhallb => test/normalization/beta/IfFalseA.dhallb +0 -1
@@ 1,1 0,0 @@
���
\ No newline at end of file

D test/normalization/beta/IfFalseB.dhallb => test/normalization/beta/IfFalseB.dhallb +0 -1
@@ 1,1 0,0 @@

\ No newline at end of file

D test/normalization/beta/IfNormalizePredicateAndBranchesA.dhallb => test/normalization/beta/IfNormalizePredicateAndBranchesA.dhallb +0 -1
@@ 1,1 0,0 @@
���axay��aaab��acad
\ No newline at end of file

D test/normalization/beta/IfNormalizePredicateAndBranchesB.dhallb => test/normalization/beta/IfNormalizePredicateAndBranchesB.dhallb +0 -1
@@ 1,1 0,0 @@
�axaaac
\ No newline at end of file

D test/normalization/beta/IfTrivialA.dhallb => test/normalization/beta/IfTrivialA.dhallb +0 -1
@@ 1,1 0,0 @@
�ax��
\ No newline at end of file

D test/normalization/beta/IfTrivialB.dhallb => test/normalization/beta/IfTrivialB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/IfTrueA.dhallb => test/normalization/beta/IfTrueA.dhallb +0 -1
@@ 1,1 0,0 @@
����
\ No newline at end of file

D test/normalization/beta/IfTrueB.dhallb => test/normalization/beta/IfTrueB.dhallb +0 -1
@@ 1,1 0,0 @@

\ No newline at end of file

D test/normalization/beta/IntegerA.dhallb => test/normalization/beta/IntegerA.dhallb +0 -1
@@ 1,1 0,0 @@
gInteger
\ No newline at end of file

D test/normalization/beta/IntegerB.dhallb => test/normalization/beta/IntegerB.dhallb +0 -1
@@ 1,1 0,0 @@
gInteger
\ No newline at end of file

D test/normalization/beta/IntegerNegativeA.dhallb => test/normalization/beta/IntegerNegativeA.dhallb +0 -1
@@ 1,1 0,0 @@

\ No newline at end of file

D test/normalization/beta/IntegerNegativeB.dhallb => test/normalization/beta/IntegerNegativeB.dhallb +0 -1
@@ 1,1 0,0 @@

\ No newline at end of file

D test/normalization/beta/IntegerPositiveA.dhallb => test/normalization/beta/IntegerPositiveA.dhallb +0 -1
@@ 1,1 0,0 @@

\ No newline at end of file

D test/normalization/beta/IntegerPositiveB.dhallb => test/normalization/beta/IntegerPositiveB.dhallb +0 -1
@@ 1,1 0,0 @@

\ No newline at end of file

D test/normalization/beta/IntegerShow-12A.dhallb => test/normalization/beta/IntegerShow-12A.dhallb +0 -0
D test/normalization/beta/IntegerShow-12B.dhallb => test/normalization/beta/IntegerShow-12B.dhallb +0 -1
@@ 1,1 0,0 @@
�c-12
\ No newline at end of file

D test/normalization/beta/IntegerShow12A.dhallb => test/normalization/beta/IntegerShow12A.dhallb +0 -0
D test/normalization/beta/IntegerShow12B.dhallb => test/normalization/beta/IntegerShow12B.dhallb +0 -1
@@ 1,1 0,0 @@
�c+12
\ No newline at end of file

D test/normalization/beta/IntegerShowA.dhallb => test/normalization/beta/IntegerShowA.dhallb +0 -1
@@ 1,1 0,0 @@
lInteger/show
\ No newline at end of file

D test/normalization/beta/IntegerShowB.dhallb => test/normalization/beta/IntegerShowB.dhallb +0 -1
@@ 1,1 0,0 @@
lInteger/show
\ No newline at end of file

D test/normalization/beta/IntegerToDouble-12A.dhallb => test/normalization/beta/IntegerToDouble-12A.dhallb +0 -0
D test/normalization/beta/IntegerToDouble-12B.dhallb => test/normalization/beta/IntegerToDouble-12B.dhallb +0 -0
D test/normalization/beta/IntegerToDouble12A.dhallb => test/normalization/beta/IntegerToDouble12A.dhallb +0 -0
D test/normalization/beta/IntegerToDouble12B.dhallb => test/normalization/beta/IntegerToDouble12B.dhallb +0 -0
D test/normalization/beta/IntegerToDoubleA.dhallb => test/normalization/beta/IntegerToDoubleA.dhallb +0 -1
@@ 1,1 0,0 @@
pInteger/toDouble
\ No newline at end of file

D test/normalization/beta/IntegerToDoubleB.dhallb => test/normalization/beta/IntegerToDoubleB.dhallb +0 -1
@@ 1,1 0,0 @@
pInteger/toDouble
\ No newline at end of file

D test/normalization/beta/KindA.dhallb => test/normalization/beta/KindA.dhallb +0 -1
@@ 1,1 0,0 @@
dKind
\ No newline at end of file

D test/normalization/beta/KindB.dhallb => test/normalization/beta/KindB.dhallb +0 -1
@@ 1,1 0,0 @@
dKind
\ No newline at end of file

D test/normalization/beta/LetA.dhallb => test/normalization/beta/LetA.dhallb +0 -1
@@ 1,1 0,0 @@
�ax�ayax
\ No newline at end of file

D test/normalization/beta/LetB.dhallb => test/normalization/beta/LetB.dhallb +0 -1
@@ 1,1 0,0 @@
ay
\ No newline at end of file

D test/normalization/beta/LetWithTypeA.dhallb => test/normalization/beta/LetWithTypeA.dhallb +0 -1
@@ 1,1 0,0 @@
�axaAayax
\ No newline at end of file

D test/normalization/beta/LetWithTypeB.dhallb => test/normalization/beta/LetWithTypeB.dhallb +0 -1
@@ 1,1 0,0 @@
ay
\ No newline at end of file

D test/normalization/beta/ListA.dhallb => test/normalization/beta/ListA.dhallb +0 -1
@@ 1,1 0,0 @@
dList
\ No newline at end of file

D test/normalization/beta/ListB.dhallb => test/normalization/beta/ListB.dhallb +0 -1
@@ 1,1 0,0 @@
dList
\ No newline at end of file

D test/normalization/beta/ListBuildA.dhallb => test/normalization/beta/ListBuildA.dhallb +0 -1
@@ 1,1 0,0 @@
jList/build
\ No newline at end of file

D test/normalization/beta/ListBuildB.dhallb => test/normalization/beta/ListBuildB.dhallb +0 -1
@@ 1,1 0,0 @@
jList/build
\ No newline at end of file

D test/normalization/beta/ListBuildFoldFusionA.dhallb => test/normalization/beta/ListBuildFoldFusionA.dhallb +0 -0
D test/normalization/beta/ListBuildFoldFusionB.dhallb => test/normalization/beta/ListBuildFoldFusionB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/ListBuildImplementationA.dhallb => test/normalization/beta/ListBuildImplementationA.dhallb +0 -0
D test/normalization/beta/ListBuildImplementationB.dhallb => test/normalization/beta/ListBuildImplementationB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/ListFoldA.dhallb => test/normalization/beta/ListFoldA.dhallb +0 -1
@@ 1,1 0,0 @@
iList/fold
\ No newline at end of file

D test/normalization/beta/ListFoldB.dhallb => test/normalization/beta/ListFoldB.dhallb +0 -1
@@ 1,1 0,0 @@
iList/fold
\ No newline at end of file

D test/normalization/beta/ListFoldEmptyA.dhallb => test/normalization/beta/ListFoldEmptyA.dhallb +0 -0
D test/normalization/beta/ListFoldEmptyB.dhallb => test/normalization/beta/ListFoldEmptyB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/ListFoldOneA.dhallb => test/normalization/beta/ListFoldOneA.dhallb +0 -0
D test/normalization/beta/ListFoldOneB.dhallb => test/normalization/beta/ListFoldOneB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/ListHeadA.dhallb => test/normalization/beta/ListHeadA.dhallb +0 -1
@@ 1,1 0,0 @@
iList/head
\ No newline at end of file

D test/normalization/beta/ListHeadB.dhallb => test/normalization/beta/ListHeadB.dhallb +0 -1
@@ 1,1 0,0 @@
iList/head
\ No newline at end of file

D test/normalization/beta/ListHeadEmptyA.dhallb => test/normalization/beta/ListHeadEmptyA.dhallb +0 -0
D test/normalization/beta/ListHeadEmptyB.dhallb => test/normalization/beta/ListHeadEmptyB.dhallb +0 -1
@@ 1,1 0,0 @@
�aT
\ No newline at end of file

D test/normalization/beta/ListHeadOneA.dhallb => test/normalization/beta/ListHeadOneA.dhallb +0 -0
D test/normalization/beta/ListHeadOneB.dhallb => test/normalization/beta/ListHeadOneB.dhallb +0 -1
@@ 1,1 0,0 @@
���
\ No newline at end of file

D test/normalization/beta/ListIndexedA.dhallb => test/normalization/beta/ListIndexedA.dhallb +0 -1
@@ 1,1 0,0 @@
lList/indexed
\ No newline at end of file

D test/normalization/beta/ListIndexedB.dhallb => test/normalization/beta/ListIndexedB.dhallb +0 -1
@@ 1,1 0,0 @@
lList/indexed
\ No newline at end of file

D test/normalization/beta/ListIndexedEmptyA.dhallb => test/normalization/beta/ListIndexedEmptyA.dhallb +0 -0
D test/normalization/beta/ListIndexedEmptyB.dhallb => test/normalization/beta/ListIndexedEmptyB.dhallb +0 -1
@@ 1,1 0,0 @@
���eindexgNaturalevalueaT
\ No newline at end of file

D test/normalization/beta/ListIndexedOneA.dhallb => test/normalization/beta/ListIndexedOneA.dhallb +0 -0
D test/normalization/beta/ListIndexedOneB.dhallb => test/normalization/beta/ListIndexedOneB.dhallb +0 -0
D test/normalization/beta/ListLastA.dhallb => test/normalization/beta/ListLastA.dhallb +0 -1
@@ 1,1 0,0 @@
iList/last
\ No newline at end of file

D test/normalization/beta/ListLastB.dhallb => test/normalization/beta/ListLastB.dhallb +0 -1
@@ 1,1 0,0 @@
iList/last
\ No newline at end of file

D test/normalization/beta/ListLastEmptyA.dhallb => test/normalization/beta/ListLastEmptyA.dhallb +0 -0
D test/normalization/beta/ListLastEmptyB.dhallb => test/normalization/beta/ListLastEmptyB.dhallb +0 -1
@@ 1,1 0,0 @@
�aT
\ No newline at end of file

D test/normalization/beta/ListLastOneA.dhallb => test/normalization/beta/ListLastOneA.dhallb +0 -0
D test/normalization/beta/ListLastOneB.dhallb => test/normalization/beta/ListLastOneB.dhallb +0 -1
@@ 1,1 0,0 @@
���
\ No newline at end of file

D test/normalization/beta/ListLengthA.dhallb => test/normalization/beta/ListLengthA.dhallb +0 -1
@@ 1,1 0,0 @@
kList/length
\ No newline at end of file

D test/normalization/beta/ListLengthB.dhallb => test/normalization/beta/ListLengthB.dhallb +0 -1
@@ 1,1 0,0 @@
kList/length
\ No newline at end of file

D test/normalization/beta/ListLengthEmptyA.dhallb => test/normalization/beta/ListLengthEmptyA.dhallb +0 -0
D test/normalization/beta/ListLengthEmptyB.dhallb => test/normalization/beta/ListLengthEmptyB.dhallb +0 -0
D test/normalization/beta/ListLengthOneA.dhallb => test/normalization/beta/ListLengthOneA.dhallb +0 -0
D test/normalization/beta/ListLengthOneB.dhallb => test/normalization/beta/ListLengthOneB.dhallb +0 -1
@@ 1,1 0,0 @@

\ No newline at end of file

D test/normalization/beta/ListNormalizeElementsA.dhallb => test/normalization/beta/ListNormalizeElementsA.dhallb +0 -1
@@ 1,1 0,0 @@
����axay
\ No newline at end of file

D test/normalization/beta/ListNormalizeElementsB.dhallb => test/normalization/beta/ListNormalizeElementsB.dhallb +0 -1
@@ 1,1 0,0 @@
��ax
\ No newline at end of file

D test/normalization/beta/ListNormalizeTypeAnnotationA.dhallb => test/normalization/beta/ListNormalizeTypeAnnotationA.dhallb +0 -1
@@ 1,1 0,0 @@
���axay
\ No newline at end of file

D test/normalization/beta/ListNormalizeTypeAnnotationB.dhallb => test/normalization/beta/ListNormalizeTypeAnnotationB.dhallb +0 -1
@@ 1,1 0,0 @@
�ax
\ No newline at end of file

D test/normalization/beta/ListReverseA.dhallb => test/normalization/beta/ListReverseA.dhallb +0 -1
@@ 1,1 0,0 @@
lList/reverse
\ No newline at end of file

D test/normalization/beta/ListReverseB.dhallb => test/normalization/beta/ListReverseB.dhallb +0 -1
@@ 1,1 0,0 @@
lList/reverse
\ No newline at end of file

D test/normalization/beta/ListReverseEmptyA.dhallb => test/normalization/beta/ListReverseEmptyA.dhallb +0 -0
D test/normalization/beta/ListReverseEmptyB.dhallb => test/normalization/beta/ListReverseEmptyB.dhallb +0 -1
@@ 1,1 0,0 @@
�aT
\ No newline at end of file

D test/normalization/beta/ListReverseTwoA.dhallb => test/normalization/beta/ListReverseTwoA.dhallb +0 -0
D test/normalization/beta/ListReverseTwoB.dhallb => test/normalization/beta/ListReverseTwoB.dhallb +0 -1
@@ 1,1 0,0 @@
����
\ No newline at end of file

D test/normalization/beta/MergeA.dhallb => test/normalization/beta/MergeA.dhallb +0 -0
D test/normalization/beta/MergeB.dhallb => test/normalization/beta/MergeB.dhallb +0 -1
@@ 1,1 0,0 @@
ay
\ No newline at end of file

D test/normalization/beta/MergeNormalizeArgumentsA.dhallb => test/normalization/beta/MergeNormalizeArgumentsA.dhallb +0 -1
@@ 1,1 0,0 @@
���axay��azab
\ No newline at end of file

D test/normalization/beta/MergeNormalizeArgumentsB.dhallb => test/normalization/beta/MergeNormalizeArgumentsB.dhallb +0 -1
@@ 1,1 0,0 @@
�axaz
\ No newline at end of file

D test/normalization/beta/MergeWithTypeA.dhallb => test/normalization/beta/MergeWithTypeA.dhallb +0 -0
D test/normalization/beta/MergeWithTypeB.dhallb => test/normalization/beta/MergeWithTypeB.dhallb +0 -1
@@ 1,1 0,0 @@
ay
\ No newline at end of file

D test/normalization/beta/MergeWithTypeNormalizeArgumentsA.dhallb => test/normalization/beta/MergeWithTypeNormalizeArgumentsA.dhallb +0 -1
@@ 1,1 0,0 @@
���axay��azab��aXaY
\ No newline at end of file

D test/normalization/beta/MergeWithTypeNormalizeArgumentsB.dhallb => test/normalization/beta/MergeWithTypeNormalizeArgumentsB.dhallb +0 -1
@@ 1,1 0,0 @@
�axazaX
\ No newline at end of file

D test/normalization/beta/NaturalA.dhallb => test/normalization/beta/NaturalA.dhallb +0 -1
@@ 1,1 0,0 @@
gNatural
\ No newline at end of file

D test/normalization/beta/NaturalB.dhallb => test/normalization/beta/NaturalB.dhallb +0 -1
@@ 1,1 0,0 @@
gNatural
\ No newline at end of file

D test/normalization/beta/NaturalBuildA.dhallb => test/normalization/beta/NaturalBuildA.dhallb +0 -1
@@ 1,1 0,0 @@
mNatural/build
\ No newline at end of file

D test/normalization/beta/NaturalBuildB.dhallb => test/normalization/beta/NaturalBuildB.dhallb +0 -1
@@ 1,1 0,0 @@
mNatural/build
\ No newline at end of file

D test/normalization/beta/NaturalBuildFoldFusionA.dhallb => test/normalization/beta/NaturalBuildFoldFusionA.dhallb +0 -0
D test/normalization/beta/NaturalBuildFoldFusionB.dhallb => test/normalization/beta/NaturalBuildFoldFusionB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/NaturalBuildImplementationA.dhallb => test/normalization/beta/NaturalBuildImplementationA.dhallb +0 -0
D test/normalization/beta/NaturalBuildImplementationB.dhallb => test/normalization/beta/NaturalBuildImplementationB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/NaturalEvenA.dhallb => test/normalization/beta/NaturalEvenA.dhallb +0 -1
@@ 1,1 0,0 @@
lNatural/even
\ No newline at end of file

D test/normalization/beta/NaturalEvenB.dhallb => test/normalization/beta/NaturalEvenB.dhallb +0 -1
@@ 1,1 0,0 @@
lNatural/even
\ No newline at end of file

D test/normalization/beta/NaturalEvenOneA.dhallb => test/normalization/beta/NaturalEvenOneA.dhallb +0 -0
D test/normalization/beta/NaturalEvenOneB.dhallb => test/normalization/beta/NaturalEvenOneB.dhallb +0 -1
@@ 1,1 0,0 @@

\ No newline at end of file

D test/normalization/beta/NaturalEvenZeroA.dhallb => test/normalization/beta/NaturalEvenZeroA.dhallb +0 -0
D test/normalization/beta/NaturalEvenZeroB.dhallb => test/normalization/beta/NaturalEvenZeroB.dhallb +0 -1
@@ 1,1 0,0 @@

\ No newline at end of file

D test/normalization/beta/NaturalFoldA.dhallb => test/normalization/beta/NaturalFoldA.dhallb +0 -1
@@ 1,1 0,0 @@
lNatural/fold
\ No newline at end of file

D test/normalization/beta/NaturalFoldB.dhallb => test/normalization/beta/NaturalFoldB.dhallb +0 -1
@@ 1,1 0,0 @@
lNatural/fold
\ No newline at end of file

D test/normalization/beta/NaturalFoldOneA.dhallb => test/normalization/beta/NaturalFoldOneA.dhallb +0 -0
D test/normalization/beta/NaturalFoldOneB.dhallb => test/normalization/beta/NaturalFoldOneB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/NaturalFoldZeroA.dhallb => test/normalization/beta/NaturalFoldZeroA.dhallb +0 -0
D test/normalization/beta/NaturalFoldZeroB.dhallb => test/normalization/beta/NaturalFoldZeroB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/NaturalIsZeroA.dhallb => test/normalization/beta/NaturalIsZeroA.dhallb +0 -1
@@ 1,1 0,0 @@
nNatural/isZero
\ No newline at end of file

D test/normalization/beta/NaturalIsZeroB.dhallb => test/normalization/beta/NaturalIsZeroB.dhallb +0 -1
@@ 1,1 0,0 @@
nNatural/isZero
\ No newline at end of file

D test/normalization/beta/NaturalIsZeroOneA.dhallb => test/normalization/beta/NaturalIsZeroOneA.dhallb +0 -0
D test/normalization/beta/NaturalIsZeroOneB.dhallb => test/normalization/beta/NaturalIsZeroOneB.dhallb +0 -1
@@ 1,1 0,0 @@

\ No newline at end of file

D test/normalization/beta/NaturalIsZeroZeroA.dhallb => test/normalization/beta/NaturalIsZeroZeroA.dhallb +0 -0
D test/normalization/beta/NaturalIsZeroZeroB.dhallb => test/normalization/beta/NaturalIsZeroZeroB.dhallb +0 -1
@@ 1,1 0,0 @@

\ No newline at end of file

D test/normalization/beta/NaturalLiteralA.dhallb => test/normalization/beta/NaturalLiteralA.dhallb +0 -1
@@ 1,1 0,0 @@

\ No newline at end of file

D test/normalization/beta/NaturalLiteralB.dhallb => test/normalization/beta/NaturalLiteralB.dhallb +0 -1
@@ 1,1 0,0 @@

\ No newline at end of file

D test/normalization/beta/NaturalOddA.dhallb => test/normalization/beta/NaturalOddA.dhallb +0 -1
@@ 1,1 0,0 @@
kNatural/odd
\ No newline at end of file

D test/normalization/beta/NaturalOddB.dhallb => test/normalization/beta/NaturalOddB.dhallb +0 -1
@@ 1,1 0,0 @@
kNatural/odd
\ No newline at end of file

D test/normalization/beta/NaturalOddOneA.dhallb => test/normalization/beta/NaturalOddOneA.dhallb +0 -0
D test/normalization/beta/NaturalOddOneB.dhallb => test/normalization/beta/NaturalOddOneB.dhallb +0 -1
@@ 1,1 0,0 @@

\ No newline at end of file

D test/normalization/beta/NaturalOddZeroA.dhallb => test/normalization/beta/NaturalOddZeroA.dhallb +0 -0
D test/normalization/beta/NaturalOddZeroB.dhallb => test/normalization/beta/NaturalOddZeroB.dhallb +0 -1
@@ 1,1 0,0 @@

\ No newline at end of file

D test/normalization/beta/NaturalShowA.dhallb => test/normalization/beta/NaturalShowA.dhallb +0 -1
@@ 1,1 0,0 @@
lNatural/show
\ No newline at end of file

D test/normalization/beta/NaturalShowB.dhallb => test/normalization/beta/NaturalShowB.dhallb +0 -1
@@ 1,1 0,0 @@
lNatural/show
\ No newline at end of file

D test/normalization/beta/NaturalShowOneA.dhallb => test/normalization/beta/NaturalShowOneA.dhallb +0 -0
D test/normalization/beta/NaturalShowOneB.dhallb => test/normalization/beta/NaturalShowOneB.dhallb +0 -1
@@ 1,1 0,0 @@
�a1
\ No newline at end of file

D test/normalization/beta/NaturalToIntegerA.dhallb => test/normalization/beta/NaturalToIntegerA.dhallb +0 -1
@@ 1,1 0,0 @@
qNatural/toInteger
\ No newline at end of file

D test/normalization/beta/NaturalToIntegerB.dhallb => test/normalization/beta/NaturalToIntegerB.dhallb +0 -1
@@ 1,1 0,0 @@
qNatural/toInteger
\ No newline at end of file

D test/normalization/beta/NaturalToIntegerOneA.dhallb => test/normalization/beta/NaturalToIntegerOneA.dhallb +0 -0
D test/normalization/beta/NaturalToIntegerOneB.dhallb => test/normalization/beta/NaturalToIntegerOneB.dhallb +0 -1
@@ 1,1 0,0 @@

\ No newline at end of file

D test/normalization/beta/NoneA.dhallb => test/normalization/beta/NoneA.dhallb +0 -1
@@ 1,1 0,0 @@
dNone
\ No newline at end of file

D test/normalization/beta/NoneB.dhallb => test/normalization/beta/NoneB.dhallb +0 -1
@@ 1,1 0,0 @@
dNone
\ No newline at end of file

D test/normalization/beta/NoneNaturalA.dhallb => test/normalization/beta/NoneNaturalA.dhallb +0 -1
@@ 1,1 0,0 @@
�gNatural
\ No newline at end of file

D test/normalization/beta/NoneNaturalB.dhallb => test/normalization/beta/NoneNaturalB.dhallb +0 -1
@@ 1,1 0,0 @@
�gNatural
\ No newline at end of file

D test/normalization/beta/OperatorAndEquivalentArgumentsA.dhallb => test/normalization/beta/OperatorAndEquivalentArgumentsA.dhallb +0 -1
@@ 1,1 0,0 @@
�axax
\ No newline at end of file

D test/normalization/beta/OperatorAndEquivalentArgumentsB.dhallb => test/normalization/beta/OperatorAndEquivalentArgumentsB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/OperatorAndLhsFalseA.dhallb => test/normalization/beta/OperatorAndLhsFalseA.dhallb +0 -1
@@ 1,1 0,0 @@
��ax
\ No newline at end of file

D test/normalization/beta/OperatorAndLhsFalseB.dhallb => test/normalization/beta/OperatorAndLhsFalseB.dhallb +0 -1
@@ 1,1 0,0 @@

\ No newline at end of file

D test/normalization/beta/OperatorAndLhsTrueA.dhallb => test/normalization/beta/OperatorAndLhsTrueA.dhallb +0 -1
@@ 1,1 0,0 @@
��ax
\ No newline at end of file

D test/normalization/beta/OperatorAndLhsTrueB.dhallb => test/normalization/beta/OperatorAndLhsTrueB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/OperatorAndNormalizeArgumentsA.dhallb => test/normalization/beta/OperatorAndNormalizeArgumentsA.dhallb +0 -1
@@ 1,1 0,0 @@
���ax��ay
\ No newline at end of file

D test/normalization/beta/OperatorAndNormalizeArgumentsB.dhallb => test/normalization/beta/OperatorAndNormalizeArgumentsB.dhallb +0 -1
@@ 1,1 0,0 @@
�axay
\ No newline at end of file

D test/normalization/beta/OperatorAndRhsFalseA.dhallb => test/normalization/beta/OperatorAndRhsFalseA.dhallb +0 -1
@@ 1,1 0,0 @@
�ax�
\ No newline at end of file

D test/normalization/beta/OperatorAndRhsFalseB.dhallb => test/normalization/beta/OperatorAndRhsFalseB.dhallb +0 -1
@@ 1,1 0,0 @@

\ No newline at end of file

D test/normalization/beta/OperatorAndRhsTrueA.dhallb => test/normalization/beta/OperatorAndRhsTrueA.dhallb +0 -1
@@ 1,1 0,0 @@
�ax�
\ No newline at end of file

D test/normalization/beta/OperatorAndRhsTrueB.dhallb => test/normalization/beta/OperatorAndRhsTrueB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/OperatorEqualEquivalentArgumentsA.dhallb => test/normalization/beta/OperatorEqualEquivalentArgumentsA.dhallb +0 -1
@@ 1,1 0,0 @@
�axax
\ No newline at end of file

D test/normalization/beta/OperatorEqualEquivalentArgumentsB.dhallb => test/normalization/beta/OperatorEqualEquivalentArgumentsB.dhallb +0 -1
@@ 1,1 0,0 @@

\ No newline at end of file

D test/normalization/beta/OperatorEqualLhsTrueA.dhallb => test/normalization/beta/OperatorEqualLhsTrueA.dhallb +0 -1
@@ 1,1 0,0 @@
�ax�
\ No newline at end of file

D test/normalization/beta/OperatorEqualLhsTrueB.dhallb => test/normalization/beta/OperatorEqualLhsTrueB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/OperatorEqualNormalizeArgumentsA.dhallb => test/normalization/beta/OperatorEqualNormalizeArgumentsA.dhallb +0 -1
@@ 1,1 0,0 @@
���ax��ay
\ No newline at end of file

D test/normalization/beta/OperatorEqualNormalizeArgumentsB.dhallb => test/normalization/beta/OperatorEqualNormalizeArgumentsB.dhallb +0 -1
@@ 1,1 0,0 @@
�axay
\ No newline at end of file

D test/normalization/beta/OperatorEqualRhsTrueA.dhallb => test/normalization/beta/OperatorEqualRhsTrueA.dhallb +0 -1
@@ 1,1 0,0 @@
��ax
\ No newline at end of file

D test/normalization/beta/OperatorEqualRhsTrueB.dhallb => test/normalization/beta/OperatorEqualRhsTrueB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/OperatorListConcatenateLhsEmptyA.dhallb => test/normalization/beta/OperatorListConcatenateLhsEmptyA.dhallb +0 -1
@@ 1,1 0,0 @@
�ax�aT
\ No newline at end of file

D test/normalization/beta/OperatorListConcatenateLhsEmptyB.dhallb => test/normalization/beta/OperatorListConcatenateLhsEmptyB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/OperatorListConcatenateListListA.dhallb => test/normalization/beta/OperatorListConcatenateListListA.dhallb +0 -1
@@ 1,1 0,0 @@
���ax��ay
\ No newline at end of file

D test/normalization/beta/OperatorListConcatenateListListB.dhallb => test/normalization/beta/OperatorListConcatenateListListB.dhallb +0 -1
@@ 1,1 0,0 @@
��axay
\ No newline at end of file

D test/normalization/beta/OperatorListConcatenateNormalizeArgumentsA.dhallb => test/normalization/beta/OperatorListConcatenateNormalizeArgumentsA.dhallb +0 -1
@@ 1,1 0,0 @@
���aTax��aTay
\ No newline at end of file

D test/normalization/beta/OperatorListConcatenateNormalizeArgumentsB.dhallb => test/normalization/beta/OperatorListConcatenateNormalizeArgumentsB.dhallb +0 -1
@@ 1,1 0,0 @@
�axay
\ No newline at end of file

D test/normalization/beta/OperatorListConcatenateRhsEmptyA.dhallb => test/normalization/beta/OperatorListConcatenateRhsEmptyA.dhallb +0 -1
@@ 1,1 0,0 @@
��aTax
\ No newline at end of file

D test/normalization/beta/OperatorListConcatenateRhsEmptyB.dhallb => test/normalization/beta/OperatorListConcatenateRhsEmptyB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/OperatorNotEqualEquivalentArgumentsA.dhallb => test/normalization/beta/OperatorNotEqualEquivalentArgumentsA.dhallb +0 -1
@@ 1,1 0,0 @@
�axax
\ No newline at end of file

D test/normalization/beta/OperatorNotEqualEquivalentArgumentsB.dhallb => test/normalization/beta/OperatorNotEqualEquivalentArgumentsB.dhallb +0 -1
@@ 1,1 0,0 @@

\ No newline at end of file

D test/normalization/beta/OperatorNotEqualLhsFalseA.dhallb => test/normalization/beta/OperatorNotEqualLhsFalseA.dhallb +0 -1
@@ 1,1 0,0 @@
��ax
\ No newline at end of file

D test/normalization/beta/OperatorNotEqualLhsFalseB.dhallb => test/normalization/beta/OperatorNotEqualLhsFalseB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/OperatorNotEqualNormalizeArgumentsA.dhallb => test/normalization/beta/OperatorNotEqualNormalizeArgumentsA.dhallb +0 -1
@@ 1,1 0,0 @@
���ax��ay
\ No newline at end of file

D test/normalization/beta/OperatorNotEqualNormalizeArgumentsB.dhallb => test/normalization/beta/OperatorNotEqualNormalizeArgumentsB.dhallb +0 -1
@@ 1,1 0,0 @@
�axay
\ No newline at end of file

D test/normalization/beta/OperatorNotEqualRhsFalseA.dhallb => test/normalization/beta/OperatorNotEqualRhsFalseA.dhallb +0 -1
@@ 1,1 0,0 @@
�ax�
\ No newline at end of file

D test/normalization/beta/OperatorNotEqualRhsFalseB.dhallb => test/normalization/beta/OperatorNotEqualRhsFalseB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/OperatorOrEquivalentArgumentsA.dhallb => test/normalization/beta/OperatorOrEquivalentArgumentsA.dhallb +0 -0
D test/normalization/beta/OperatorOrEquivalentArgumentsB.dhallb => test/normalization/beta/OperatorOrEquivalentArgumentsB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/OperatorOrLhsFalseA.dhallb => test/normalization/beta/OperatorOrLhsFalseA.dhallb +0 -0
D test/normalization/beta/OperatorOrLhsFalseB.dhallb => test/normalization/beta/OperatorOrLhsFalseB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/OperatorOrLhsTrueA.dhallb => test/normalization/beta/OperatorOrLhsTrueA.dhallb +0 -0
D test/normalization/beta/OperatorOrLhsTrueB.dhallb => test/normalization/beta/OperatorOrLhsTrueB.dhallb +0 -1
@@ 1,1 0,0 @@

\ No newline at end of file

D test/normalization/beta/OperatorOrNormalizeArgumentsA.dhallb => test/normalization/beta/OperatorOrNormalizeArgumentsA.dhallb +0 -0
D test/normalization/beta/OperatorOrNormalizeArgumentsB.dhallb => test/normalization/beta/OperatorOrNormalizeArgumentsB.dhallb +0 -0
D test/normalization/beta/OperatorOrRhsFalseA.dhallb => test/normalization/beta/OperatorOrRhsFalseA.dhallb +0 -0
D test/normalization/beta/OperatorOrRhsFalseB.dhallb => test/normalization/beta/OperatorOrRhsFalseB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/OperatorOrRhsTrueA.dhallb => test/normalization/beta/OperatorOrRhsTrueA.dhallb +0 -0
D test/normalization/beta/OperatorOrRhsTrueB.dhallb => test/normalization/beta/OperatorOrRhsTrueB.dhallb +0 -1
@@ 1,1 0,0 @@

\ No newline at end of file

D test/normalization/beta/OperatorPlusLhsZeroA.dhallb => test/normalization/beta/OperatorPlusLhsZeroA.dhallb +0 -0
D test/normalization/beta/OperatorPlusLhsZeroB.dhallb => test/normalization/beta/OperatorPlusLhsZeroB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/OperatorPlusNormalizeArgumentsA.dhallb => test/normalization/beta/OperatorPlusNormalizeArgumentsA.dhallb +0 -0
D test/normalization/beta/OperatorPlusNormalizeArgumentsB.dhallb => test/normalization/beta/OperatorPlusNormalizeArgumentsB.dhallb +0 -1
@@ 1,1 0,0 @@
�axay
\ No newline at end of file

D test/normalization/beta/OperatorPlusOneAndOneA.dhallb => test/normalization/beta/OperatorPlusOneAndOneA.dhallb +0 -1
@@ 1,1 0,0 @@
���
\ No newline at end of file

D test/normalization/beta/OperatorPlusOneAndOneB.dhallb => test/normalization/beta/OperatorPlusOneAndOneB.dhallb +0 -1
@@ 1,1 0,0 @@

\ No newline at end of file

D test/normalization/beta/OperatorPlusRhsZeroA.dhallb => test/normalization/beta/OperatorPlusRhsZeroA.dhallb +0 -0
D test/normalization/beta/OperatorPlusRhsZeroB.dhallb => test/normalization/beta/OperatorPlusRhsZeroB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/OperatorTextConcatenateLhsEmptyA.dhallb => test/normalization/beta/OperatorTextConcatenateLhsEmptyA.dhallb +0 -1
@@ 1,1 0,0 @@
��`ax
\ No newline at end of file

D test/normalization/beta/OperatorTextConcatenateLhsEmptyB.dhallb => test/normalization/beta/OperatorTextConcatenateLhsEmptyB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/OperatorTextConcatenateNormalizeArgumentsA.dhallb => test/normalization/beta/OperatorTextConcatenateNormalizeArgumentsA.dhallb +0 -1
@@ 1,1 0,0 @@
���`ax��`ay
\ No newline at end of file

D test/normalization/beta/OperatorTextConcatenateNormalizeArgumentsB.dhallb => test/normalization/beta/OperatorTextConcatenateNormalizeArgumentsB.dhallb +0 -1
@@ 1,1 0,0 @@
�axay
\ No newline at end of file

D test/normalization/beta/OperatorTextConcatenateRhsEmptyA.dhallb => test/normalization/beta/OperatorTextConcatenateRhsEmptyA.dhallb +0 -1
@@ 1,1 0,0 @@
�ax�`
\ No newline at end of file

D test/normalization/beta/OperatorTextConcatenateRhsEmptyB.dhallb => test/normalization/beta/OperatorTextConcatenateRhsEmptyB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/OperatorTextConcatenateTextTextA.dhallb => test/normalization/beta/OperatorTextConcatenateTextTextA.dhallb +0 -1
@@ 1,1 0,0 @@
��ax�ay
\ No newline at end of file

D test/normalization/beta/OperatorTextConcatenateTextTextB.dhallb => test/normalization/beta/OperatorTextConcatenateTextTextB.dhallb +0 -1
@@ 1,1 0,0 @@
�bxy
\ No newline at end of file

D test/normalization/beta/OperatorTimesLhsOneA.dhallb => test/normalization/beta/OperatorTimesLhsOneA.dhallb +0 -1
@@ 1,1 0,0 @@
��ax
\ No newline at end of file

D test/normalization/beta/OperatorTimesLhsOneB.dhallb => test/normalization/beta/OperatorTimesLhsOneB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/OperatorTimesLhsZeroA.dhallb => test/normalization/beta/OperatorTimesLhsZeroA.dhallb +0 -0
D test/normalization/beta/OperatorTimesLhsZeroB.dhallb => test/normalization/beta/OperatorTimesLhsZeroB.dhallb +0 -0
D test/normalization/beta/OperatorTimesNormalizeArgumentsA.dhallb => test/normalization/beta/OperatorTimesNormalizeArgumentsA.dhallb +0 -1
@@ 1,1 0,0 @@
���ax��ay
\ No newline at end of file

D test/normalization/beta/OperatorTimesNormalizeArgumentsB.dhallb => test/normalization/beta/OperatorTimesNormalizeArgumentsB.dhallb +0 -1
@@ 1,1 0,0 @@
�axay
\ No newline at end of file

D test/normalization/beta/OperatorTimesRhsOneA.dhallb => test/normalization/beta/OperatorTimesRhsOneA.dhallb +0 -1
@@ 1,1 0,0 @@
�ax�
\ No newline at end of file

D test/normalization/beta/OperatorTimesRhsOneB.dhallb => test/normalization/beta/OperatorTimesRhsOneB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/OperatorTimesRhsZeroA.dhallb => test/normalization/beta/OperatorTimesRhsZeroA.dhallb +0 -0
D test/normalization/beta/OperatorTimesRhsZeroB.dhallb => test/normalization/beta/OperatorTimesRhsZeroB.dhallb +0 -0
D test/normalization/beta/OperatorTimesTwoAndTwoA.dhallb => test/normalization/beta/OperatorTimesTwoAndTwoA.dhallb +0 -1
@@ 1,1 0,0 @@
���
\ No newline at end of file

D test/normalization/beta/OperatorTimesTwoAndTwoB.dhallb => test/normalization/beta/OperatorTimesTwoAndTwoB.dhallb +0 -1
@@ 1,1 0,0 @@

\ No newline at end of file

D test/normalization/beta/OptionalA.dhallb => test/normalization/beta/OptionalA.dhallb +0 -1
@@ 1,1 0,0 @@
hOptional
\ No newline at end of file

D test/normalization/beta/OptionalB.dhallb => test/normalization/beta/OptionalB.dhallb +0 -1
@@ 1,1 0,0 @@
hOptional
\ No newline at end of file

D test/normalization/beta/OptionalBuildA.dhallb => test/normalization/beta/OptionalBuildA.dhallb +0 -1
@@ 1,1 0,0 @@
nOptional/build
\ No newline at end of file

D test/normalization/beta/OptionalBuildB.dhallb => test/normalization/beta/OptionalBuildB.dhallb +0 -1
@@ 1,1 0,0 @@
nOptional/build
\ No newline at end of file

D test/normalization/beta/OptionalBuildFoldFusionA.dhallb => test/normalization/beta/OptionalBuildFoldFusionA.dhallb +0 -0
D test/normalization/beta/OptionalBuildFoldFusionB.dhallb => test/normalization/beta/OptionalBuildFoldFusionB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/OptionalBuildImplementationA.dhallb => test/normalization/beta/OptionalBuildImplementationA.dhallb +0 -0
D test/normalization/beta/OptionalBuildImplementationB.dhallb => test/normalization/beta/OptionalBuildImplementationB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/OptionalFoldA.dhallb => test/normalization/beta/OptionalFoldA.dhallb +0 -1
@@ 1,1 0,0 @@
mOptional/fold
\ No newline at end of file

D test/normalization/beta/OptionalFoldB.dhallb => test/normalization/beta/OptionalFoldB.dhallb +0 -1
@@ 1,1 0,0 @@
mOptional/fold
\ No newline at end of file

D test/normalization/beta/OptionalFoldNoneA.dhallb => test/normalization/beta/OptionalFoldNoneA.dhallb +0 -0
D test/normalization/beta/OptionalFoldNoneB.dhallb => test/normalization/beta/OptionalFoldNoneB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/OptionalFoldSomeA.dhallb => test/normalization/beta/OptionalFoldSomeA.dhallb +0 -0
D test/normalization/beta/OptionalFoldSomeB.dhallb => test/normalization/beta/OptionalFoldSomeB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/RecordA.dhallb => test/normalization/beta/RecordA.dhallb +0 -1
@@ 1,1 0,0 @@
��aa��ayazabax
\ No newline at end of file

D test/normalization/beta/RecordB.dhallb => test/normalization/beta/RecordB.dhallb +0 -1
@@ 1,1 0,0 @@
��aaayabax
\ No newline at end of file

D test/normalization/beta/RecordEmptyA.dhallb => test/normalization/beta/RecordEmptyA.dhallb +0 -1
@@ 1,1 0,0 @@
��
\ No newline at end of file

D test/normalization/beta/RecordEmptyB.dhallb => test/normalization/beta/RecordEmptyB.dhallb +0 -1
@@ 1,1 0,0 @@
��
\ No newline at end of file

D test/normalization/beta/RecordProjectionA.dhallb => test/normalization/beta/RecordProjectionA.dhallb +0 -2
@@ 1,2 0,0 @@
��axaaayabazacaxaz
\ No newline at end of file

D test/normalization/beta/RecordProjectionB.dhallb => test/normalization/beta/RecordProjectionB.dhallb +0 -1
@@ 1,1 0,0 @@
��axaaazac
\ No newline at end of file

D test/normalization/beta/RecordProjectionEmptyA.dhallb => test/normalization/beta/RecordProjectionEmptyA.dhallb +0 -2
@@ 1,2 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/RecordProjectionEmptyB.dhallb => test/normalization/beta/RecordProjectionEmptyB.dhallb +0 -1
@@ 1,1 0,0 @@
��
\ No newline at end of file

D test/normalization/beta/RecordProjectionNormalizeArgumentsA.dhallb => test/normalization/beta/RecordProjectionNormalizeArgumentsA.dhallb +0 -2
@@ 1,2 0,0 @@
��ayazaxay
\ No newline at end of file

D test/normalization/beta/RecordProjectionNormalizeArgumentsB.dhallb => test/normalization/beta/RecordProjectionNormalizeArgumentsB.dhallb +0 -2
@@ 1,2 0,0 @@
ayaxay
\ No newline at end of file

D test/normalization/beta/RecordSelectionA.dhallb => test/normalization/beta/RecordSelectionA.dhallb +0 -1
@@ 1,1 0,0 @@
�	��axavax
\ No newline at end of file

D test/normalization/beta/RecordSelectionB.dhallb => test/normalization/beta/RecordSelectionB.dhallb +0 -1
@@ 1,1 0,0 @@
av
\ No newline at end of file

D test/normalization/beta/RecordSelectionNormalizeArgumentsA.dhallb => test/normalization/beta/RecordSelectionNormalizeArgumentsA.dhallb +0 -1
@@ 1,1 0,0 @@
�	��ayazax
\ No newline at end of file

D test/normalization/beta/RecordSelectionNormalizeArgumentsB.dhallb => test/normalization/beta/RecordSelectionNormalizeArgumentsB.dhallb +0 -1
@@ 1,1 0,0 @@
�	ayax
\ No newline at end of file

D test/normalization/beta/RecordTypeA.dhallb => test/normalization/beta/RecordTypeA.dhallb +0 -1
@@ 1,1 0,0 @@
��aa��aAaBabaT
\ No newline at end of file

D test/normalization/beta/RecordTypeB.dhallb => test/normalization/beta/RecordTypeB.dhallb +0 -1
@@ 1,1 0,0 @@
��aaaAabaT
\ No newline at end of file

D test/normalization/beta/RecordTypeEmptyA.dhallb => test/normalization/beta/RecordTypeEmptyA.dhallb +0 -1
@@ 1,1 0,0 @@
��
\ No newline at end of file

D test/normalization/beta/RecordTypeEmptyB.dhallb => test/normalization/beta/RecordTypeEmptyB.dhallb +0 -1
@@ 1,1 0,0 @@
��
\ No newline at end of file

D test/normalization/beta/RecursiveRecordMergeCollisionA.dhallb => test/normalization/beta/RecursiveRecordMergeCollisionA.dhallb +0 -1
@@ 1,1 0,0 @@
���ax��az���ax��ay�
\ No newline at end of file

D test/normalization/beta/RecursiveRecordMergeCollisionB.dhallb => test/normalization/beta/RecursiveRecordMergeCollisionB.dhallb +0 -1
@@ 1,1 0,0 @@
��ax��ay�az�
\ No newline at end of file

D test/normalization/beta/RecursiveRecordMergeLhsEmptyA.dhallb => test/normalization/beta/RecursiveRecordMergeLhsEmptyA.dhallb +0 -1
@@ 1,1 0,0 @@
���ax
\ No newline at end of file

D test/normalization/beta/RecursiveRecordMergeLhsEmptyB.dhallb => test/normalization/beta/RecursiveRecordMergeLhsEmptyB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/RecursiveRecordMergeNoCollisionA.dhallb => test/normalization/beta/RecursiveRecordMergeNoCollisionA.dhallb +0 -1
@@ 1,1 0,0 @@
���ax��az���ab��ay�
\ No newline at end of file

D test/normalization/beta/RecursiveRecordMergeNoCollisionB.dhallb => test/normalization/beta/RecursiveRecordMergeNoCollisionB.dhallb +0 -1
@@ 1,1 0,0 @@
��ab��ay�ax��az�
\ No newline at end of file

D test/normalization/beta/RecursiveRecordMergeNormalizeArgumentsA.dhallb => test/normalization/beta/RecursiveRecordMergeNormalizeArgumentsA.dhallb +0 -1
@@ 1,1 0,0 @@
��ax�����ab
\ No newline at end of file

D test/normalization/beta/RecursiveRecordMergeNormalizeArgumentsB.dhallb => test/normalization/beta/RecursiveRecordMergeNormalizeArgumentsB.dhallb +0 -1
@@ 1,1 0,0 @@
�axab
\ No newline at end of file

D test/normalization/beta/RecursiveRecordMergeRhsEmptyA.dhallb => test/normalization/beta/RecursiveRecordMergeRhsEmptyA.dhallb +0 -1
@@ 1,1 0,0 @@
�ax��
\ No newline at end of file

D test/normalization/beta/RecursiveRecordMergeRhsEmptyB.dhallb => test/normalization/beta/RecursiveRecordMergeRhsEmptyB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/RecursiveRecordTypeMergeCollisionA.dhallb => test/normalization/beta/RecursiveRecordTypeMergeCollisionA.dhallb +0 -2
@@ 1,2 0,0 @@
��ax��azaA��ax��ayaB
\ No newline at end of file

D test/normalization/beta/RecursiveRecordTypeMergeCollisionB.dhallb => test/normalization/beta/RecursiveRecordTypeMergeCollisionB.dhallb +0 -1
@@ 1,1 0,0 @@
��ax��ayaBazaA
\ No newline at end of file

D test/normalization/beta/RecursiveRecordTypeMergeLhsEmptyA.dhallb => test/normalization/beta/RecursiveRecordTypeMergeLhsEmptyA.dhallb +0 -2
@@ 1,2 0,0 @@
��ax
\ No newline at end of file

D test/normalization/beta/RecursiveRecordTypeMergeLhsEmptyB.dhallb => test/normalization/beta/RecursiveRecordTypeMergeLhsEmptyB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/RecursiveRecordTypeMergeNoCollisionA.dhallb => test/normalization/beta/RecursiveRecordTypeMergeNoCollisionA.dhallb +0 -2
@@ 1,2 0,0 @@
��ax��azaA��ab��ayaB
\ No newline at end of file

D test/normalization/beta/RecursiveRecordTypeMergeNoCollisionB.dhallb => test/normalization/beta/RecursiveRecordTypeMergeNoCollisionB.dhallb +0 -1
@@ 1,1 0,0 @@
��ab��ayaBax��azaA
\ No newline at end of file

D test/normalization/beta/RecursiveRecordTypeMergeNormalizeArgumentsA.dhallb => test/normalization/beta/RecursiveRecordTypeMergeNormalizeArgumentsA.dhallb +0 -4
@@ 1,4 0,0 @@
ax���
��ab
\ No newline at end of file

D test/normalization/beta/RecursiveRecordTypeMergeNormalizeArgumentsB.dhallb => test/normalization/beta/RecursiveRecordTypeMergeNormalizeArgumentsB.dhallb +0 -2
@@ 1,2 0,0 @@
axab
\ No newline at end of file

D test/normalization/beta/RecursiveRecordTypeMergeRhsEmptyA.dhallb => test/normalization/beta/RecursiveRecordTypeMergeRhsEmptyA.dhallb +0 -2
@@ 1,2 0,0 @@
ax��
\ No newline at end of file

D test/normalization/beta/RecursiveRecordTypeMergeRhsEmptyB.dhallb => test/normalization/beta/RecursiveRecordTypeMergeRhsEmptyB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/RightBiasedRecordMergeCollisionA.dhallb => test/normalization/beta/RightBiasedRecordMergeCollisionA.dhallb +0 -1
@@ 1,1 0,0 @@
�	��ax�ay���ax�
\ No newline at end of file

D test/normalization/beta/RightBiasedRecordMergeCollisionB.dhallb => test/normalization/beta/RightBiasedRecordMergeCollisionB.dhallb +0 -1
@@ 1,1 0,0 @@
��ax�ay�
\ No newline at end of file

D test/normalization/beta/RightBiasedRecordMergeLhsEmptyA.dhallb => test/normalization/beta/RightBiasedRecordMergeLhsEmptyA.dhallb +0 -1
@@ 1,1 0,0 @@
�	��ax
\ No newline at end of file

D test/normalization/beta/RightBiasedRecordMergeLhsEmptyB.dhallb => test/normalization/beta/RightBiasedRecordMergeLhsEmptyB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/RightBiasedRecordMergeNoCollisionA.dhallb => test/normalization/beta/RightBiasedRecordMergeNoCollisionA.dhallb +0 -1
@@ 1,1 0,0 @@
�	��ax�ay���aa�
\ No newline at end of file

D test/normalization/beta/RightBiasedRecordMergeNoCollisionB.dhallb => test/normalization/beta/RightBiasedRecordMergeNoCollisionB.dhallb +0 -1
@@ 1,1 0,0 @@
��aa�ax�ay�
\ No newline at end of file

D test/normalization/beta/RightBiasedRecordMergeNormalizeArgumentsA.dhallb => test/normalization/beta/RightBiasedRecordMergeNormalizeArgumentsA.dhallb +0 -1
@@ 1,1 0,0 @@
�	�	ax���	ay��
\ No newline at end of file

D test/normalization/beta/RightBiasedRecordMergeNormalizeArgumentsB.dhallb => test/normalization/beta/RightBiasedRecordMergeNormalizeArgumentsB.dhallb +0 -1
@@ 1,1 0,0 @@
�	axay
\ No newline at end of file

D test/normalization/beta/RightBiasedRecordMergeRhsEmptyA.dhallb => test/normalization/beta/RightBiasedRecordMergeRhsEmptyA.dhallb +0 -1
@@ 1,1 0,0 @@
�	ax��
\ No newline at end of file

D test/normalization/beta/RightBiasedRecordMergeRhsEmptyB.dhallb => test/normalization/beta/RightBiasedRecordMergeRhsEmptyB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/SomeNormalizeArgumentsA.dhallb => test/normalization/beta/SomeNormalizeArgumentsA.dhallb +0 -1
@@ 1,1 0,0 @@
����axay
\ No newline at end of file

D test/normalization/beta/SomeNormalizeArgumentsB.dhallb => test/normalization/beta/SomeNormalizeArgumentsB.dhallb +0 -1
@@ 1,1 0,0 @@
��ax
\ No newline at end of file

D test/normalization/beta/SortA.dhallb => test/normalization/beta/SortA.dhallb +0 -1
@@ 1,1 0,0 @@
dSort
\ No newline at end of file

D test/normalization/beta/SortB.dhallb => test/normalization/beta/SortB.dhallb +0 -1
@@ 1,1 0,0 @@
dSort
\ No newline at end of file

D test/normalization/beta/TextA.dhallb => test/normalization/beta/TextA.dhallb +0 -1
@@ 1,1 0,0 @@
dText
\ No newline at end of file

D test/normalization/beta/TextB.dhallb => test/normalization/beta/TextB.dhallb +0 -1
@@ 1,1 0,0 @@
dText
\ No newline at end of file

D test/normalization/beta/TextInterpolateA.dhallb => test/normalization/beta/TextInterpolateA.dhallb +0 -1
@@ 1,1 0,0 @@
�as�abax``
\ No newline at end of file

D test/normalization/beta/TextInterpolateB.dhallb => test/normalization/beta/TextInterpolateB.dhallb +0 -1
@@ 1,1 0,0 @@
�bsbax`
\ No newline at end of file

D test/normalization/beta/TextLiteralA.dhallb => test/normalization/beta/TextLiteralA.dhallb +0 -1
@@ 1,1 0,0 @@
�as
\ No newline at end of file

D test/normalization/beta/TextLiteralB.dhallb => test/normalization/beta/TextLiteralB.dhallb +0 -1
@@ 1,1 0,0 @@
�as
\ No newline at end of file

D test/normalization/beta/TextNormalizeInterpolationsA.dhallb => test/normalization/beta/TextNormalizeInterpolationsA.dhallb +0 -1
@@ 1,1 0,0 @@
�as��axay`
\ No newline at end of file

D test/normalization/beta/TextNormalizeInterpolationsB.dhallb => test/normalization/beta/TextNormalizeInterpolationsB.dhallb +0 -1
@@ 1,1 0,0 @@
�asax`
\ No newline at end of file

D test/normalization/beta/TextShowA.dhallb => test/normalization/beta/TextShowA.dhallb +0 -1
@@ 1,1 0,0 @@
iText/show
\ No newline at end of file

D test/normalization/beta/TextShowAllEscapesA.dhallb => test/normalization/beta/TextShowAllEscapesA.dhallb +0 -0
D test/normalization/beta/TextShowAllEscapesB.dhallb => test/normalization/beta/TextShowAllEscapesB.dhallb +0 -1
@@ 1,1 0,0 @@
�x("\"\u0024\\\b\f\n\r\tツa\u0007b\u0010c"
\ No newline at end of file

D test/normalization/beta/TextShowB.dhallb => test/normalization/beta/TextShowB.dhallb +0 -1
@@ 1,1 0,0 @@
iText/show
\ No newline at end of file

D test/normalization/beta/TrueA.dhallb => test/normalization/beta/TrueA.dhallb +0 -1
@@ 1,1 0,0 @@

\ No newline at end of file

D test/normalization/beta/TrueB.dhallb => test/normalization/beta/TrueB.dhallb +0 -1
@@ 1,1 0,0 @@

\ No newline at end of file

D test/normalization/beta/TypeA.dhallb => test/normalization/beta/TypeA.dhallb +0 -1
@@ 1,1 0,0 @@
dType
\ No newline at end of file

D test/normalization/beta/TypeAnnotationA.dhallb => test/normalization/beta/TypeAnnotationA.dhallb +0 -1
@@ 1,1 0,0 @@
�axaA
\ No newline at end of file

D test/normalization/beta/TypeAnnotationB.dhallb => test/normalization/beta/TypeAnnotationB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/TypeB.dhallb => test/normalization/beta/TypeB.dhallb +0 -1
@@ 1,1 0,0 @@
dType
\ No newline at end of file

D test/normalization/beta/UnionNormalizeAlternativesA.dhallb => test/normalization/beta/UnionNormalizeAlternativesA.dhallb +0 -1
@@ 1,1 0,0 @@
�axay�ay��aXaY
\ No newline at end of file

D test/normalization/beta/UnionNormalizeAlternativesB.dhallb => test/normalization/beta/UnionNormalizeAlternativesB.dhallb +0 -1
@@ 1,1 0,0 @@
�axay�ayaX
\ No newline at end of file

D test/normalization/beta/UnionNormalizeArgumentsA.dhallb => test/normalization/beta/UnionNormalizeArgumentsA.dhallb +0 -1
@@ 1,1 0,0 @@
�ax��ayaz�
\ No newline at end of file

D test/normalization/beta/UnionNormalizeArgumentsB.dhallb => test/normalization/beta/UnionNormalizeArgumentsB.dhallb +0 -1
@@ 1,1 0,0 @@
�axay�
\ No newline at end of file

D test/normalization/beta/UnionProjectConstructorA.dhallb => test/normalization/beta/UnionProjectConstructorA.dhallb +0 -1
@@ 1,1 0,0 @@
�	��axaTax
\ No newline at end of file

D test/normalization/beta/UnionProjectConstructorB.dhallb => test/normalization/beta/UnionProjectConstructorB.dhallb +0 -1
@@ 1,1 0,0 @@
�axaT�axax�
\ No newline at end of file

D test/normalization/beta/UnionProjectConstructorNormalizeArgumentsA.dhallb => test/normalization/beta/UnionProjectConstructorNormalizeArgumentsA.dhallb +0 -1
@@ 1,1 0,0 @@
�	��ayazax
\ No newline at end of file

D test/normalization/beta/UnionProjectConstructorNormalizeArgumentsB.dhallb => test/normalization/beta/UnionProjectConstructorNormalizeArgumentsB.dhallb +0 -1
@@ 1,1 0,0 @@
�	ayax
\ No newline at end of file

D test/normalization/beta/UnionSortAlternativesA.dhallb => test/normalization/beta/UnionSortAlternativesA.dhallb +0 -1
@@ 1,1 0,0 @@
�axay�ayaBazaA
\ No newline at end of file

D test/normalization/beta/UnionSortAlternativesB.dhallb => test/normalization/beta/UnionSortAlternativesB.dhallb +0 -1
@@ 1,1 0,0 @@
�axay�ayaBazaA
\ No newline at end of file

D test/normalization/beta/UnionTypeA.dhallb => test/normalization/beta/UnionTypeA.dhallb +0 -1
@@ 1,1 0,0 @@
��axaBazaA
\ No newline at end of file

D test/normalization/beta/UnionTypeB.dhallb => test/normalization/beta/UnionTypeB.dhallb +0 -1
@@ 1,1 0,0 @@
��axaBazaA
\ No newline at end of file

D test/normalization/beta/UnionTypeEmptyA.dhallb => test/normalization/beta/UnionTypeEmptyA.dhallb +0 -1
@@ 1,1 0,0 @@
��
\ No newline at end of file

D test/normalization/beta/UnionTypeEmptyB.dhallb => test/normalization/beta/UnionTypeEmptyB.dhallb +0 -1
@@ 1,1 0,0 @@
��
\ No newline at end of file

D test/normalization/beta/UnionTypeNormalizeArgumentsA.dhallb => test/normalization/beta/UnionTypeNormalizeArgumentsA.dhallb +0 -1
@@ 1,1 0,0 @@
��ax��aBaZazaA
\ No newline at end of file

D test/normalization/beta/UnionTypeNormalizeArgumentsB.dhallb => test/normalization/beta/UnionTypeNormalizeArgumentsB.dhallb +0 -1
@@ 1,1 0,0 @@
��axaBazaA
\ No newline at end of file

D test/normalization/beta/VariableA.dhallb => test/normalization/beta/VariableA.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/beta/VariableB.dhallb => test/normalization/beta/VariableB.dhallb +0 -1
@@ 1,1 0,0 @@
ax
\ No newline at end of file

D test/normalization/dhall-encode => test/normalization/dhall-encode +0 -3
@@ 1,3 0,0 @@
#!/bin/sh

dhall encode < "$1" > "$1"b

D test/normalization/dhall-hash => test/normalization/dhall-hash +0 -7
@@ 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

D test/normalization/gen => test/normalization/gen +0 -9
@@ 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 '{}' \;

D test/normalization/standard/.gitignore => test/normalization/standard/.gitignore +0 -2
@@ 1,2 0,0 @@
*.dhall
*.dhallb

M test/test_as_json.rb => test/test_as_json.rb +5 -3
@@ 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

M test/test_binary.rb => test/test_binary.rb +1 -1
@@ 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$/, "")

M test/test_normalization.rb => test/test_normalization.rb +8 -8
@@ 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


A test/test_parser.rb => test/test_parser.rb +36 -0
@@ 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

M test/test_resolvers.rb => test/test_resolvers.rb +4 -4
@@ 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

M test/test_suite.rb => test/test_suite.rb +1 -0
@@ 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