dhall 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2189303de0238086f008d9fa07f0a24de1f0d825
-  data.tar.gz: 33dd23d2bcffb5e1171a7a0a08320c02be502fe1
+  metadata.gz: 30ff6e0ad066b23996b9a31b21e7f1a30b86b265
+  data.tar.gz: 88efb36ee05894a74df3b691d67774b8e0eea185
 SHA512:
-  metadata.gz: 3e3385fa51023333875319b5355a8eb11dcb9e69b0bbaa6b2bbf368003ea46a79daf7819dfcc9e8e444f028e6edbbf33dba8a3e68043a2a92a97767f82819bca
-  data.tar.gz: d690a7f50b99ee3d8f7a16ab4e7439c42b1500cc23186e30a6db73c8c76af3ca452c9febc303f7ce179166cc55629188720a1ea9839469c3c29356559a25d2d6
+  metadata.gz: ff197049f1d4ceb3e1742a4e3b44491192170c4bb1e32b7aef6bbaeb643f16b828ffdee1d78eaa628a9f0dd9d5dedd0f4c796556b2e72b92ed0705a0e8306430
+  data.tar.gz: e92aad6b3921f4bd25ebdf8f20204b95ceec8814250ed90b5424b70a75991ca68de8bd60b0c2cf982541c560f9e1ba135f87f0b05f685d767588150b051c465f

data/README.md

@@ -12,7 +12,7 @@ For the purposes of considering what is a "breaking change" only the API as docu
 
 Add this line to your application's Gemfile:
 
-    gem 'dhall'
+    gem "dhall"
 
 And then execute:
 

data/bin/dhall-compile

@@ -0,0 +1,77 @@
+#!/usr/bin/ruby
+# frozen_string_literal: true
+
+require "dhall"
+require "optparse"
+
+@extension = ".dhallb"
+
+def compile(source)
+	Dhall.load(
+		source,
+		timeout:  Float::INFINITY,
+		resolver: Dhall::Resolvers::Default.new(
+			max_depth: Float::INFINITY
+		)
+	).then(&:to_binary)
+end
+
+def compile_file(file_path, relative_to: Pathname.new("."))
+	out = file_path.sub_ext(@extension)
+	if @output_directory
+		out = @output_directory + out.relative_path_from(relative_to)
+		out.dirname.mkpath
+	end
+	warn "#{file_path} => #{out}"
+	compile(file_path.expand_path).then(&out.method(:write))
+end
+
+opt_parser = OptionParser.new do |opts|
+	opts.banner = "Usage: dhall-compile [options] [-] [files_and_dirs]"
+
+	opts.on(
+		"-oDIRECTORY",
+		"--output-directory DIRECTORY",
+		"Write output to this directory"
+	) do |dir|
+		@output_directory = Pathname.new(dir)
+	end
+
+	opts.on(
+		"-e [EXTENSION]",
+		"--extension [EXTENSION]",
+		"Use this extension for files (default .dhallb)"
+	) do |ext|
+		@extension = ext ? ".#{ext}" : ""
+	end
+
+	opts.on("-h", "--help", "Show this usage information") do
+		warn opts
+		exit
+	end
+end
+
+opt_parser.parse!
+
+if ARGV.empty?
+	warn opt_parser
+	exit 0
+end
+
+ARGV.map(&Pathname.method(:new)).each do |path|
+	if !path.exist? && path.to_s == "-"
+		warn "Compiling STDIN to STDOUT"
+		compile(STDIN.read).then(&STDOUT.method(:write)).sync
+	elsif path.file?
+		compile_file(path, relative_to: path.dirname).sync
+	elsif path.directory?
+		warn "Recursively compiling #{path}"
+		path.find.flat_map do |child|
+			next if !child.file? || child.extname == ".dhallb"
+			compile_file(child, relative_to: path).sync
+		end
+	else
+		warn "#{path} may not exist"
+		exit 1
+	end
+end

data/lib/dhall/as_dhall.rb

@@ -6,31 +6,84 @@ require "psych"
 module Dhall
 	module AsDhall
 		TAGS = {
-			::Integer    => "Integer",
+			::Array      => "List",
 			::FalseClass => "Bool",
-			::Integer    => "Integer",
 			::Float      => "Double",
+			::Hash       => "Record",
+			::Integer    => "Integer",
+			::Integer    => "Integer",
 			::NilClass   => "None",
 			::String     => "Text",
 			::TrueClass  => "Bool"
 		}.freeze
 
