Class: Dhall::AsDhall::UnionInferer

Inherits:
Object
  • Object
show all
Defined in:
lib/dhall/as_dhall.rb

Instance Method Summary collapse

Constructor Details

#initialize(tagged = {}) ⇒ UnionInferer

Returns a new instance of UnionInferer.



52
53
54
 
# File 'lib/dhall/as_dhall.rb', line 52

def initialize(tagged={})
	@tagged = tagged
end

Instance Method Details

#disambiguate_against(tag, anno) ⇒ Object 



80
81
82
83
84
85
86
87
 
# File 'lib/dhall/as_dhall.rb', line 80

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

#union_for(expr) ⇒ Object 



60
61
62
63
64
65
66
67
68
69
 
# File 'lib/dhall/as_dhall.rb', line 60

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

#union_type ⇒ Object 



56
57
58
 
# File 'lib/dhall/as_dhall.rb', line 56

def union_type
	UnionType.new(alternatives: Hash[@tagged.map { |k, v| [k, v.type] }])
end

#with(tag, type_annotation) ⇒ Object 



71
72
73
74
75
76
77
78
 
# File 'lib/dhall/as_dhall.rb', line 71

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