Re: How to delay action of ...[[i]] (Part[...,i])

*To*: mathgroup at smc.vnet.net*Subject*: [mg112307] Re: How to delay action of ...[[i]] (Part[...,i])*From*: Leonid Shifrin <lshifr at gmail.com>*Date*: Wed, 8 Sep 2010 01:00:43 -0400 (EDT)

On Tue, Sep 7, 2010 at 9:59 AM, Greylander <greylander at gmail.com> wrote: > I have answered my own question! And understand a bit more how to > 'think' in Mathematica... > > The problem is that Part[[]] acts on any expression. What I have > finally figured out is that I need a version of part (or a version of > [[...]]) that acts *only* on lists (i.e. expressions with "List" > head), and searching and exploring the documentation, I eventually > learned how to do that. This will have exactly the desired result. > > Here is what I did: > > VPart[expr_List,k_] :=Part[expr,k] > > And I also define subscripting in an expression to invoke VPart[]: > > expr_List[Ctrl+-]k_ :=VPart[expr,k] > > Above the [Ctrl+-] means literally press the Ctrl key and the - > (minus) key, so that "k_" will then be a subscript. > > Now I have one remaining question: why is there not something like > this already defined in the core of Mathematica? It seems obvious (to > me) that one would want a version of Part[] (element selection) > restricted to List expressions only. > To my mind, the kernel should contain either functionality which is not easily reproduced with top-level Mathematica code (either because of efficiency or because the rest of the language is not sufficient to reproduce the feature in a satisfactory way), or functions which are so frequently used in practice that the convenience of having them as single commands overweights the conceptual cost of extending the kernel. Functions like Most and Rest I think can be examples of the latter. As far as I can tell, your case with Part restricted on lists does not fall into either category. Restricted patterns give a powerful mechanism to define functions only on certain types of arguments - this is just what you used in your implementation. OTOH, at least in my experience, problems with Part applied to general structures when intended to work only on lists are pretty rare and I always treat them as programming mistakes on my side. And having Part work universally on general Mathematica expressions has major advantages in terms of simplicity and consistency of the language, which I think greatly overweight occasional puzzling situations like the one you encountered. In fact, one of the main reasons for my appreciation of Mathematica language is that it does expose enough of its internals to the user that in most cases one can create custom functions for whatever purposes one needs, and work around the lack of any particular function in the kernel, just as you did it here. But this kind of extensibility stems from the small number of "orthogonal" general functions (like Part, or functions related to patterns, such as Pattern, ReplaceAll, etc) much more than it would from a huge API for all tasks one can possibly think of. Regards, Leonid > > > > > On Sep 6, 4:13 am, Greylander <greylan... at gmail.com> wrote: > > Consider the following toy example: > > > > in> goo[v_] := v.{1, 1}*(3 v) > > in> foo[k_][v_] := goo[v] [[k]] > > > > in> goo[nnn] > > out> 3 nnn nnn.{1, 1} > > > > in>foo[1][{2, 3}] > > out>30 > > > > in> foo[2][nnn] > > out>nnn > > > > Notice how in this last output, because the parameter nnn is > > undefined, [[k]] ends up acting on the structure of the expression in > > goo, but the intuitive behavior would be for evaluation of [[k]] to > > also be delayed. The output I would like to see is: > > > > in>foo[2][nnn] > > out> ( 3 nnn nnn.{1,1} ) [[2]] > > in> nnn = {4,5} > > % > > out> 135 > > > > But of course it does not happen that way. > > > > I realize that Mathematica is a specification rather than procedural > > language, but surely there is some reasonably elegant way to to delay > > the effect of [[2]] above so it acts on the eventual result of > > goo[nnn] and not on the structure of the expression. > > > > This is related to my other questions about using NDSolve on dependent > > variables that have arbitrary structure and therefore require some > > kind of indexing. > > > > There must some basic aspect of the Mathematica language that I have > > missed which makes indexing and list manipulation more intuitive. (I > > hope!) > > > > Anyone have any insights? > > >