Surprise list - Revision history

ThomasLeonard: /* Single-letter uriGetters are a special case */

ThomasLeonard — Thu, 27 Oct 2011 11:28:46 GMT

Single-letter uriGetters are a special case

New page

Potentially surprising parts of the [[E language]].

Current as of [http://www.erights.org/download/0-8-29/ E 0.8.33o].

==For-loop pattern failure is not an error==



If the key or value pattern of a <code>for</code> loop does not match, then the loop simply skips that element of the collection. This can be useful, but is unlike all other non-explicit pattern match operations (<code>def</code> and parameter lists).

===Examples===

# E sample

? def things := [1, "two", 3]
# value: [1, "two", 3]

? for x :int in things {
> println(x)
> }
# stdout: 1
# 3
#

===Alternative===

Move the pattern into a <code>def</code>:

# E sample

? for thing in things {
> def x :int := thing
> println(x)
> }
# stdout: 1
#

# problem: <ClassCastException: String doesn't coerce to an int>

The current developer version also allows strict checking to be turned on with a pragma (experimental):

# E sample
? pragma.enable("for-must-match")

? for x :int in things {
> println(x)
> }
# stdout: 1
#

# problem: <ClassCastException: String doesn't coerce to an int>

==<code>def x</code> doesn't return <var>x</var>==

The forward declaration expression, <code>def <var>var</var></code>, does not return <var>var</var> but rather the [[Resolver]] for it.

===Examples===

# E sample

? def x
# value: <Resolver>

? x
# value: <Promise>

===Rationale===

If you want to pass a resolver as an argument, using it as an “out parameter”, this syntax is helpful:

x.hereIsAResolver(def y)
<var>... use y</var>

===Alternative===

If you want the actual promise, simply write <code>(def x; x)</code>.

==Unresolved references do not necessarily behave as their future resolved identity==

— messages sent before the reference is resolved may be reacted to however the current holder of the reference “arrow-head” chooses, which does not necessarily correspond to the reference to which the unresolved reference resolves.

This has been discussed in [http://www.eros-os.org/pipermail/e-lang/2005-July/010821.html an e-lang thread].

===Rationale===

This cannot be fixed without removing [http://www.erights.org/elib/distrib/pipeline.html pipelining], eliminating one of the major benefits of the E reference model.

===Examples===

For now, see [http://www.eros-os.org/pipermail/e-lang/2005-July/010827.html this lengthy example by MarkM].

===Alternative===

To avoid being vulnerable to this type of misbehavior, do not use a sameness test (<code>==</code>) or Map key lookup in order to decide on the reliability of the response to a ''previously'' sent message. This might involve using a when-catch/whenResolved construct to wait until the reference is resolved.

==Accumulator operator is lowest-precedence==

As you can see in the following expansion, the operator following the “_” is always lowest-precedence (as it is the one effectively rewritten into an assignment form):

? e`pragma.enable("accumulator"); accum 0 while (a) { _ * b + c }`
# value: e`null
...
# accum__1 := accum__1.multiply(b.add(c))
...

===Rationale===

None known; this is probably an accident of the definition of the expansion of accumulator syntax.

===Alternative===

Avoid accumulator syntax when the accumulation cannot be expressed as a single call.

== Shadowing function arguments ==

Rebinding a name within a block is an error, e.g.

def foo() {
def x := 2
def x := 3
}

("Failed: x already in scope")

However, rebinding an argument does not issue any warning:

def foo(x) {
...
def x := 2
...
println(x)
}

=== Rationale ===

The already-in-scope error is intended to catch accidentally using the same name twice, not prohibit rebinding. Generally, you can expect it to be supressed anywhere there is visible <code>{...}</code> syntax.

== Single-letter uriGetters are a special case ==

It is not possible to refer to a single-letter uriGetter in a URI literal.

? def <t> := ["foo" => "bar"]
# value: ["foo" => "bar"]

? interp.setExpand(true)
? <t:foo>
# expansion: file__uriGetter.get("t:foo")

# value: <file:/Users/kpreid/t:foo>

===Rationale===

This is a feature intended for convenient support for Windows drive letter filenames. {{XXX|Look at whether MarkM agreed to remove it.}}

===Alternative===

Use names longer than one letter.

[[Category:E language]]

ThomasLeonard: for-must-match

ThomasLeonard — Thu, 27 Oct 2011 11:25:47 GMT

for-must-match

←Older revision		Revision as of 11:25, 27 October 2011
Line 38:		Line 38:

	# problem: <ClassCastException: String doesn't coerce to an int>		# problem: <ClassCastException: String doesn't coerce to an int>
		+
		+	The current developer version also allows strict checking to be turned on with a pragma (experimental):
		+
		+	# E sample
		+	? pragma.enable("for-must-match")
		+
		+	? for x :int in things {
		+	> println(x)
		+	> }
		+	# stdout: 1
		+	#
		+
		+	# problem: <ClassCastException: String doesn't coerce to an int>

	==<code>def x</code> doesn't return <var>x</var>==		==<code>def x</code> doesn't return <var>x</var>==

Kevin Reid: revert to last good version, hopefully right this time

Kevin Reid — Wed, 20 Apr 2011 22:51:28 GMT

revert to last good version, hopefully right this time

←Older revision		Revision as of 22:51, 20 April 2011
Line 3:		Line 3:
	Current as of [http://www.erights.org/download/0-8-29/ E 0.8.33o].		Current as of [http://www.erights.org/download/0-8-29/ E 0.8.33o].

-	~~Very true~~! ~~Makes a chagne~~ to ~~see someone spell it out like~~ that. :)	+	==For-loop pattern failure is not an error==
		+
		+	<!-- FIXME: link to erights.org for loop doc -->
		+
		+	If the key or value pattern of a <code>for</code> loop does not match, then the loop simply skips that element of the collection. This can be useful, but is unlike all other non-explicit pattern match operations (<code>def</code> and parameter lists).
		+
		+	===Examples===
		+
		+	# E sample
		+
		+	? def things := [1, "two", 3]
		+	# value: [1, "two", 3]
		+
		+	? for x :int in things {
		+	> println(x)
		+	> }
		+	# stdout: 1
		+	# 3
		+	#
		+
		+
		+	===Alternative===
		+
		+	Move the pattern into a <code>def</code>:
		+
		+	# E sample
		+
		+	? for thing in things {
		+	> def x :int := thing
		+	> println(x)
		+	> }
		+	# stdout: 1
		+	#
		+
		+	# problem: <ClassCastException: String doesn't coerce to an int>

	==<code>def x</code> doesn't return <var>x</var>==		==<code>def x</code> doesn't return <var>x</var>==

Kevin Reid: rvv

Kevin Reid — Wed, 20 Apr 2011 22:49:47 GMT

rvv

←Older revision		Revision as of 22:49, 20 April 2011
Line 3:		Line 3:
	Current as of [http://www.erights.org/download/0-8-29/ E 0.8.33o].		Current as of [http://www.erights.org/download/0-8-29/ E 0.8.33o].

-	~~==For-loop pattern failure is not an error==~~	+	Very true! Makes a chagne to see someone spell it out like that. :)
-		+
-	<!~~-- FIXME: link~~ to ~~erights.org for loop doc -->~~	+
-		+
-	~~If the key or value pattern of a <code>for</code> loop does not match, then the loop simply skips~~ that ~~element of the collection~~. ~~This can be useful, but is unlike all other non-explicit pattern match operations (<code>def</code> and parameter lists).~~	+
-		+
-	~~===Examples===~~	+
-		+
-	~~# E sample~~	+
-		+
-	~~? def things~~ :~~= [1, "two", 3]~~	+
-	~~# value: [1, "two", 3]~~	+
-		+
-	~~? for x :int in things {~~	+
-	~~> println(x~~)	+
-	~~> }~~	+
-	~~# stdout: 1~~	+
-	~~# 3~~	+
-	#	+
-		+
-		+
-	~~===Alternative===~~	+
-		+
-	~~Move the pattern into a <code>def</code>:~~	+
-		+
-	~~# E sample~~	+
-		+
-	~~? for thing in things {~~	+
-	~~> def x :int := thing~~	+
-	~~> println(x)~~	+
-	~~> }~~	+
-	~~# stdout: 1~~	+
-	#	+
-		+
-	~~# problem: <ClassCastException: String doesn't coerce to an int>~~	+

	==<code>def x</code> doesn't return <var>x</var>==		==<code>def x</code> doesn't return <var>x</var>==

Ansible: revert vandalism

Ansible — Wed, 20 Apr 2011 18:55:37 GMT

revert vandalism

←Older revision		Revision as of 18:55, 20 April 2011
Line 3:		Line 3:
	Current as of [http://www.erights.org/download/0-8-29/ E 0.8.33o].		Current as of [http://www.erights.org/download/0-8-29/ E 0.8.33o].

-	~~Very true~~! ~~Makes a chagne~~ to ~~see someone spell it out like~~ that. :)	+	==For-loop pattern failure is not an error==
		+
		+	<!-- FIXME: link to erights.org for loop doc -->
		+
		+	If the key or value pattern of a <code>for</code> loop does not match, then the loop simply skips that element of the collection. This can be useful, but is unlike all other non-explicit pattern match operations (<code>def</code> and parameter lists).
		+
		+	===Examples===
		+
		+	# E sample
		+
		+	? def things := [1, "two", 3]
		+	# value: [1, "two", 3]
		+
		+	? for x :int in things {
		+	> println(x)
		+	> }
		+	# stdout: 1
		+	# 3
		+	#
		+
		+
		+	===Alternative===
		+
		+	Move the pattern into a <code>def</code>:
		+
		+	# E sample
		+
		+	? for thing in things {
		+	> def x :int := thing
		+	> println(x)
		+	> }
		+	# stdout: 1
		+	#
		+
		+	# problem: <ClassCastException: String doesn't coerce to an int>

	==<code>def x</code> doesn't return <var>x</var>==		==<code>def x</code> doesn't return <var>x</var>==
Line 48:		Line 82:
	To avoid being vulnerable to this type of misbehavior, do not use a sameness test (<code>==</code>) or Map key lookup in order to decide on the reliability of the response to a ''previously'' sent message. This might involve using a when-catch/whenResolved construct to wait until the reference is resolved.		To avoid being vulnerable to this type of misbehavior, do not use a sameness test (<code>==</code>) or Map key lookup in order to decide on the reliability of the response to a ''previously'' sent message. This might involve using a when-catch/whenResolved construct to wait until the reference is resolved.

-	~~You've hit~~ the ~~ball out~~ the ~~park! Icnredbile!~~	+	==Accumulator operator is lowest-precedence==
		+
		+	As you can see in the following expansion, the operator following the “_” is always lowest-precedence (as it is the one effectively rewritten into an assignment form):
		+
		+	? e`pragma.enable("accumulator"); accum 0 while (a) { _ * b + c }`
		+	# value: e`null
		+	...
		+	# accum__1 := accum__1.multiply(b.add(c))
		+	...
		+
		+	===Rationale===
		+
		+	None known; this is probably an accident of the definition of the expansion of accumulator syntax.
		+
		+	===Alternative===
		+
		+	Avoid accumulator syntax when the accumulation cannot be expressed as a single call.
		+
		+

	== Shadowing function arguments ==		== Shadowing function arguments ==

83.80.80.6: /* Accumulator operator is lowest-precedence */

83.80.80.6 — Wed, 20 Apr 2011 13:36:25 GMT

Accumulator operator is lowest-precedence

←Older revision		Revision as of 13:36, 20 April 2011
Line 48:		Line 48:
	To avoid being vulnerable to this type of misbehavior, do not use a sameness test (<code>==</code>) or Map key lookup in order to decide on the reliability of the response to a ''previously'' sent message. This might involve using a when-catch/whenResolved construct to wait until the reference is resolved.		To avoid being vulnerable to this type of misbehavior, do not use a sameness test (<code>==</code>) or Map key lookup in order to decide on the reliability of the response to a ''previously'' sent message. This might involve using a when-catch/whenResolved construct to wait until the reference is resolved.

-	~~==Accumulator operator is lowest-precedence==~~	+	You've hit the ball out the park! Icnredbile!
-		+
-	~~As you can see in~~ the ~~following expansion,~~ the ~~operator following the “_” is always lowest-precedence (as it is the one effectively rewritten into an assignment form):~~	+
-		+
-	~~? e`pragma.enable("accumulator"); accum 0 while (a) { _ * b + c }`~~	+
-	~~# value: e`null~~	+
-	~~...~~	+
-	~~# accum__1 := accum__1.multiply(b.add(c))~~	+
-	~~...~~	+
-		+
-	~~NVXbEU Touchdown~~! ~~That's a really cool way of ptuitng it~~!	+
-		+
-	~~===Alternative===~~	+
-		+
-	~~Avoid accumulator syntax when the accumulation cannot be expressed as a single call.~~	+
-		+
-		+

	== Shadowing function arguments ==		== Shadowing function arguments ==

74.121.148.3: /* Rationale */

74.121.148.3 — Wed, 20 Apr 2011 07:45:28 GMT

Rationale

←Older revision		Revision as of 07:45, 20 April 2011
Line 58:		Line 58:
	...		...

-	~~===Rationale===~~	+	NVXbEU Touchdown! That's a really cool way of ptuitng it!
-		+
-	~~None known; this is probably an accident~~ of ~~the definition of the expansion of accumulator syntax.~~	+

	===Alternative===		===Alternative===

108.56.174.60: /* For-loop pattern failure is not an error */

108.56.174.60 — Wed, 20 Apr 2011 01:04:59 GMT

For-loop pattern failure is not an error

←Older revision		Revision as of 01:04, 20 April 2011
Line 3:		Line 3:
	Current as of [http://www.erights.org/download/0-8-29/ E 0.8.33o].		Current as of [http://www.erights.org/download/0-8-29/ E 0.8.33o].

-	~~==For-loop pattern failure is not an error==~~	+	Very true! Makes a chagne to see someone spell it out like that. :)
-		+
-	<!~~-- FIXME: link~~ to ~~erights.org for loop doc -->~~	+
-		+
-	~~If the key or value pattern of a <code>for</code> loop does not match, then the loop simply skips~~ that ~~element of the collection~~. ~~This can be useful, but is unlike all other non-explicit pattern match operations (<code>def</code> and parameter lists).~~	+
-		+
-	~~===Examples===~~	+
-		+
-	~~# E sample~~	+
-		+
-	~~? def things~~ :~~= [1, "two", 3]~~	+
-	~~# value: [1, "two", 3]~~	+
-		+
-	~~? for x :int in things {~~	+
-	~~> println(x~~)	+
-	~~> }~~	+
-	~~# stdout: 1~~	+
-	~~# 3~~	+
-	#	+
-		+
-		+
-	~~===Alternative===~~	+
-		+
-	~~Move the pattern into a <code>def</code>:~~	+
-		+
-	~~# E sample~~	+
-		+
-	~~? for thing in things {~~	+
-	~~> def x :int := thing~~	+
-	~~> println(x)~~	+
-	~~> }~~	+
-	~~# stdout: 1~~	+
-	#	+
-		+
-	~~# problem: <ClassCastException: String doesn't coerce to an int>~~	+

	==<code>def x</code> doesn't return <var>x</var>==		==<code>def x</code> doesn't return <var>x</var>==

Kevin Reid: s/Reason and Uses/Rationale/

Kevin Reid — Fri, 04 Feb 2011 00:04:27 GMT

s/Reason and Uses/Rationale/

←Older revision		Revision as of 00:04, 4 February 2011
Line 53:		Line 53:
	# value: <Promise>		# value: <Promise>

-	===~~Reason and Uses~~===	+	===Rationale===

-	If you want to pass a resolver as an argument, this syntax is helpful:	+	If you want to pass a resolver as an argument, using it as an “out parameter”, this syntax is helpful:

	x.hereIsAResolver(def y)		x.hereIsAResolver(def y)
Line 70:		Line 70:
	This has been discussed in [http://www.eros-os.org/pipermail/e-lang/2005-July/010821.html an e-lang thread].		This has been discussed in [http://www.eros-os.org/pipermail/e-lang/2005-July/010821.html an e-lang thread].

-	===~~Reason and Uses~~===	+	===Rationale===

	This cannot be fixed without removing [http://www.erights.org/elib/distrib/pipeline.html pipelining], eliminating one of the major benefits of the E reference model.		This cannot be fixed without removing [http://www.erights.org/elib/distrib/pipeline.html pipelining], eliminating one of the major benefits of the E reference model.
Line 92:		Line 92:
	...		...

-	===~~Reason and Uses~~===	+	===Rationale===

	None known; this is probably an accident of the definition of the expansion of accumulator syntax.		None known; this is probably an accident of the definition of the expansion of accumulator syntax.
Line 122:		Line 122:
	}		}

-	=== ~~Reason and Uses~~ ===	+	=== Rationale ===

	The already-in-scope error is intended to catch accidentally using the same name twice, not prohibit rebinding. Generally, you can expect it to be supressed anywhere there is visible <code>{...}</code> syntax.		The already-in-scope error is intended to catch accidentally using the same name twice, not prohibit rebinding. Generally, you can expect it to be supressed anywhere there is visible <code>{...}</code> syntax.
Line 139:		Line 139:
	# value: <file:/Users/kpreid/t:foo>		# value: <file:/Users/kpreid/t:foo>

-	===~~Reason and Uses~~===	+	===Rationale===

	This is a feature intended for convenient support for Windows drive letter filenames. {{XXX\|Look at whether MarkM agreed to remove it.}}		This is a feature intended for convenient support for Windows drive letter filenames. {{XXX\|Look at whether MarkM agreed to remove it.}}

Kevin Reid: add missing info about rationales

Kevin Reid — Thu, 03 Feb 2011 23:26:04 GMT

add missing info about rationales

←Older revision		Revision as of 23:26, 3 February 2011
Line 122:		Line 122:
	}		}

		+	=== Reason and Uses ===

-	== Single-letter uriGetters ~~get overridden by the parser~~ ==	+	The already-in-scope error is intended to catch accidentally using the same name twice, not prohibit rebinding. Generally, you can expect it to be supressed anywhere there is visible <code>{...}</code> syntax.
		+
		+	== Single-letter uriGetters are a special case ==
		+
		+	It is not possible to refer to a single-letter uriGetter in a URI literal.

	? def <t> := ["foo" => "bar"]		? def <t> := ["foo" => "bar"]
	# value: ["foo" => "bar"]		# value: ["foo" => "bar"]

-	? <t:foo> == "~~bar~~"	+	? interp.setExpand(true)
-	# value: ~~false~~	+	? <t:foo>
		+	# expansion: file__uriGetter.get("t:foo")
		+
		+	# value: <file:/Users/kpreid/t:foo>
		+
		+	===Reason and Uses===
		+
		+	This is a feature intended for convenient support for Windows drive letter filenames. {{XXX\|Look at whether MarkM agreed to remove it.}}
		+
		+	===Alternative===

-	~~If the variable had been called <tt> instead of <t>, the result would have been true~~.	+	Use names longer than one letter.

	[[Category:E language]]		[[Category:E language]]