Module: Dhall

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

Defined Under Namespace

Modules: AsDhall, Builtins, ExpressionVisitor, Parser, Resolvers, TypeChecker, Util Classes: Application, Bool, Builtin, Double, EmptyList, EmptyRecord, EmptyRecordProjection, EmptyRecordType, Expression, ExpressionResolver, Forall, Function, If, Import, ImportBannedException, ImportFailedException, ImportLoopException, Integer, Let, LetBlock, LetIn, List, Merge, Natural, Number, Operator, Optional, OptionalNone, Record, RecordProjection, RecordSelection, RecordType, Text, TextLiteral, TypeAnnotation, Union, UnionType, Variable, Visitor

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::ALL[e]&.new || Variable.new(name: e) },
  ::Integer      => ->(e) { Variable.new(index: e) },
  ::Array        => lambda { |e|
    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 => lambda { |e|
    return Dhall.decode(e.value) if e.tag == 55799

    raise "Unknown tag: #{e.inspect}"
  }
}.freeze
BINARY_TAGS = 
[
  Application,
  Function,
  Forall,
  Operator,
  List,
  Optional,
  Merge,
  RecordType,
  Record,
  RecordSelection,
  RecordProjection,
  UnionType,
  Union,
  nil,
  If,
  Natural,
  Integer,
  nil,
  TextLiteral,
  nil,
  nil,
  nil,
  nil,
  nil,
  Import,
  LetBlock,
  TypeAnnotation
].freeze

Class Method Summary collapse

Class Method Details

.decode(expression) ⇒ Object 



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

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 



34
35
36
 
# File 'lib/dhall.rb', line 34

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

.from_binary(cbor_binary) ⇒ Object 



10
11
12
 
# File 'lib/dhall/binary.rb', line 10

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

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



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

def self.load(source, resolver: Resolvers::Default.new)
  Promise.resolve(nil).then {
    load_raw(source).resolve(resolver: resolver)
  }.then do |resolved|
    TypeChecker.for(resolved).annotate(TypeChecker::Context.new).normalize
  end
end

.load_raw(source) ⇒ Object 



23
24
25
26
27
28
29
30
31
32
 
# File 'lib/dhall.rb', line 23

def self.load_raw(source)
  begin
    return from_binary(source) if source.encoding == Encoding::BINARY
  rescue Exception # rubocop:disable Lint/RescueException
    # Parsing CBOR failed, so guess this is source text in standard UTF-8
    return load_raw(source.force_encoding("UTF-8"))
  end

  Parser.parse(source.encode("UTF-8")).value
end