-		def self.tag_for(o, type)
+		def self.tag_for(o)
 			return "Natural" if o.is_a?(::Integer) && !o.negative?
 
 			TAGS.fetch(o.class) do
-				"#{o.class.name}_#{type.digest.hexdigest}"
+				o.class.name
+			end
+		end
+
+		class AnnotatedExpressionList
+			attr_reader :type
+			attr_reader :exprs
+
+			def self.from(type_annotation)
+				if type_annotation.nil?
+					new(nil, [nil])
+				else
+					new(type_annotation.type, [type_annotation.value])
+				end
+			end
+
+			def initialize(type, exprs)
+				@type = type
+				@exprs = exprs
+			end
+
+			def +(other)
+				raise "#{type} != #{other.type}" if type != other.type
+				self.class.new(type, exprs + other.exprs)
 			end
 		end
 
-		def self.union_of(values_and_types)
-			z = [UnionType.new(alternatives: {}), []]
-			values_and_types.reduce(z) do |(ut, tags), (v, t)|
-				tag = tag_for(v, t)
-				[
-					ut.merge(UnionType.new(alternatives: { tag => t })),
-					tags + [tag]
-				]
+		class UnionInferer
+			def initialize(tagged={})
+				@tagged = tagged
+			end
+
+			def union_type
+				UnionType.new(alternatives: Hash[@tagged.map { |k, v| [k, v.type] }])
+			end
+
+			def union_for(expr)
+				if expr.is_a?(Enum)
+					tag = expr.tag
+					expr = nil
+				else
+					tag = @tagged.keys.find { |k| @tagged[k].exprs.include?(expr) }
+				end
+				expr = expr.extract if expr.is_a?(Union)
+				Union.from(union_type, tag, expr)
+			end
+
+			def with(tag, type_annotation)
+				anno = AnnotatedExpressionList.from(type_annotation)
+				if @tagged.key?(tag) && @tagged[tag].type != anno.type
+					disambiguate_against(tag, anno)
+				else
+					self.class.new(@tagged.merge(tag => anno) { |_, x, y| x + y })
+				end
+			end
+
+			def disambiguate_against(tag, anno)
+				self.class.new(
+					@tagged.reject { |k, _| k == tag }.merge(
+						"#{tag}_#{@tagged[tag].type.digest.hexdigest}" => @tagged[tag],
+						"#{tag}_#{anno.type.digest.hexdigest}"         => anno
+					)
+				)
 			end
 		end
 
@@ -46,9 +99,8 @@ module Dhall
 
 		refine ::Symbol do
 			def as_dhall
-				Dhall::Union.new(
+				Dhall::Enum.new(
 					tag:          to_s,
-					value:        nil,
 					alternatives: Dhall::UnionType.new(alternatives: {})
 				)
 			end
@@ -143,17 +195,28 @@ module Dhall
 
 			class Union
 				def initialize(values, exprs, types)
-					@values = values
+					@tags, @types = values.zip(types).map { |(value, type)|
+						if type.is_a?(UnionType) && type.alternatives.length == 1
+							type.alternatives.to_a.first
+						else
+							[AsDhall.tag_for(value), type]
+						end
+					}.transpose
 					@exprs = exprs
-					@types = types
+					@inferer = UnionInferer.new
 				end
 
 				def list
-					ut, tags = AsDhall.union_of(@values.zip(@types))
-
-					List.new(elements: @exprs.zip(tags).map do |(expr, tag)|
-						Dhall::Union.from(ut, tag, expr)
-					end)
+					final_inferer =
+						@tags
+						.zip(@exprs, @types)
+						.reduce(@inferer) do |inferer, (tag, expr, type)|
+							inferer.with(
+								tag,
+								type.nil? ? nil : TypeAnnotation.new(value: expr, type: type)
+							)
+						end
+					List.new(elements: @exprs.map(&final_inferer.method(:union_for)))
 				end
 			end
 		end
@@ -215,5 +278,11 @@ module Dhall
 				)
 			end
 		end
