Class: Dhall::Function

Inherits:
Expression show all
Defined in:
lib/dhall/ast.rb,
lib/dhall/binary.rb,
lib/dhall/normalize.rb

Direct Known Subclasses

Forall, FunctionProxyRaw

Constant Summary collapse

@@alpha_normalization = 
true

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Expression

#&, #*, #+, #annotate, #as_dhall, #cache_key, #concat, #deep_merge, #deep_merge_type, #dhall_eq, #digest, #fetch, #fusion, #merge, #resolve, #slice, #to_binary, #to_cbor, #to_proc, #to_s, #|

Class Method Details

.decode(var_or_type, type_or_body, body_or_nil = nil) ⇒ Object 



63
64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/dhall/binary.rb', line 63

def self.decode(var_or_type, type_or_body, body_or_nil=nil)
	type_or_body = Dhall.decode(type_or_body)

	if body_or_nil.nil?
		of_arguments(Dhall.decode(var_or_type), body: type_or_body)
	else
		raise ArgumentError, "explicit var named _" if var_or_type == "_"

		body_or_nil = Dhall.decode(body_or_nil)
		new(var: var_or_type, type: type_or_body, body: body_or_nil)
	end
end

.disable_alpha_normalization! ⇒ Object 



87
88
89
 
# File 'lib/dhall/normalize.rb', line 87

def self.disable_alpha_normalization!
	@@alpha_normalization = false
end

.enable_alpha_normalization! ⇒ Object 



91
92
93
 
# File 'lib/dhall/normalize.rb', line 91

def self.enable_alpha_normalization!
	@@alpha_normalization = true
end

.of_arguments(*types, body:) ⇒ Object 



160
161
162
163
164
165
166
167
168
 
# File 'lib/dhall/ast.rb', line 160

def self.of_arguments(*types, body:)
	types.reverse.reduce(body) do |inner, type|
		new(
			var:  "_",
			type: type,
			body: inner
		)
	end
end

Instance Method Details

#<<(other) ⇒ Object 



184
185
186
187
188
189
 
# File 'lib/dhall/ast.rb', line 184

def <<(other)
	FunctionProxy.new(
		->(*args, &block) { call(other.call(*args, &block)) },
		curry: false
	)
end

#>>(other) ⇒ Object 



191
192
193
194
195
196
 
# File 'lib/dhall/ast.rb', line 191

def >>(other)
	FunctionProxy.new(
		->(*args, &block) { other.call(call(*args, &block)) },
		curry: false
	)
end

#as_json ⇒ Object 



206
207
208
209
210
211
212
 
# File 'lib/dhall/ast.rb', line 206

def as_json
	if var == "_"
		[1, type.as_json, body.as_json]
	else
		[1, var, type.as_json, body.as_json]
	end
end

#binding ⇒ Object 



198
199
200
 
# File 'lib/dhall/ast.rb', line 198

def binding
	to_proc.binding
end

#call(*args, &block) ⇒ Object Also known as: [], === 



170
171
172
173
174
175
176
177
178
179
 
# File 'lib/dhall/ast.rb', line 170

def call(*args, &block)
	args += [block] if block
	args.map! { |arg| arg&.as_dhall }
	return super if args.length > 1

	body.substitute(
		Variable.new(name: var),
		args.first.shift(1, var, 0)
	).shift(-1, var, 0).normalize
end

#curry ⇒ Object 



202
203
204
 
# File 'lib/dhall/ast.rb', line 202

def curry
	self
end

#normalize ⇒ Object 



114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'lib/dhall/normalize.rb', line 114

def normalize
	return super unless alpha_normalize?
	with(
		var:  "_",
		type: type&.normalize,
		body: body
		      .shift(1, "_", 0)
		      .substitute(Variable[var], Variable["_"])
		      .shift(-1, var, 0)
		      .normalize
	)
end

#shift(amount, name, min_index) ⇒ Object 



95
96
97
98
99
100
101
102
 
# File 'lib/dhall/normalize.rb', line 95

def shift(amount, name, min_index)
	return super unless var == name

	with(
		type: type.shift(amount, name, min_index),
		body: body.shift(amount, name, min_index + 1)
	)
end

#substitute(svar, with_expr) ⇒ Object 



104
105
106
107
108
109
110
111
112
 
# File 'lib/dhall/normalize.rb', line 104

def substitute(svar, with_expr)
	with(
		type: type&.substitute(svar, with_expr),
		body: body.substitute(
			var == svar.name ? svar.with(index: svar.index + 1) : svar,
			with_expr.shift(1, var, 0)
		)
	)
end