POLA fetch - Revision history

Kevin Reid: whoops, inconsistent links

Kevin Reid — Mon, 11 Aug 2008 17:15:07 GMT

whoops, inconsistent links

New page

to fetch(<var>key</var>, <var>absentThunk</var>)

The <code>fetch/2</code> protocol for [[collection]]s does not obey [[POLA]]:

* The collection gets access to the value of <var>absentThunk</var>.
* The collection may invoke <var>absentThunk</var> and yet return something else.
* The collection may invoke <var>absentThunk</var> more than once, or after fetch returns.

== Proposals ==

* Make the second argument usually an ejector. Ejectors do not return values and are robust against being invoked multiple times; if some other sort of object is being used, its author is more likely to consider the multiple invocation issue. If we do this, then utilities should be provided for default-value behavior. --[[User:Kevin Reid|Kevin Reid]] 11:25, 12 April 2008 (CDT)

== Scribbles ==

# Current example (ensuring [[FlexMap]] entry, has the POLA problem discussed here)
def value := map.[[:Category:Message fetch/2|fetch]](key, fn {
map[key] := makeValue()
})

# works with existing fetch implementations
def value := [[escape]] e {
map.[[:Category:Message fetch/2|fetch]](key, e)
} catch _ {
map[key] := makeValue()
}

# return-value-distinguishing #1
def value := switch (map.fetch(key)) {
match [value] { value }
match [] { map[key] := makeValue() }
}

# return-value-distinguishing #2, using call-patterns and Haskell-style Maybe
def value := switch (map.fetch(key)) {
match just(value) { value }
match nothing() { map[key] := makeValue() }
}

[[Category:Unresolved design issues]]
[[Category:Message fetch/2]]
[[Category:Message fetch/1]]

Kevin Reid: publishing scribbles sitting on my disk

Kevin Reid — Mon, 11 Aug 2008 17:13:28 GMT

publishing scribbles sitting on my disk

←Older revision		Revision as of 17:13, 11 August 2008
Line 10:		Line 10:

	* Make the second argument usually an ejector. Ejectors do not return values and are robust against being invoked multiple times; if some other sort of object is being used, its author is more likely to consider the multiple invocation issue. If we do this, then utilities should be provided for default-value behavior. --[[User:Kevin Reid\|Kevin Reid]] 11:25, 12 April 2008 (CDT)		* Make the second argument usually an ejector. Ejectors do not return values and are robust against being invoked multiple times; if some other sort of object is being used, its author is more likely to consider the multiple invocation issue. If we do this, then utilities should be provided for default-value behavior. --[[User:Kevin Reid\|Kevin Reid]] 11:25, 12 April 2008 (CDT)
		+
		+	== Scribbles ==
		+
		+	# Current example (ensuring [[FlexMap]] entry, has the POLA problem discussed here)
		+	def value := map.[[:Category:Message fetch/2\|fetch]](key, fn {
		+	map[key] := makeValue()
		+	})
		+
		+	# works with existing fetch implementations
		+	def value := [[escape]] e {
		+	map.[[Message fetch/2\|fetch]](key, e)
		+	} catch _ {
		+	map[key] := makeValue()
		+	}
		+
		+	# return-value-distinguishing #1
		+	def value := switch (map.fetch(key)) {
		+	match [value] { value }
		+	match [] { map[key] := makeValue() }
		+	}
		+
		+	# return-value-distinguishing #2, using call-patterns and Haskell-style Maybe
		+	def value := switch (map.fetch(key)) {
		+	match just(value) { value }
		+	match nothing() { map[key] := makeValue() }
		+	}

	[[Category:Unresolved design issues]]		[[Category:Unresolved design issues]]
		+	[[Category:Message fetch/2]]
		+	[[Category:Message fetch/1]]

Kevin Reid: /* Proposals */ note need to provide default-value behavior

Kevin Reid — Sat, 12 Apr 2008 16:35:46 GMT

Proposals: note need to provide default-value behavior

←Older revision		Revision as of 16:35, 12 April 2008
Line 9:		Line 9:
	== Proposals ==		== Proposals ==

-	* Make the second argument usually an ejector. Ejectors do not return values and are robust against being invoked multiple times; if some other sort of object is being used, its author is more likely to consider the multiple invocation issue. --[[User:Kevin Reid\|Kevin Reid]] 11:25, 12 April 2008 (CDT)	+	* Make the second argument usually an ejector. Ejectors do not return values and are robust against being invoked multiple times; if some other sort of object is being used, its author is more likely to consider the multiple invocation issue. If we do this, then utilities should be provided for default-value behavior. --[[User:Kevin Reid\|Kevin Reid]] 11:25, 12 April 2008 (CDT)

	[[Category:Unresolved design issues]]		[[Category:Unresolved design issues]]

Kevin Reid at 16:25, 12 April 2008

Kevin Reid — Sat, 12 Apr 2008 16:25:03 GMT

←Older revision		Revision as of 16:25, 12 April 2008
Line 9:		Line 9:
	== Proposals ==		== Proposals ==

-	* Make the second argument usually an ejector. Ejectors do not return values and are robust against being invoked multiple times; if some other sort of object is being used, its author is more likely to consider the multiple invocation issue~~. If we do this, then utilities should be provided for default-value behavior~~. --[[User:Kevin Reid\|Kevin Reid]] 11:25, 12 April 2008 (CDT)	+	* Make the second argument usually an ejector. Ejectors do not return values and are robust against being invoked multiple times; if some other sort of object is being used, its author is more likely to consider the multiple invocation issue. --[[User:Kevin Reid\|Kevin Reid]] 11:25, 12 April 2008 (CDT)
-		+
-	~~== Scribbles ==~~	+
-		+
-	~~# Current example (ensuring [[FlexMap]] entry, has the POLA problem discussed here)~~	+
-	~~def value := map.[[:Category:Message fetch/2\|fetch]](key, fn {~~	+
-	~~map[key] := makeValue()~~	+
-	})	+
-		+
-	~~# works with existing fetch implementations~~	+
-	~~def value := [[escape]] e {~~	+
-	~~map.[[:Category:Message fetch/2\|fetch]](key, e)~~	+
-	~~} catch _ {~~	+
-	~~map[key] := makeValue()~~	+
-	}	+
-		+
-	~~# return-value-distinguishing #1~~	+
-	~~def value := switch (map.fetch(key)) {~~	+
-	~~match [value] { value }~~	+
-	~~match [] { map[key] := makeValue() }~~	+
-	}	+
-		+
-	~~# return-value-distinguishing #2, using call-patterns and Haskell-style Maybe~~	+
-	~~def value := switch (map.fetch(key)) {~~	+
-	~~match just(value) { value }~~	+
-	~~match nothing() { map[key] := makeValue() }~~	+
-	}	+

	[[Category:Unresolved design issues]]		[[Category:Unresolved design issues]]
-	~~[[Category:Message fetch/2]]~~
-	~~[[Category:Message fetch/1]]~~