dhallish 0.2.0

data/lib/types.rb

@@ -0,0 +1,440 @@
+module Dhallish
+	module Types
+		Natural = :Natural
+		Integer = :Integer
+		Double = :Double
+		Bool = :Bool
+		Text = :Text
+		class Type
+			# metadata contains information about that type, for example if
+			# its a list type. This is important for the static type checks.
+			attr_accessor :metadata
+			def initialize(metadata=nil)
+				@metadata = metadata
+			end
+
+			def ==(otype)
+				if !otype.is_a? Type
+					false
+				elsif @metadata != nil && otype.metadata != nil
+					@metadata == otype.metadata
+				else
+					true
+				end
+			end
+			def to_s()
+				if @metadata.nil? or @metadata.is_a? Unresolved
+					"Type"
+				else
+					"Type(#{@metadata.to_s})"
+				end
+			end
+		end
+		class Optional
+			# Type of Optional
+			attr_accessor :type
+			def initialize(type)
+				@type = type
+			end
+
+			def ==(otype) otype.is_a? Optional and otype.type == @type end
+			def to_s() "Optional #{@type.to_s}" end
+		end
+		class List
+			# Type of List elements
+			attr_accessor :type
+			def initialize(type)
+				@type = type
+			end
+
+			def ==(otype) otype.is_a? List and otype.type == @type end
+			def to_s() "List #{@type.to_s}" end
+		end
+		class Record
+			# Hash: keyname -> type
+			attr_accessor :types
+			def initialize(types)
+				@types = types
+			end
+
+			def ==(otype)
+				if !otype.is_a? Record or @types.size != otype.types.size
+					return false
+				end
+
+				@types.keys.reduce(true) { |isequal, key|
+					if !isequal or !(otype.types.key? key)
+						false
+					else
+						otype.types[key] == @types[key]
+					end
+				}
+			end
+
+			def to_s()
+				"{ #{@types.keys.map { |key|
+					"#{key}: #{@types[key].to_s}"
+				}.join(", ")} }"
+			end
+		end
+		class Function
+			# Type of Function that takes argtype and returns restype
+			attr_accessor :argtype
+			attr_accessor :restype
+			attr_accessor :unres
+
+			def initialize(argtype, restype, unres=nil)
+				@argtype = argtype
+				@restype = restype
+				if !unres.nil?
+					if !unres.is_a? Symbol
+						@unres = unres.to_sym
+					else
+						@unres = unres
+					end
+				else
+					@unres = nil
+				end
+			end
+
+			def ==(otype)
+				if !(otype.is_a? Function) or !(otype.argtype == @argtype)
+					false
+				elsif !@restype.nil? and !otype.restype.nil?
+					@restype == otype.restype
+				else
+					true
+				end
+			end
+
+			def to_s()
+				if !@restype.nil? and !@unres.nil?
+					"∀(#{@unres}: #{@argtype.to_s}) -> #{@restype.to_s}"
+				elsif !@restype.nil?
+					"∀(#{@argtype.to_s}) -> #{@restype.to_s}"
+				else
+					"∀(#{@argtype.to_s}) -> ?"
+				end
+			end
+		end
+		class Unresolved
+			attr_accessor :name
+			def initialize(name)
+				@name = name.to_sym
+			end
+			def ==(otype) otype.is_a? Unresolved and otype.name == @name end
+			def to_s() "#{@name}" end
+		end
+		class Union
+			# types: label -> Type
+			attr_accessor :types
+			def initialize(types)
+				@types = types
+			end
+
+			def ==(otype)
+				if !otype.is_a? Union
+					return false
+				end
+
+				@types.keys.reduce(true) { |isequal, key|
+					isequal and (otype.types.include? key and @types[key] == otype.types[key])
+				}
+			end
+
+			def to_s()
+				"< #{@types.keys.map { |key|
+					"#{key}: #{@types[key].to_s}"
+				}.join(" | ")} >"
+			end
+		end
+
+		def resolve(orgtype, name, newtype)
+			case orgtype
+			when Type
+				Type.new(resolve(orgtype.metadata, name, newtype))
+			when Unresolved
+				if name == orgtype.name
+					newtype
+				else
+					orgtype
+				end
+			when Function
+				if orgtype.restype.nil?
+					Function.new(resolve(orgtype.argtype, name, newtype), nil, orgtype.unres)
+				else
+					restype = orgtype.restype
+					argtype = orgtype.argtype
+					if orgtype.unres.nil? or orgtype.unres != name
+						restype = resolve(orgtype.restype, name, newtype)
+						argtype = resolve(orgtype.argtype, name, newtype)
+					end
+					Function.new(argtype, restype, orgtype.unres)
+				end
+			when Optional
+				Optional.new(resolve(orgtype.type, name, newtype))
+			when List
+				List.new(resolve(orgtype.type, name, newtype))
+			when Record
+				Record.new(orgtype.types.map{ |key, val| [key, resolve(val, name, newtype)] }.to_h)
+			when Union
+				Union.new(orgtype.types.map{ |key, val| [key, resolve(val, name, newtype)] }.to_h)
+			else
+				orgtype
+			end
+		end
+		module_function :resolve
+
+		def unification(a, b, mapping={})
+			case a
+			when Type
+				if b.is_a? Type
+					unification(a.metadata, b.metadata, mapping)
+				else
+					nil
+				end
+			when Unresolved
+				if b.is_a? Unresolved
+					if mapping[a.name] == nil
+						mapping[a.name] = b.name
+						mapping
+					elsif mapping[a.name] != b.name
+						nil
+					else
+						mapping
+					end
+				else
+					nil
+				end
+			when Function
+				if b.is_a? Function
+					if unification(a.argtype, b.argtype, mapping).nil?
+						nil
+					else
+						arestype = a.restype
+						brestype = b.restype
+						if !a.unres.nil?; arestype = resolve(a.restype, a.unres, Unresolved.new(get_new_sym())) end
+						if !b.unres.nil?; brestype = resolve(b.restype, b.unres, Unresolved.new(get_new_sym())) end
+						unification(arestype, brestype, mapping)
+					end
+				else
+					nil
+				end
+			when Optional
+				if b.is_a? Optional
+					unification(a.type, b.type, mapping)
+				else
+					nil
+				end
+			when List
+				if b.is_a? List
+					unification(a.type, b.type, mapping)
+				else
+					nil
+				end
+			when Record
+				if b.is_a? Record and a.types.keys.length == b.types.keys.length
+					for key in a.types.keys
+						aelm = a.types[key]
+						belm = b.types[key]
+						if belm.nil?; return nil end
+						ret = unification(aelm, belm, mapping)
+						if ret.nil?; return nil end
+					end
+					mapping
+				else
+					nil
+				end
+			when Union
+				if b.is_a? Union and a.types.keys.length == b.types.keys.length
+					for key in a.types.keys
+						aelm = a.types[key]
+						belm = b.types[key]
+						if belm.nil?; return nil end
+						ret = unification(aelm, belm, mapping)
+						if ret.nil?; return nil end
+					end
+					mapping
+				else
+					nil
+				end
+			else
+				if a == b
+					mapping
+				else
+					nil
+				end
+			end
+		end
+		module_function :unification
+
+		def not_a_type?(x)
+			if x.is_a? Symbol
+				x != Natural and x != Integer and x != Double and x != Bool and x != Text
+			else
+				!x.is_a? Optional and !x.is_a? List and !x.is_a? Record and !x.is_a? Function and !x.is_a? Unresolved and !x.is_a? Type and !x.is_a? Union
+			end
+		end
+		module_function :not_a_type?
+
+		def is_a_type?(x)
+			!not_a_type?(x)
+		end
+		module_function :is_a_type?
+
+		Numbers = [Natural, Integer, Double]
+		TextList = List.new(Text)
+		NaturalList = List.new(Natural)
+		IntegerList = List.new(Integer)
+		DoubleList = List.new(Double)
+	end
+
+	def to_json(dhallval)
+		case dhallval
+		when Integer
+			dhallval.to_s
+		when Float
+			dhallval.to_s
+		when String
+			 "\"#{escape_str(dhallval)}\""
+		when TrueClass
+			"true"
+		when FalseClass
+			"false"
+		when Array
+			"[#{ dhallval.map{ |val| to_json(val) }.join(", ") }]"
+		when Hash
+			"{#{ dhallval.map{ |key, val| "\"#{escape_str(key)}\": #{ to_json(val) }" }.join(", ") }}"
+		when nil
+			"null"
+		else
+			if Types::is_a_type? dhallval
+				"\"#{dhallval.to_s}\""
+			else
+				"\"<#{escape_str(dhallval.class.to_s)}##{dhallval.hash.abs.to_s(16)}>\""
+			end
+		end
+	end
+	module_function :to_json
+
+	# To be used as Dhallish::Value.val for dhall-defined functions
+	class Function
+		attr_accessor :argname
+		attr_accessor :ast
+		attr_accessor :ctx
+		def initialize(argname, ast, ctx)
+			@argname = argname
+			@ast = ast
+			@ctx = ctx
+		end
+
+		def call(arg)
+			newctx = Context.new ctx
+			newctx[@argname] = arg
+			@ast.evaluate newctx
+		end
+	end
+
+	class Union
+		attr_accessor :init_label
+		attr_accessor :init_val
+		attr_accessor :type
+
+		def initialize(init_label, init_val, type)
+			@init_label = init_label
+			@init_val = init_val
+			@type = type
+		end
+
+		def select(label)
+			if label == @init_label
+				@init_val
+			else
+				nil
+			end
+		end
+	end
+
+	# To be used as Dhallish::Value.val for ruby-defined functions
+	class BuiltinFunction
+		attr_accessor :block
+		def initialize(&block)
+			@block = block
+		end
+
+		def call(arg) @block.call arg end
+	end
+
+	class Context
+		def initialize(outercontext=nil)
+			@outercontext = outercontext
+			@scope = {}
+		end
+
+		def [](varname)
+			val = @scope[varname]
+			if val.nil? && !@outercontext.nil?
+				@outercontext[varname]
+			else
+				val
+			end
+		end
+
+		def []=(varname, value)
+			@scope[varname] = value
+		end
+	end
+
+	def mergeRecordTypes(a, b)
+		assert("records expected") { a.is_a? Types::Record and b.is_a? Types::Record }
+
+		merged = a.types.clone
+		b.types.each { |key, type|
+			if merged.key? key
+				if type.is_a? Types::Record and merged[key].is_a? Types::Record
+					merged[key] = mergeRecordTypes(merged[key], type)
+				else
+					raise DhallError, "key `#{key}` apeares in left and right side of `//\\\\` with different types"
+				end
+			else
+				merged[key] = type
+			end
+		}
+
+		Types::Record.new merged
+	end
+	module_function :mergeRecordTypes
+
+	# TODO: .val weg!
+	def mergeRecordsRecursively(a, b)
+		merged = a.clone
+		b.each { |key, val|
+			if merged.key? key
+				if val.is_a? Hash and merged[key].is_a? Hash
+					merged[key] = mergeRecordsRecursively(merged[key], val)
+				else
+					raise DhallError, "key `#{key}` apeares in left and right side of `/\\` (should not happen becouse of static type checks)"
+				end
+			else
+				merged[key] = val
+			end
+		}
+		merged
+	end
+	module_function :mergeRecordsRecursively
+
+	def mergeRecordTypesPrefereRight(a, b)
+		assert("expecting records for `//`") { a.is_a? Types::Record and b.is_a? Types::Record }
+		mergedTypes = a.types.clone
+		b.types.each { |key, type| mergedTypes[key] = type }
+		Types::Record.new(mergedTypes)
+	end
+	module_function :mergeRecordTypesPrefereRight
+
+	def mergeRecordsPrefereRight(a, b)
+		mergedVals = a.clone
+		b.each { |key, val| mergedVals[key] = val }
+		mergedVals
+	end
+	module_function :mergeRecordsPrefereRight
+end

