Surprise list

From Erights

Revision as of 14:57, 1 February 2011 by ThomasLeonard (Talk)
Jump to: navigation, search

Potentially surprising parts of the E language.

Current as of E 0.8.33o.

Contents

For-loop pattern failure is not an error

If the key or value pattern of a for 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 (def 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 def:

 # E sample
 
 ? for thing in things {
 >     def x :int := thing
 >     println(x)
 > }
 # stdout: 1
 #         
 
 # problem: <ClassCastException: String doesn't coerce to an int>

def x doesn't return x

The forward declaration expression, def var, does not return var but rather the Resolver for it.

Examples

 # E sample
 
 ? def x
 # value: <Resolver>
 
 ? x
 # value: <Promise>

Reason and Uses

If you want to pass a resolver as an argument, this syntax is helpful:

 x.hereIsAResolver(def y)
 ... use y

Alternative

If you want the actual promise, simply write (def x; x).

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 an e-lang thread.

Reason and Uses

This cannot be fixed without removing pipelining, eliminating one of the major benefits of the E reference model.

Examples

For now, see this lengthy example by MarkM.

Alternative

To avoid being vulnerable to this type of misbehavior, do not use a sameness test (==) 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))
   ...

Reason and Uses

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)
 }


Single-letter uriGetters get overridden by the parser

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

If the variable had been called <tt> instead of <t>, the result would have been true.

Personal tools
more tools