+
+		refine ::Proc do
+			def as_dhall
+				FunctionProxy.new(self)
+			end
+		end
 	end
 end

data/lib/dhall/ast.rb

@@ -102,6 +102,10 @@ module Dhall
 			end
 		end
 
+		def to_s
+			inspect
+		end
+
 		def as_dhall
 			self
 		end
@@ -157,7 +161,8 @@ module Dhall
 			end
 		end
 
-		def call(*args)
+		def call(*args, &block)
+			args += [block] if block
 			args.map! { |arg| arg&.as_dhall }
 			return super if args.length > 1
 
@@ -168,6 +173,29 @@ module Dhall
 		end
 
 		alias [] call
+		alias === call
+
+		def <<(other)
+			FunctionProxy.new(
+				->(*args, &block) { call(other.call(*args, &block)) },
+				curry: false
+			)
+		end
+
+		def >>(other)
+			FunctionProxy.new(
+				->(*args, &block) { other.call(call(*args, &block)) },
+				curry: false
+			)
+		end
+
+		def binding
+			to_proc.binding
+		end
+
+		def curry
+			self
+		end
 
 		def as_json
 			if var == "_"
@@ -188,6 +216,28 @@ module Dhall
 		end
 	end
 
+	class FunctionProxy < Function
+		def initialize(callable, curry: true)
+			@callable = if !curry
+				callable
+			elsif callable.respond_to?(:curry)
+				callable.curry
+			elsif callable.respond_to?(:to_proc)
+				callable.to_proc.curry
+			else
+				callable.method(:call).to_proc.curry
+			end
+		end
+
+		def call(*args, &block)
+			@callable.call(*args.map { |arg| arg&.as_dhall }, &block).as_dhall
+		end
+
+		def as_json
+			raise "Cannot serialize #{self}"
+		end
+	end
+
 	class Bool < Expression
 		include(ValueSemantics.for_attributes do
 			value Bool()
@@ -764,9 +814,22 @@ module Dhall
 
 	class UnionType < Expression
 		include(ValueSemantics.for_attributes do
-			alternatives Util::HashOf.new(::String, Either(Expression, nil))
+			alternatives Util::HashOf.new(::String, Either(Expression, nil)), default: {}
 		end)
 
+		def empty?
+			alternatives.empty?
+		end
+
+		def [](k)
+			alternatives.fetch(k)
+		end
+
+		def without(*keys)
+			keys.map!(&:to_s)
+			with(alternatives: alternatives.reject { |k, _| keys.include?(k) })
+		end
+
 		def record
 			alternatives
 		end
@@ -779,8 +842,8 @@ module Dhall
 			self == other
 		end
 
-		def merge(other)
-			with(alternatives: alternatives.merge(other.alternatives))
+		def merge(other, &block)
+			with(alternatives: alternatives.merge(other.alternatives, &block))
 		end
 
 		def fetch(k, default=nil)
@@ -817,31 +880,28 @@ module Dhall
 	class Union < Expression
 		include(ValueSemantics.for_attributes do
 			tag          ::String
-			value        Either(Expression, nil)
+			value        Expression
 			alternatives UnionType
 		end)
 
 		def self.from(alts, tag, value)
-			new(
-				tag:          tag,
-				value:        value && TypeAnnotation.new(
-					value: value,
-					type:  alts.alternatives[tag]
-				),
-				alternatives: alts.with(
-					alternatives: alts.alternatives.reject { |alt, _| alt == tag }
+			if value.nil?
+				Enum.new(tag: tag, alternatives: alts.without(tag))
+			else
+				new(
+					tag:          tag,
+					value:        TypeAnnotation.new(value: value, type: alts[tag]),
+					alternatives: alts.without(tag)
 				)
-			)
+			end
 		end
 
 		def to_s
-			value.nil? ? tag : extract.to_s
+			extract.to_s
 		end
 
 		def extract
-			if value.nil?
-				tag.to_sym
-			elsif value.is_a?(TypeAnnotation)
+			if value.is_a?(TypeAnnotation)
 				value.value
 			else
 				value
@@ -851,12 +911,8 @@ module Dhall
 		def reduce(handlers)
 			handlers = handlers.to_h
 			handler = handlers.fetch(tag.to_sym) { handlers.fetch(tag) }
-			if value.nil?
-				handler
-			else
-				(handler.respond_to?(:to_proc) ? handler.to_proc : handler)
-					.call(extract)
-			end
+			(handler.respond_to?(:to_proc) ? handler.to_proc : handler)
+				.call(extract)
 		end
 
 		def selection_syntax
@@ -869,18 +925,14 @@ module Dhall
 		end
 
 		def syntax
-			if value.nil?
-				selection_syntax
-			else
-				Application.new(
-					function: selection_syntax,
-					argument: value.is_a?(TypeAnnotation) ? value.value : value
-				)
-			end
+			Application.new(
+				function: selection_syntax,
+				argument: value.is_a?(TypeAnnotation) ? value.value : value
+			)
 		end
 
 		def as_json
-			if value.nil? || value.respond_to?(:type)
+			if value.respond_to?(:type)
 				syntax.as_json
 			else
 				[12, tag, value&.as_json, alternatives.as_json.last]
@@ -888,6 +940,31 @@ module Dhall
 		end
 	end
 
+	class Enum < Union
+		include(ValueSemantics.for_attributes do
+			tag          ::String
+			alternatives UnionType
+		end)
+
+		def reduce(handlers)
+			handlers = handlers.to_h
+			handler = handlers.fetch(tag.to_sym) { handlers.fetch(tag) }
+			handler
+		end
+
+		def to_s
+			tag
+		end
+
+		def extract
+			tag.to_sym
+		end
+
+		def as_json
+			selection_syntax.as_json
+		end
+	end
+
 	class If < Expression
 		include(ValueSemantics.for_attributes do
 			predicate Expression
@@ -1058,12 +1135,12 @@ module Dhall
 			Builtins[:Text]
 		end
 
+		def empty?
+			value.empty?
+		end
+
 		def <<(other)
-			if other.is_a?(Text)
-				with(value: value + other.value)
-			else
-				super
-			end
+			with(value: value + other.value)
 		end
 
 		def to_s
@@ -1096,6 +1173,14 @@ module Dhall
 			fixed.length == 1 ? fixed.first : new(chunks: fixed)
 		end
 
+		def start_empty?
+			chunks.first.empty?
+		end
+
+		def end_empty?
+			chunks.last.empty?
+		end
+
 		def as_json
 			[18, *chunks.map { |chunk| chunk.is_a?(Text) ? chunk.value : chunk.as_json }]
 		end
@@ -1343,24 +1428,6 @@ module Dhall
 		end
 
 		class EnvironmentVariable
-			ESCAPES = {
-				"\"" => "\"",
-				"\\" => "\\",
-				"a"  => "\a",
-				"b"  => "\b",
-				"f"  => "\f",
-				"n"  => "\n",
-				"r"  => "\r",
-				"t"  => "\t",
-				"v"  => "\v"
-			}.freeze
-
-			def self.decode(var)
-				var.gsub(/\\[\"\\abfnrtv]/) do |escape|
-					ESCAPES.fetch(escape[1])
-				end
-			end
-
 			attr_reader :var
 
 			def initialize(var)
@@ -1400,7 +1467,10 @@ module Dhall
 			end
 
 			def to_s
-				"env:#{as_json}"
+				escapes = Parser::PosixEnvironmentVariableCharacter::ESCAPES
+				"env:#{@var.gsub(/[\"\\\a\b\f\n\r\t\v]/) do |c|
+					"\\" + escapes.find { |(_, v)| v == c }.first
+				end}"
 			end
 
 			def hash
@@ -1413,9 +1483,7 @@ module Dhall
 			alias eql? ==
 
 			def as_json
-				@var.gsub(/[\"\\\a\b\f\n\r\t\v]/) do |c|
-					"\\" + ESCAPES.find { |(_, v)| v == c }.first
-				end
+				@var
 			end
 		end
 
@@ -1535,6 +1603,19 @@ module Dhall
 			body Expression
 		end)
 
+		def lets
+			[let]
+		end
+
+		def flatten
+			flattened = body.is_a?(LetIn) ? body.flatten : body
+			if flattened.is_a?(LetIn) || flattened.is_a?(LetBlock)
+				LetBlock.for(lets: [let] + flattened.lets, body: flattened.body)
+			else
+				self
+			end
+		end
+
 		def desugar
 			Application.new(
 				function: Function.new(
@@ -1572,6 +1653,10 @@ module Dhall
 			end
 		end
 
+		def flatten
+			unflatten.flatten
+		end
+
 		def unflatten
 			lets.reverse.reduce(body) do |inside, let|
 				letin = LetIn.new(let: let, body: inside)

data/lib/dhall/binary.rb

@@ -192,7 +192,6 @@ 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?
-			parts[0] = EnvironmentVariable.decode(parts[0]) if path_type == 6
 
 			new(
 				IntegrityCheck.new(*integrity_check),
@@ -223,6 +222,13 @@ module Dhall
 		end
 	end
 
+	def self.handle_tag(e)
+		return e unless e.is_a?(::CBOR::Tagged)
+		return e.value if e.tag == 55799
+
+		raise "Unknown tag: #{e.inspect}"
+	end
+
 	BINARY = {
 		::TrueClass    => ->(e) { Bool.new(value: e) },
 		::FalseClass   => ->(e) { Bool.new(value: e) },
@@ -230,6 +236,7 @@ module Dhall
 		::String       => ->(e) { Builtins[e.to_sym] || (raise "Unknown builtin") },
 		::Integer      => ->(e) { Variable.new(index: e) },
 		::Array        => lambda { |e|
+			e = e.map(&method(:handle_tag))
 			if e.length == 2 && e.first.is_a?(::String)
 				Variable.new(name: e[0], index: e[1])
 			else
@@ -238,11 +245,7 @@ module Dhall
 					(raise "Unknown expression: #{e.inspect}")
 			end
 		},
-		::CBOR::Tagged => lambda { |e|
-			return Dhall.decode(e.value) if e.tag == 55799
-
-			raise "Unknown tag: #{e.inspect}"
-		}
+		::CBOR::Tagged => ->(e) { Dhall.decode(handle_tag(e)) }
 	}.freeze
 
 	BINARY_TAGS = [

data/lib/dhall/coder.rb

@@ -117,17 +117,22 @@ module Dhall
 
 			refine Function do
 				def to_ruby(&decode)
-					->(*args) { decode[expr.call(*args)] }
+					->(*args) { decode[call(*args)] }
+				end
+			end
+
+			refine Enum do
+				def to_ruby
+					extract == :None ? nil : extract
 				end
 			end
 
 			refine Union do
 				def to_ruby
-					if !value.nil? && tag.match(/\A\p{Upper}/) &&
-					   Object.const_defined?(tag)
-						yield extract, Object.const_get(tag)
-					elsif extract == :None
-						nil
+					rtag = tag.sub(/_[0-9a-f]{64}\Z/, "")
+					if tag.match(/\A\p{Upper}/) &&
+					   Object.const_defined?(rtag) && !Dhall.const_defined?(rtag, false)
+						yield extract, Object.const_get(rtag)
 					else
 						yield extract
 					end

data/lib/dhall/normalize.rb

@@ -120,9 +120,18 @@ module Dhall
 		end
 	end
 
-	class Forall; end
+	class FunctionProxy
+		def shift(*)
+			self
+		end
+
+		def substitute(*)
+			raise "Cannot substitute #{self}"
+		end
 
-	class Bool
+		def normalize
+			self
+		end
 	end
 
 	class Variable
@@ -335,6 +344,12 @@ module Dhall
 		end
 	end
 
+	class Enum
+		def normalize
+			with(alternatives: alternatives.normalize)
+		end
+	end
+
 	class If
 		def normalize
 			normalized = super
@@ -357,7 +372,14 @@ module Dhall
 
 	class TextLiteral
 		def normalize
-			TextLiteral.for(*super.flatten.chunks)
+			lit = TextLiteral.for(*super.flatten.chunks)
+
+			if lit.is_a?(TextLiteral) && lit.chunks.length == 3 &&
+			   lit.start_empty? && lit.end_empty?
+				lit.chunks[1]
+			else
+				lit
+			end
 		end
 
 		def flatten
@@ -380,6 +402,17 @@ module Dhall
 				body: body.shift(amount, name, min_index + 1)
 			)
 		end
+
+		def substitute(svar, with_expr)
+			var = let.var
+			with(
+				let:  let.substitute(svar, with_expr),
+				body: body.substitute(
+					var == svar.name ? svar.with(index: svar.index + 1) : svar,
+					with_expr.shift(1, var, 0)
+				)
+			)
+		end
 	end
 
 	class LetBlock
@@ -390,6 +423,10 @@ module Dhall
 		def shift(amount, name, min_index)
 			unflatten.shift(amount, name, min_index)
 		end
+
+		def substitute(svar, with_expr)
+			unflatten.substitute(svar, with_expr)
+		end
 	end
 
 	class TypeAnnotation

data/lib/dhall/parser.citrus

@@ -10,10 +10,10 @@ rule block_comment
 	(/(?:\u{7b})(?:\u{2d})/i (block_comment_continue))
 end
 rule block_comment_char
-	(/[\u{20}-@\u{5b}-\u{10ffff}]/i | (tab) | (end_of_line))
+	!("{-" | "-}") (/[\u{20}-@\u{5b}-\u{10ffff}]/i | (tab) | (end_of_line))
 end
 rule block_comment_continue
-	((/(?:\u{2d})(?:\u{7d})/i) | ((block_comment) (block_comment_continue)) | ((block_comment_char) (block_comment_continue)))
+	("-}" | block_comment_char+ block_comment_continue | (block_comment block_comment_continue))
 end
 rule not_end_of_line
 	(/[\u{20}-@\u{5b}-\u{10ffff}]/i | (tab))
@@ -340,7 +340,7 @@ rule ipvfuture
 	(`v` ((hexdig)+) /\u{2e}/i (((unreserved) | (sub_delims) | `:`)+))
 end
 rule ipv6address
-	(((((h16) `:`) 6*6) (ls32)) | (`::` (((h16) `:`) 5*5) (ls32)) | (((h16)?) `::` (((h16) `:`) 4*4) (ls32)) | ((((((h16) `:`)?) (h16))?) `::` (((h16) `:`) 3*3) (ls32)) | ((((((h16) `:`) 0*2) (h16))?) `::` (((h16) `:`) 2*2) (ls32)) | ((((((h16) `:`) 0*3) (h16))?) `::` (h16) `:` (ls32)) | ((((((h16) `:`) 0*4) (h16))?) `::` (ls32)) | ((((((h16) `:`) 0*5) (h16))?) `::` (h16)) | ((((((h16) `:`) 0*6) (h16))?) `::`))
+	(((((h16) `:`) 6*6) (ls32)) | (`::` (((h16) `:`) 5*5) (ls32)) | (((h16)?) `::` (((h16) `:`) 4*4) (ls32)) | ((((h16) ((`:` (h16))?))?) `::` (((h16) `:`) 3*3) (ls32)) | ((((h16) ((`:` (h16)) 0*2))?) `::` (((h16) `:`) 2*2) (ls32)) | ((((h16) ((`:` (h16)) 0*3))?) `::` (h16) `:` (ls32)) | ((((h16) ((`:` (h16)) 0*4))?) `::` (ls32)) | ((((h16) ((`:` (h16)) 0*5))?) `::` (h16)) | ((((h16) ((`:` (h16)) 0*6))?) `::`))
 end
 rule h16
 	((hexdig) 1*4)
@@ -352,7 +352,7 @@ rule ipv4address
 	((dec_octet) /\u{2e}/i (dec_octet) /\u{2e}/i (dec_octet) /\u{2e}/i (dec_octet))
 end
 rule dec_octet
-	((digit) | (/[1-9]/i (digit)) | (`1` ((digit) 2*2)) | (/2(?:[0-4])/i (digit)) | (/25(?:[0-5])/i))
+	((/25(?:[0-5])/i) | (/2(?:[0-4])/i (digit)) | (`1` ((digit) 2*2)) | (/[1-9]/i (digit)) | (digit))
 end
 rule reg_name
 	(((unreserved) | (pct_encoded) | (sub_delims))*)

data/lib/dhall/parser.rb

@@ -276,14 +276,15 @@ module Dhall
 		module SingleQuoteLiteral
 			def value
 				chunks = capture(:single_quote_continue).value
-				indent = chunks.join.split(/\n/, -1).map { |line|
-					line.match(/^( *|\t*)/).to_s.length
-				}.min
+				raw = chunks.join
+				indent = raw.scan(/^[ \t]*(?=[^ \t\r\n])/).map(&:chars)
+				            .reduce(&Util.method(:longest_common_prefix)).length
+				indent = 0 if raw.end_with?("\n")
 
 				TextLiteral.for(
 					*chunks
-					.chunk { |c| c != "\n" }
-					.flat_map { |(line, chunk)| line ? chunk[indent..-1] : chunk }
+						.chunk { |c| c != "\n" }
+						.flat_map { |(line, chunk)| line ? chunk[indent..-1] : chunk }
 				)
 			end
 		end
@@ -558,9 +559,9 @@ module Dhall
 			def value
 				Dhall::Import::EnvironmentVariable.new(
 					if captures.key?(:bash_environment_variable)
-						capture(:bash_environment_variable).string
+						capture(:bash_environment_variable).value
 					else
-						capture(:posix_environment_variable).value.encode("utf-8")
+						capture(:posix_environment_variable).value
 					end
 				)
 			end
@@ -568,12 +569,22 @@ module Dhall
 
 		module PosixEnvironmentVariable
 			def value
-				matches.map(&:value).join
+				matches.map(&:value).join.encode(Encoding::UTF_8)
 			end
 		end
 
 		module PosixEnvironmentVariableCharacter
-			ESCAPES = Dhall::Import::EnvironmentVariable::ESCAPES
+			ESCAPES = {
+				"\"" => "\"",
+				"\\" => "\\",
+				"a"  => "\a",
+				"b"  => "\b",
+				"f"  => "\f",
+				"n"  => "\n",
+				"r"  => "\r",
+				"t"  => "\t",
+				"v"  => "\v"
+			}.freeze
 
 			def value
 				if first&.string == "\\"

data/lib/dhall/typecheck.rb

@@ -388,11 +388,11 @@ module Dhall
 				end
 
 				def element_type
-					@alist.first.value&.type || @alist.element_type
+					(@alist.first.value&.type || @alist.element_type).normalize
 				end
 
 				def element_types
-					@alist.to_a.map(&:type)
+					@alist.to_a.map(&:type).map(&:normalize)
 				end
 			end
 
@@ -604,6 +604,25 @@ module Dhall
 			end
 		end
 
+		class Enum
+			TypeChecker.register self, Dhall::Enum
+
+			def initialize(enum)
+				@enum = enum
+			end
+
+			def annotate(context)
+				type = Dhall::UnionType.new(
+					alternatives: { @enum.tag => nil }
+				).merge(@enum.alternatives)
+
+				# Annotate to sanity check
+				TypeChecker.for(type).annotate(context)
+
+				Dhall::TypeAnnotation.new(value: @enum, type: type)
+			end
+		end
+
 		class Union
 			TypeChecker.register self, Dhall::Union
 
@@ -1189,6 +1208,15 @@ module Dhall
 		class Builtin
 			TypeChecker.register self, Dhall::Builtin
 
+			def self.for(builtin)
+				unfilled = builtin.unfill
+				if unfilled != builtin
+					TypeChecker.for(unfilled)
+				else
+					new(builtin)
+				end
+			end
+
 			def initialize(builtin)
 				@expr = builtin
 				@name = builtin.as_json

data/lib/dhall/util.rb

@@ -177,5 +177,9 @@ module Dhall
 				str.encode(Encoding::UTF_8)
 			end
 		end
+
+		def self.longest_common_prefix(a, b)
+			a.zip(b).take_while { |(x, y)| x == y }.map(&:first)
+		end
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dhall
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Stephen Paul Weber
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-29 00:00:00.000000000 Z
+date: 2019-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cbor
@@ -114,6 +114,7 @@ description: 'This is a Ruby implementation of the Dhall configuration language.
 email:
 - dev@singpolyma.net
 executables:
+- dhall-compile
 - json-to-dhall
 - yaml-to-dhall
 extensions: []
@@ -121,6 +122,7 @@ extra_rdoc_files: []
 files:
 - COPYING
 - README.md
+- bin/dhall-compile
 - bin/json-to-dhall
 - bin/yaml-to-dhall
 - dhall.gemspec