pipes in Mathematica

*To*: mathgroup at yoda.ncsa.uiuc.edu*Subject*: pipes in Mathematica*From*: jacobson at cello.hpl.hp.com*Date*: Tue, 13 Aug 91 09:51:29 PDT

I use Mathematica a lot for data analysis. I like to use a functional programming style, but I have found this is more difficult in Mathematica than it ought to be. The problem is that when using functional programming, particularly in data analysis, we are usually starting with some list of values, and passing it successively through a sequence of operations. The problem is that some functions, such as Select, Take, Drop, and Transpose, have their "data" or "expr" argument first and their control arguments last. So you get into this situation of Drop[ <<< giant 12-line function>>>, 2] and sometimes that is embedded in something bigger. It is very difficult to tell that the "2" goes with the drop. For a possible solution, let us look at the tremendously successful pipe notation of the Unix C-shell. foo a | grep math | cut -2 | sort This means start with foo a, and pipe its result into grep math, and pipe its result into cut -2 and pipe is result into sort. Mathematica can do the same thing, but only if the functions (after the first) take exactly one argument. For example: foo[a,b,c]//Fourier//Reverse At some small runtime expense we can make this work with functions of all types foo[a,b,c]//Fourier//Drop[#,3]&//Map[1+1/#&,#]& Note that the last thing in the pipe got confusing because there are 2 #s close to each other that mean different things. (Maybe we could write .../Map[Function[x,1+1/x],#]&, but it is more verbose and looks confusing to me.) To overcome this, I have developed a hack that is working quite well for me. $$$/: Literal[f_[left___,$$$,right___]] := Function[x,f[left,x,right] This lets me write the above as foo[a,b,c]//Fourier//Drop[$$$,3]//Map[1+1/#&,$$$] where $$$ appearing in a top-level argument causes the expression to be converted to a function that accepts its input in that position. Note that only one $$$ is allowed. You must also be careful with using this in infix expressions, since what looks like a top-level parameter is not always. For example foo // 2/$$$ // bar would not do the right thing. If you want to put this into a file that you read in, you will have trouble if you reread the file. This what I actually use. ===================== $$$Switch=False Unprotect[$$$] $$$/: Literal[f_[left___,$$$,right___]] := Function[x,f[left,x,right], {HoldAll}]/; $$$Switch (* The HoldAll attributed keeps the Function from evaluating its argument, but normally, f will evaluate it anyway. This maintains exact compatibility with the normal function calling semantics. *) Protect[$$$] $$$Switch=True =================== I'm using 2.0beta3. Version 1.2 does not do true static scoping of varibles, so 1.2 users may wish to change "x" above to something like "Private`x" to be safe. They will also have to drop the {HoldAll} parameter. I'm hoping to find a scheme that is less of a hack than this. I would really like a system with a new symbol, such as /// that would mean "turn the thing to the right into a function and pipe the stuff to the left into it." Some special symbol, such as ###, would designate the formal parameter, which would not have to appear at the top level, and possibly might appear more than once. The construct should work properly when nested. Suggestions are welcome. -- David Jacobson