Module: Dhall

Defined in:
lib/dhall.rb,
lib/dhall/ast.rb,
lib/dhall/util.rb,
lib/dhall/coder.rb,
lib/dhall/types.rb,
lib/dhall/binary.rb,
lib/dhall/parser.rb,
lib/dhall/resolve.rb,
lib/dhall/as_dhall.rb,
lib/dhall/builtins.rb,
lib/dhall/normalize.rb,
lib/dhall/typecheck.rb

Defined Under Namespace

Modules: AsDhall, Builtins, Parser, Resolvers, TypeChecker, Types, Util Classes: Application, Assertion, Bool, Builtin, BuiltinFunction, Coder, Double, EmptyList, EmptyRecord, EmptyRecordProjection, EmptyRecordType, Enum, Expression, ExpressionResolver, ExpressionVisitor, Forall, Function, FunctionProxy, FunctionProxyRaw, If, Import, ImportBannedException, ImportFailedException, ImportLoopException, Integer, Let, LetBlock, LetIn, List, Merge, Natural, Operator, Optional, OptionalNone, Record, RecordProjection, RecordProjectionByExpression, RecordSelection, RecordType, RubyObjectRaw, Text, TextLiteral, TimeoutException, ToMap, TypeAnnotation, Union, UnionType, Variable

Constant Summary collapse

BINARY = 
{
	::TrueClass    => ->(e) { Bool.new(value: e) },
	::FalseClass   => ->(e) { Bool.new(value: e) },
	::Float        => ->(e) { Double.new(value: e) },
	::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
			tag, *body = e
			BINARY_TAGS[tag]&.decode(*body) ||
				(raise "Unknown expression: #{e.inspect}")
		end
	},
	::CBOR::Tagged => ->(e) { Dhall.decode(handle_tag(e)) }
}.freeze
BINARY_TAGS = 
[
	Application,
	Function,
	Forall,
	Operator,
	List,
	Optional,
	Merge,
	RecordType,
	Record,
	RecordSelection,
	RecordProjection,
	UnionType,
	Union,
	nil,
	If,
	Natural,
	Integer,
	nil,
	TextLiteral,
	Assertion,
	nil,
	nil,
	nil,
	nil,
	Import,
	LetIn,
	TypeAnnotation,
	ToMap,
	EmptyList
].freeze

Class Method Summary collapse

Class Method Details

.decode(expression) ⇒ Object 



16
17
18
19
20
21
22
 
# File 'lib/dhall/binary.rb', line 16

def self.decode(expression)
	BINARY.each do |match, use|
		return use[expression] if expression.is_a?(match)
	end

	raise "Unknown expression: #{expression.inspect}"
end

.dump(o) ⇒ Object 



46
47
48
 
# File 'lib/dhall.rb', line 46

def self.dump(o)
	CBOR.encode(o.as_dhall)
end

.from_binary(cbor_binary) ⇒ Object 



12
13
14
 
# File 'lib/dhall/binary.rb', line 12

def self.from_binary(cbor_binary)
	decode(CBOR.decode(cbor_binary))
end

.handle_tag(e) ⇒ Object 



298
299
300
301
302
303
 
# File 'lib/dhall/binary.rb', line 298

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

.load(source, resolver: Resolvers::Default.new, timeout: 10) ⇒ Object 



17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
# File 'lib/dhall.rb', line 17

def self.load(
	source,
	resolver: Resolvers::Default.new,
	timeout: 10
)
	deadline = Util::Deadline.for_timeout(timeout)
	Promise.resolve(nil).then {
		load_raw(source.to_s, timeout: timeout).resolve(
			resolver: resolver.with_deadline(deadline)
		)
	}.then do |resolved|
		deadline.timeout_block do
			TypeChecker.for(resolved).annotate(TypeChecker::Context.new).normalize
		end
	end
end

.load_raw(source, timeout: 10) ⇒ Object 



34
35
36
37
38
39
40
41
42
43
44
 
# File 'lib/dhall.rb', line 34

def self.load_raw(source, timeout: 10)
	source = Util.text_or_binary(source)

	Util::Deadline.for_timeout(timeout).timeout_block do
		if source.encoding == Encoding::BINARY
			from_binary(source)
		else
			Parser.parse(source).value
		end
	end
end