Re: Re: exchanging 2 elements in a list (problem with Block)
- To: mathgroup at smc.vnet.net
- Subject: [mg27790] Re: [mg27631] Re: exchanging 2 elements in a list (problem with Block)
- From: "Allan Hayes" <hay at haystack.demon.co.uk>
- Date: Fri, 16 Mar 2001 04:37:44 -0500 (EST)
- References: <933FF20B19D8D411A3AB0006295069B0286951@dassne02.darmstadt.dsh.de> <3AAF97B7.8494FB81@cs.berkeley.edu>
- Sender: owner-wri-mathgroup at wolfram.com
Richard, Helmut,
A few remarks:
USES OF BLOCK WHERE MODULE DOES NOT WORK
(all except 4 use only the ability of Block to temporarily set aside
definitons - only 4 introduces a temporary definition)
1 ---------------
i=j;
Table[i^j, {j,3}]
{1, 4, 27}
Module[{i},Table[i^j, {j,3}]]
{i$1049, i$1049^2, i$1049^3}
Block[{i},Table[i^j, {j,3}]]
{j, j^2, j^3}
2 ------------
Block[{Dot},Sort/@({q,p}.{x,y})]
p*x + q*y
3 ------------
Thread[Length[{{1,2,3},{4,5}}]]
Thread::normal: Nonatomic expression expected at position 1 in
Thread[2].
Thread[2]
Block[{Length}, Thread[Length[{{1,2,3},{4,5}}]]]
{3, 2}
4 -------------
Block[{$DisplayFunction = Identity},
Plot[Sin[x],{x,0,2Pi}]
]
Show[%]
5 -----------
x=1;
Module[{x},Integrate[x^2,x]]
x$3^3/3
Block[{x},Integrate[x^2,x]]
1/3
BAD USE OF MODULE
$ModuleNumber= 1;
Module[{x=a}, x +x$1]
2*a
BAD USE OF FUNCTION
Function[y,Function[x,x+y]][x$]
Function[x$, x$ + x$]
NOTES
-- In general don't directly introduce symbols like x$, x$123 -- leave this
to Mathematica
-- Be careful whenever users or evaluation can introduce the symbols over
which you have no control - this was the problem with the original example
of the undesirable behaviour of Block
-- We get some protection from interactions amongse scoping constructs,
Module, With, Function, Passing using named patterns (n:pattern) ... but
beware
**** Nothing can protect us from the consequences of replacement rules
except care ****
Clear[x,y]
Function[x, Function[x, x+y]][y]
Function[x, x + y]
Function[y, Function[x, x+y]][x]
Function[x$, x$ + 1]
But
Function[x, x+y] /.x->y
Function[y, y + y]
Function[x, x+y] /.y->x
Function[x, x + x]
Allan
---------------------
Allan Hayes
Mathematica Training and Consulting
Leicester UK
www.haystack.demon.co.uk
hay at haystack.demon.co.uk
Voice: +44 (0)116 271 4198
Fax: +44 (0)870 164 0565
----- Original Message -----
From: "Richard Fateman" <fateman at cs.berkeley.edu>
To: mathgroup at smc.vnet.net
Subject: [mg27790] Re: [mg27631] Re: exchanging 2 elements in a list (problem with
Block)
"Wolf, Hartmut" wrote:
>
> Dear Allan,
>
> you'r right, a general problem with, not of, Block. Block indeed does
exacly
> what it is supposed to do.
To declare a bug to be a feature is not to eliminate it. Most people
who use Block, do so at the risk of exactly the problem pointed out.
Module was created (also in a hackish way that can be broken if
you use variables like x$$4, I think), to provide a better but
still broken version of programming language scope in Mathematica.
>
> This kind of problems is shared e.g. by all early Lisp dialects having
been
> discussed extensively, and being the reason for generally converting to
> lexical scoping.
Early lisps had dynamic scope by default in interpreted code. Dynamic
scope is not, in my view, a bug. In fact, the ANSI standard common
lisp provides facilities for having dynamic scope (defvar, special
variable declarations). This is
not the same as the Mathematica Block bug, which so far as I can tell
has
no use and should be eliminated from the language. If there is a
legitimate
example in which the semantics of Block (rather than the semantics of
Module) make sense, I would be interested in learning it.
> That it is present at all in Mathematica presumably has
> historical reasons.
Um, it was there before Module, certainly. That it is STILL there
I don't know.
> However it also has certain advantages, and I'm happy to
> have it at my disposal.
Can you name one? I can defend it only indirectly, in that Module
is ALSO done wrong, and you have a choice of the bugs/inefficiency in
Module
or the gross bug in Block. If Module were done as in lambda-binding,
in Lisp then I can't think of a reason.
> We have to be wary however, and routinely better use
> Module. So a first thought when seeing a Block might be: "will it work
with
> Module?"
Yep. I agree 100%
>
> A method to make Block work with Swap1 (not seriously meant for this case)
> is to restrict evaluation to where it is needed:
>
>
> In[18]:= Clear[s]
> In[19]:= lazySwap[m_,i_,j_] :=
> Evaluate /@ Block[{s = Unevaluated /@ m},
> s[[{i, j}]] = s[[{j, i}]];
> s]
>
> In[20]:= lazySwap[{a, s},1,2]
> Out[20]= {s,a}
>
> Finally a note I would like to add to Richard's problem (after all has
been
> said by you and Jens-Peer Kuska, to mention). His pitfall is common to all
> having been absent from Mathematica for a while, and extensively
programming
> in C or a similiar language, then misconstruing a definition in Mathemtica
> for a "function procedure". A definition is a term rewrite rule, and there
> is no such thing as a "formal parameter" (with the meaning of a storage
> location behind).
> Pure lambda calculus wouldn't rise the idea, and Mathematica comes closer
to
> that than to C.
Unfortunately, the Mathematica book assists in this "thought crime" of
viewing
rules as function definitions.
>
> How to approach call by reference semantics has been shown by Jens-Peer
and
> David B. Wagner in his Book "Power Programming with Mathematica, the
Kernel"
>
> http://www.amazon.com/exec/obidos/ASIN/007912237X
> devotes all of §4.4 "Parameter-Passing Semantics" (of chapter 4
"Procedural
> Programming") to the theme.
Thanks for the reference.
RJF
>
> With kind regards, yours
> Hartmut
>