Surprise list

From Erights

(Difference between revisions)
Jump to: navigation, search
(→Single-letter uriGetters are a special case)
(import E surprise list from my web site)
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>==
Line 66: Line 53:
   # value: &lt;Promise&gt;
   # value: &lt;Promise&gt;
-
===Rationale===
+
===Reason and Uses===
-
If you want to pass a resolver as an argument, using it as an “out parameter”, this syntax is helpful:
+
If you want to pass a resolver as an argument, this syntax is helpful:
   x.hereIsAResolver(def y)
   x.hereIsAResolver(def y)
Line 83: 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].
-
===Rationale===
+
===Reason and Uses===
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 94: Line 81:
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==
 
-
 
-
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]]
[[Category:E language]]

Revision as of 18:51, 12 June 2009

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.

Retrieved from "http://wiki.erights.org/wiki/Surprise_list"
Personal tools
more tools