dhallish 0.2.0

data/lib/ast.rb

@@ -0,0 +1,836 @@
+require_relative 'types.rb'
+require_relative 'utils.rb'
+require 'open-uri'
+
+module Dhallish
+	module Ast
+		include Dhallish
+
+		# Ast-Node for all operations that take two
+		# args of the same type and returns something of that type.
+		# `op` must be an ruby-Operator as String/Symbol
+		class BinaryArithOpNode
+			attr_accessor :lhs
+			attr_accessor :rhs
+
+			def initialize(types, lhs, rhs, op, &block)
+				@op = op
+				@types = types
+				@block = block
+				@lhs = lhs
+				@rhs = rhs
+			end
+
+			def compute_type(ctx)
+				lhs_type = @lhs.compute_type(ctx)
+				rhs_type = @rhs.compute_type(ctx)
+				assert ("Wrong Operator types for #{@op}. left: #{lhs_type}, right: #{rhs_type}") { lhs_type == rhs_type and @types.include? lhs_type }
+				lhs_type
+			end
+
+			def evaluate(ctx)
+				lhs = @lhs.evaluate ctx
+				rhs = @rhs.evaluate ctx
+				@block.call lhs, rhs
+			end
+		end
+
+		# Ast-Node that takes two Ints, Naturals, Bools or Texts and
+		# returns a Boolean
+		class ComparisonOpNode
+			attr_accessor :lhs
+			attr_accessor :rhs
+			attr_accessor :op
+
+			def initialize(lhs, rhs, op, &block)
+				@block = block
+				@op = op
+				@lhs = lhs
+				@rhs = rhs
+			end
+
+			def compute_type(ctx)
+				lhs_type, _ = @lhs.compute_type(ctx)
+				rhs_type, _ = @rhs.compute_type(ctx)
+				case @op
+				when "<", "<=" ">", ">="
+					assert ("operator \"#{@op}\" expects two numbers as operators") { (Types::Numbers + [Types::Text]).include? lhs_type }
+				when "==", "!="
+					assert ("operator \"#{@op}\" bad operator type") { (Types::Numbers + [Types::Text, Types::Bool]).include? lhs_type }
+				end
+				assert ("operator \"#{@op}\" expects two operators of same Type. left: #{lhs_type}, right: #{rhs_type}") { lhs_type == rhs_type }
+				Types::Bool
+
+			end
+
+			def evaluate(ctx)
+				lhs = @lhs.evaluate ctx
+				rhs = @rhs.evaluate ctx
+				@block.call lhs, rhs
+			end
+		end
+
+		class IfThenElseNode
+			attr_accessor :cond
+			attr_accessor :iftrue
+			attr_accessor :iffalse
+			def initialize(cond, iftrue, iffalse)
+				@cond = cond
+				@iftrue = iftrue
+				@iffalse = iffalse
+			end
+
+			def compute_type(ctx)
+				cond_type, _ = @cond.compute_type(ctx)
+				assert ("Condition in If-Then-Else-Statement not of type Bool") { cond_type == Types::Bool }
+				then_type = @iftrue.compute_type(ctx)
+				else_type = @iffalse.compute_type(ctx)
+				assert ("If-Then-Else: expressions in both branches have to be of the same type") { then_type == else_type }
+				then_type
+			end
+
+			def evaluate(ctx)
+				cond = @cond.evaluate ctx
+				if cond
+					@iftrue.evaluate ctx
+				else
+					@iffalse.evaluate ctx
+				end
+			end
+		end
+
+		class VariableNode
+			attr_accessor :varname
+			def initialize(varname)
+				@varname = varname
+			end
+
+			# returns a Type for a defined Variable @varname that does not have Type 'Type'
+			# returns a Value of Type 'Type' if @varname is a Typevariable
+			def compute_type(ctx)
+				assert ("Undefined Variable \"#{@varname}\"") { !ctx[@varname].nil? }
+				type = ctx[@varname]
+				assert ("WTF?!") { Types::is_a_type? type }
+				ctx[@varname]
+			end
+
+			def evaluate(ctx)
+				ctx[@varname]
+			end
+		end
+
+		# `parts` should be a list of ruby-strings
+		# and other ast-nodes that shall be interpolated.
+		class TextInterpolationNode
+			attr_accessor :parts
+			def initialize(parts)
+				@parts = parts
+			end
+
+			def compute_type(ctx)
+				parts.each_with_index { |part, idx|
+					assert ("TextInterpolationNode: expression at index #{idx} not a Text") { part.is_a? String or part.compute_type(ctx) == Types::Text }
+				}
+				Types::Text
+			end
+
+			def evaluate(ctx)
+				tmp = @parts.reduce("") { |str, part|
+					if part.is_a? String
+						str + part
+					else
+						val = part.evaluate ctx
+						str + val
+					end
+				}
+				tmp
+			end
+		end
+
+		# (let varname [: expected_type] = varval)+ in ...
+		# vars shall be [[varname1, expected_type1, varval1], ...]
+		# where expected_type can be nil if no type was given
+		class LetInNode
+			attr_accessor :vars
+			attr_accessor :inexpr
+			def initialize(vars, inexpr)
+				@vars = vars
+				@inexpr = inexpr
+			end
+
+			def compute_type(ctx)
+				new_ctx = Context.new ctx
+				@vars.each { |decl|
+					name, annot_type_expr, val = decl
+
+					act_type = val.compute_type(new_ctx)
+
+					if !annot_type_expr.nil?
+						type_type = annot_type_expr.compute_type(new_ctx)
+						assert ("not a type after type annotation") { type_type.is_a? Types::Type }
+						annot_type = type_type.metadata
+						unification = Types::unification(annot_type, act_type)
+						assert ("Actual type of #{name}'s value (#{act_type}) doesn't match annotated type (#{annot_type})") { !unification.nil? }
+					end
+
+					new_ctx[name] = act_type
+				}
+
+				@inexpr.compute_type new_ctx
+			end
+
+			def evaluate(ctx)
+				newctx = Context.new(ctx)
+				vars.each { |elm|
+					varname, expected_type_ast, expr = elm
+					val = expr.evaluate newctx
+					newctx[varname] = val
+				}
+				inexpr.evaluate newctx
+			end
+		end
+
+		# argname should be the name of the argument.
+		# argtype should be an Ast-Node, as does body.
+		class FunctionDefinitionNode
+			attr_accessor :argname
+			attr_accessor :body
+			def initialize(argname, argtype, body)
+				@argname = argname
+				@argtype = argtype
+				@body = body
+			end
+
+			def compute_type(ctx)
+				argtype = @argtype.compute_type ctx
+				assert("expected type as argument annotation: #{argtype}") { argtype.is_a? Types::Type }
+				argtype = argtype.metadata
+
+				unres = nil
+				if argtype.is_a? Types::Type
+					assert("DEBUG: wann passiert sowas? #{argtype.inspect}") { argtype.metadata.nil? }
+					argtype = Types::Type.new(Types::Unresolved.new(@argname))
+					unres = @argname
+				end
+
+				newctx = Context.new ctx
+				newctx[@argname] = argtype
+
+				Types::Function.new(argtype, @body.compute_type(newctx), unres)
+			end
+
+			def evaluate(ctx)
+				Function.new(@argname, @body, ctx)
+			end
+
+		end
+
+		class FunctionCallNode
+			attr_accessor :fn
+			attr_accessor :arg
+			def initialize(fn, arg)
+				@fn = fn
+				@arg = arg
+			end
+
+			def compute_type(ctx)
+				arg_type = @arg.compute_type ctx
+				fn_type = @fn.compute_type ctx
+
+				assert("only functions can be called, not #{fn_type}") { fn_type.is_a? Types::Function }
+
+				if arg_type.is_a? Types::Type and !fn_type.unres.nil?
+					assert ("argument type mismatch: expected: #{fn_type.argtype}, got: #{arg_type}") { fn_type.argtype.is_a? Types::Type }
+					Types::resolve(fn_type.restype, fn_type.unres, arg_type.metadata)
+				else
+					unification = Types::unification(fn_type.argtype, arg_type)
+					assert ("argument type mismatch: expected: #{fn_type.argtype}, got: #{arg_type}") { !unification.nil? }
+					fn_type.restype
+				end
+			end
+
+			def evaluate(ctx)
+				fn = @fn.evaluate ctx
+				arg = @arg.evaluate ctx
+				fn.call arg
+			end
+		end
+
+		class ListConcatNode
+			def initialize(lhs, rhs)
+				@lhs = lhs
+				@rhs = rhs
+			end
+
+			def compute_type(ctx)
+				lhs_type = @lhs.compute_type(ctx)
+				rhs_type = @rhs.compute_type(ctx)
+
+				assert ("List Concat: left operand not a list but #{lhs_type}") { lhs_type.is_a? Types::List }
+				assert ("List Concatenation operands type mismatch. Left: #{lhs_type}, Right: #{rhs_type}") { rhs_type == lhs_type }
+
+				lhs_type
+			end
+
+			def evaluate(ctx)
+				lhs = @lhs.evaluate(ctx)
+				rhs = @rhs.evaluate(ctx)
+				lhs + rhs
+			end
+		end
+
+		class ListNode
+			attr_accessor :list
+			attr_accessor :type_node
+
+			def initialize(list, type_node)
+				@list = list
+				@type_node = type_node
+			end
+
+			def compute_type(ctx)
+				elem_type = nil
+				if !@type_node.nil?
+					annot_type = @type_node.compute_type ctx
+					assert ("Annotated Type not a type") { annot_type.is_a? Types::Type }
+					elem_type = annot_type.metadata
+				end
+
+				if @list.length > 0
+					if !elem_type.nil?
+						assert ("First list element's type mismatches annotated type") { list[0].compute_type(ctx) == elem_type }
+					else
+						elem_type = list[0].compute_type(ctx)
+					end
+
+					@list.each_with_index { |e, idx|
+						t = e.compute_type(ctx)
+						assert ("Type mismatch: element at index #{idx} has type #{t}, expected #{elem_type}") { t == elem_type }
+					}
+				end
+
+				Types::List.new elem_type
+			end
+
+			def evaluate(ctx)
+				res = []
+				list.each { |node|
+					res.append node.evaluate(ctx)
+				}
+				res
+			end
+		end
+
+		class OptionalNode
+			# expression should be a some value for prefix "Some" or a Type for prefix "None"
+			attr_accessor :expression
+
+			def initialize(prefix, expression)
+				@isSome = (prefix == "Some")
+				@expression = expression
+			end
+
+			def compute_type(ctx)
+				if @isSome
+					elem_type = @expression.compute_type ctx
+				else
+					type_type = @expression.compute_type ctx
+					assert ("Expression after \"None\" not a type") { type_type.is_a? Types::Type }
+					elem_type = type_type.metadata
+				end
+				Types::Optional.new elem_type
+			end
+
+			def evaluate(ctx)
+				if @isSome
+					@expression.evaluate(ctx)
+				else
+					nil
+				end
+			end
+		end
+
+		class TypeAnnotationNode
+			attr_accessor :expr
+			attr_accessor :type
+			def initialize(expr, type)
+				@expr = expr
+				@type = type
+			end
+
+			def compute_type(ctx)
+				act_type = @expr.compute_type ctx
+				type_type = @type.compute_type ctx
+				assert ("Annotated expression not a type") { type_type.is_a? Types::Type }
+				exp_type = type_type.metadata
+				assert ("Expression does not match annotated type. Actual: #{act_type}, expected: #{exp_type}") { Types::unification act_type, exp_type }
+				exp_type
+			end
+
+			def evaluate(ctx)
+				@expr.evaluate ctx
+			end
+		end
+
+		# `hash` shall map Keys to Ast-Nodes
+		class RecordNode
+			attr_accessor :hash
+			def initialize(hash)
+				@hash = hash
+			end
+
+			def compute_type(ctx)
+				types = {}
+				@hash.each { |name, expr|
+					types[name] = expr.compute_type ctx
+				}
+				Types::Record.new types
+			end
+
+			def evaluate(ctx)
+				vals = {}
+				@hash.each { |key, node|
+					vals[key] = node.evaluate ctx
+				}
+				vals
+			end
+		end
+
+		class RecordTypeNode
+			attr_accessor :hash
+			def initialize(hash)
+				@hash = hash
+			end
+
+			def compute_type(ctx)
+				types = {}
+				@hash.each { |name, type_expr|
+					type_type = type_expr.compute_type ctx
+					assert ("annotated expression of record member \"#{name}\" not a type") { type_type.is_a? Types::Type }
+					types[name] = type_type.metadata
+				}
+
+				Types::Type.new(Types::Record.new types)
+			end
+
+			def evaluate(ctx)
+				types = {}
+				@hash.each { |key, node|
+					types[key] = node.evaluate ctx
+				}
+				Types::Record.new types
+			end
+		end
+
+		# rec: ast node of something that will be a record, key: name of key to access in record (string)
+		class RecordUnionSelector
+			attr_accessor :rec
+			attr_accessor :key
+			def initialize(rec, key)
+				@rec = rec
+				@key = key
+			end
+
+			def compute_type(ctx)
+				rectype = @rec.compute_type ctx
+				assert("`.` can only be used on records and unions, the key `#{@key}` must exist") {
+					((rectype.is_a? Types::Record or rectype.is_a? Types::Union) and !rectype.types[@key].nil?) \
+					or (rectype.is_a? Types::Type and rectype.metadata.is_a? Types::Union)
+				}
+				if rectype.is_a? Types::Union
+					Types::Optional.new rectype.types[@key]
+				elsif rectype.is_a? Types::Record
+					rectype.types[@key]
+				else
+					union_type = rectype.metadata
+					Types::Function.new union_type.types[@key], union_type
+				end
+			end
+
+			def evaluate(ctx)
+				rec = @rec.evaluate ctx
+				if rec.is_a? Union
+					rec.select @key
+				elsif rec.is_a? Hash  # <== Record
+					rec[@key]
+				else
+					BuiltinFunction.new { |val| Union.new @key, val, rec }
+				end
+			end
+		end
+
+		# keys: ruby-list of keys to access (strings)
+		class RecordProjection
+			attr_accessor :rec
+			attr_accessor :keys
+			def initialize(rec, keys)
+				@rec = rec
+				@keys = keys
+			end
+
+			def compute_type(ctx)
+				rectype = @rec.compute_type ctx
+				assert("`.` can only be used on records") { rectype.is_a? Types::Record }
+				newrectype = {}
+				@keys.each { |key|
+					assert("missing key in projection: `#{key}`") { !rectype.types[key].nil? }
+					newrectype[key] = rectype.types[key]
+				}
+				Types::Record.new(newrectype)
+			end
+
+			def evaluate(ctx)
+				rec = @rec.evaluate ctx
+				newrecvals = {}
+				@keys.each { |key|
+					newrecvals[key] = rec[key]
+				}
+				newrecvals
+			end
+		end
+
+		class RecordRecursiveMergeNode
+			attr_accessor :lhs
+			attr_accessor :rhs
+
+			# lhs and rhs should be RecordNodes
+			def initialize(lhs, rhs)
+				@lhs = lhs
+				@rhs = rhs
+			end
+
+			def compute_type(ctx)
+				lhs = @lhs.compute_type ctx
+				rhs = @rhs.compute_type ctx
+				::Dhallish::mergeRecordTypes(lhs, rhs)
+			end
+
+			def evaluate(ctx)
+				lhs = @lhs.evaluate(ctx)
+				rhs = @rhs.evaluate(ctx)
+				::Dhallish::mergeRecordsRecursively(lhs, rhs)
+			end
+		end
+
+		class RecordNonRecursiveMergeNode
+			attr_accessor :lhs
+			attr_accessor :rhs
+
+			# lhs and rhs should be RecordNodes
+			def initialize(lhs, rhs)
+				@lhs = lhs
+				@rhs = rhs
+			end
+
+			def compute_type(ctx)
+				lhs = @lhs.compute_type ctx
+				rhs = @rhs.compute_type ctx
+				::Dhallish::mergeRecordTypesPrefereRight(lhs, rhs)
+			end
+
+			def evaluate(ctx)
+				lhs = @lhs.evaluate(ctx)
+				rhs = @rhs.evaluate(ctx)
+				::Dhallish::mergeRecordsPrefereRight(lhs, rhs)
+			end
+		end
+
+		class RecordTypeRecursiveMergeNode
+			attr_accessor :lhs
+			attr_accessor :rhs
+
+			def initialize(lhs, rhs)
+				@lhs = lhs
+				@rhs = rhs
+			end
+
+			def compute_type(ctx)
+				lhs = @lhs.compute_type ctx
+				rhs = @rhs.compute_type ctx
+				assert("`//\\\\` can only merge record types") {
+					lhs.is_a? Types::Type and rhs.is_a? Types::Type and
+					lhs.metadata.is_a? Types::Record and rhs.metadata.is_a? Types::Record }
+				Types::Type.new(::Dhallish::mergeRecordTypes(lhs.metadata, rhs.metadata))
+			end
+
+			def evaluate(ctx)
+				lhs = @lhs.evaluate(ctx)
+				rhs = @rhs.evaluate(ctx)
+				::Dhallish::mergeRecordTypes(lhs, rhs)
+			end
+		end
+
+		class FunctionType
+			attr_accessor :lhs
+			attr_accessor :rhs
+			attr_accessor :type_var
+
+			# lhs and rhs should be values of type Type
+			# if Function Type contains "forall" , e.g. "forall(t : Type) -> Natural", type_var should contain the introduced label as a string
+			# otherwise, type_var shall be nil
+			def initialize(lhs, rhs, type_var=nil)
+				@lhs = lhs
+				@rhs = rhs
+				@type_var = type_var
+			end
+
+			def compute_type(ctx)
+				lhs_type = @lhs.compute_type ctx
+				assert ("Expression for argument type not a type") { lhs_type.is_a? Types::Type }
+				lhs_type = lhs_type.metadata
+				new_ctx = ctx
+				type_var = nil
+				if !@type_var.nil? and lhs_type.is_a? Types::Type
+					new_ctx = Context.new ctx
+					lhs_type = new_ctx[@type_var] = Types::Type.new (Types::Unresolved.new @type_var)
+					type_var = @type_var
+				end
+				rhs_type = @rhs.compute_type new_ctx
+				assert ("Expression for result type not a type") { rhs_type.is_a? Types::Type }
+				rhs_type = rhs_type.metadata
+				Types::Type.new (Types::Function.new lhs_type, rhs_type, type_var)
+			end
+
+			def evaluate(ctx)
+				lhs = @lhs.evaluate(ctx)
+
+				if !type_var.nil? and lhs.is_a? Types::Type
+					new_ctx = Context.new(ctx)
+					new_ctx[type_var] = Types::Unresolved.new(type_var)
+					rhs = @rhs.evaluate(new_ctx)
+				else
+					rhs = @rhs.evaluate(ctx)
+				end
+
+				Types::Function.new(lhs, rhs, type_var)
+			end
+		end
+
+		class Import
+			attr_accessor :prefix
+			attr_accessor :src
+			attr_accessor :import_as_text
+			attr_accessor :buf
+
+			def initialize(prefix, src, import_as_text)
+				@prefix = prefix
+				@src = src
+				@import_as_text = import_as_text
+				@buf = nil
+			end
+
+			def compute_type(ctx)
+				new_path = nil
+				text = nil
+				if prefix == "env:"
+					text = ENV[@src]
+					if text.nil?
+						raise NameError, "#{@src}: no such environment variable set"
+					end
+				else
+					src = @src
+					if prefix == "./" or prefix == "../"
+						basedir = ctx["<#DIR#>"]
+						if basedir.is_a? String
+							src = File.join basedir , (@prefix + src)
+							new_path = File.dirname src
+						else
+							opath = basedir.path
+							basedir.path = File.join basedir.path,  (@prefix + src)
+							src = basedir.to_s
+							basedir.path = File.dirname basedir.path
+							new_path = URI basedir.to_s
+							basedir.path = opath
+						end
+					elsif prefix == "~/"
+						# ruby does not expand '~'
+						src = File.join ENV['HOME'], src
+						new_path = ENV['HOME']
+					else
+						src = @prefix + src
+						new_path = URI src
+						new_path.path = File.dirname new_path.path
+					end
+
+					file = open(src)
+					text = file.read
+
+					if text.nil?
+						raise IOError, "url or file not found"
+					end
+				end
+
+				if @import_as_text
+					@buf = text
+					Types::Text
+				else
+					# treat as dhallish expression
+					@buf, type = Dhallish::evaluate(text, Dhallish::empty_context(new_path))
+					type
+				end
+			end
+
+			def evaluate(ctx) @buf end
+		end
+
+		class UnionLiteral
+			# map: label -> type, can be empty
+			attr_accessor :map
+			attr_accessor :init_label
+			attr_accessor :init_val
+			attr_accessor :type
+
+			def initialize(map, init_label, init_val)
+				@map = map
+				@init_label = init_label
+				@init_val = init_val
+			end
+
+			def compute_type(ctx)
+				types = {}
+				@map.keys.each { |key|
+					node = @map[key]
+					assert ("duplicate labels not allowed in union literals") { !types.include? key }
+					type_type = node.compute_type(ctx)
+					assert ("Type annotation in Union Literal not a type") { type_type.is_a? Types::Type }
+					@map[key] = types[key] = type_type.metadata
+				}
+				assert ("duplicate labels not allowed in union literals") { !types.include? @init_label }
+				types[@init_label] = @init_val.compute_type(ctx)
+				@type = Types::Union.new(types)
+				@type
+			end
+
+			def evaluate(ctx)
+				Union.new @init_label, @init_val.evaluate(ctx), @type
+			end
+		end
+
+		class UnionType
+			# map: maps labels to ast-nodes that should be types
+			attr_accessor :map
+
+			def initialize(map)
+				@map = map
+			end
+
+			def compute_type(ctx)
+				types_map = {}
+				@map.each { |key, type|
+					assert ("Duplicate labels in Union Types are not allowed") { !types_map.include? key }
+					type_type = type.compute_type ctx
+					assert ("annotated type in union type not a type") { type_type.is_a? Types::Type }
+					types_map[key] = type_type.metadata
+				}
+				Types::Type.new(Types::Union.new types_map)
+			end
+
+			def evaluate(ctx)
+				res = {}
+				@map.each { |key, node|
+					res[key] = node.evaluate ctx
+				}
+				Types::Union.new(res)
+			end
+		end
+
+		class UnionMerge
+			attr_accessor :handler
+			attr_accessor :union
+			def initialize(handler, union)
+				@handler = handler
+				@union = union
+			end
+
+			def compute_type(ctx)
+				hdlr = @handler.compute_type ctx
+				unin = @union.compute_type ctx
+
+				assert("`merge` expects a record as first and a union as second argument (both with the same keys and they shall not be empty)") {
+					hdlr.is_a? Types::Record and unin.is_a? Types::Union and hdlr.types.size == unin.types.size and hdlr.types.size > 0
+				}
+				rettype = nil
+				hdlr.types.each { |key, fntype|
+					argtype = unin.types[key]
+					assert("`merge` record (of functions) and union must have the same fields") { !argtype.nil? and fntype.is_a? Types::Function }
+					if rettype.nil?
+						rettype = fntype.restype
+					else
+						# TODO: unification instead of ==
+						assert("`merge` functions must all have the same return type") { fntype.restype == rettype }
+					end
+					assert("`merge` functions must take as argument the type of its union field") { fntype.argtype == argtype }
+				}
+				rettype
+			end
+
+			def evaluate(ctx)
+				hdlr = @handler.evaluate ctx
+				unin = @union.evaluate ctx
+				fn = hdlr[unin.init_label]
+				fn.call(unin.init_val)
+			end
+		end
+
+		class Import_Alternative
+			attr_accessor :lhs
+			attr_accessor :rhs
+
+			def initialize(lhs, rhs)
+				@lhs = lhs
+				@rhs = rhs
+				@lhs_succeded = false
+			end
+
+			def compute_type(ctx)
+				begin
+					type = @lhs.compute_type ctx
+					@lhs_succeded = true
+					type
+				rescue AssertionError, DhallError => e
+					raise e
+				rescue
+					@rhs.compute_type ctx
+				end
+			end
+
+			def evaluate(ctx)
+				if @lhs_succeded
+					@lhs.evaluate ctx
+				else
+					@rhs.evaluate ctx
+				end
+			end
+		end
+
+		class Literal_Node
+			attr_accessor :val
+			attr_accessor :type
+
+			def initialize(val, type)
+				@val = val
+				@type = type
+			end
+
+			def compute_type(ctx)
+				@type
+			end
+
+			def evaluate(ctx)
+				@val
+			end
+		end
+
+		class GetContext
+			def initialize() @typectx = nil end
+
+			def compute_type(ctx)
+				@typectx = ctx
+				Types::Record.new({})
+			end
+
+			def evaluate(ctx) { "<#TYPES#>" => @typectx, "<#VALS#>" => ctx } end
+		end
+
+	end
+end