data/lib/utils.rb

@@ -0,0 +1,46 @@
+
+class AssertionError < RuntimeError
+	def initialize(msg = "Help!")
+		super(msg)
+	end
+end
+
+def assert(msg, &block) raise AssertionError, msg unless yield end
+
+class DhallError < StandardError
+	def initialize(msg)
+		super(msg)
+	end
+end
+
+$dhallish_internal_global_counter = 0
+def get_new_sym()
+	$dhallish_internal_global_counter += 1
+	("__newsym_#{$dhallish_internal_global_counter}").to_sym
+end
+
+def escape_str(str)
+	str.gsub("\n", "\\n").gsub("\"", "\\\"")
+end
+
+def does_cmd_exist?(cmd)
+	ENV['PATH'].split(File::PATH_SEPARATOR).each { |path|
+		exe = File.join(path, cmd)
+		if File.executable?(exe) && !File.directory?(exe)
+			return true
+		end
+	}
+	return false
+end
+
+def resolve_map(map, from_name, to_name)
+	resmap = {}
+	map.each { |key, val|
+		reskey = key
+		resval = val
+		if reskey == from_name; reskey = to_name; end
+		if resval == from_name; resval = to_name; end
+		resmap[reskey] = resval
+	}
+	resmap
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: dhallish
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Lou Knauer <lou.knauer@fau.de>
+- Philipp Panzer <philipp.panzer@fau.de>
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-03-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: treetop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.10
+description: A Ruby Implementation of a Dhall-like Language
+email: 
+executables:
+- dhallish
+extensions: []
+extra_rdoc_files: []
+files:
+- "./bin/dhallish"
+- "./lib/DhallishGrammar.rb"
+- "./lib/DhallishGrammar.treetop"
+- "./lib/ast.rb"
+- "./lib/dhallish.rb"
+- "./lib/stdlib.rb"
+- "./lib/types.rb"
+- "./lib/utils.rb"
+- bin/dhallish
+homepage: https://gitlab.cs.fau.de/basst/ruby-dhallish
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: A Ruby Implementation of a Dhall-like Language
+test_files: []