new functional operator

roby

unread,

Mar 3, 2012, 6:52:46 AM3/3/12

to

Dear Group and Mathematica staff.

In the functional programming spirit I am missing a postfix notation
for Map[ ].

Du to its clarity I often prefer the sequentiall postfix style
processing of expressions and data:
e.g.

data//F1//F2//F3

but what if our data is a List and the functions we want to perform on
don't have the Listable Attribute ?.
the clumsy solution now is:

data//F1/@#&//F2/@#&//F3/@#&

therefor I suggest a new functional operator, which e.g. could look
like this: ///
such that my favorit expression would appear in this nice and clear
form:

data///F1///F2///F3

In other words the new /// operator should temporarily activate the
Listable Atrribute for the affected function

any comments welcome

Robert

noqsiae...@gmail.com

unread,

Mar 4, 2012, 4:37:11 AM3/4/12

to

On Saturday, March 3, 2012 8:52:46 PM UTC+9, roby wrote:
> Dear Group and Mathematica staff.
>
> In the functional programming spirit I am missing a postfix notation
> for Map[ ].

How about:

RightVector[a_,f_]:=Map[f, a]
RightVector[a_,more__]:=RightVector[Map[{more}[[1]],a],Sequence@@Drop[{more},1]]

Then:

{1,2,3}\[RightVector](#^2&)\[RightVector]g

yields:

{g[1],g[4],g[9]}

(it looks nicer in a notebook)

roby

unread,

Mar 8, 2012, 4:37:18 AM3/8/12

to

On 4 Mrz., 10:37, noqsiaerosp...@gmail.com wrote:
> On Saturday, March 3, 2012 8:52:46 PM UTC+9, roby wrote:
> > Dear Group and Mathematica staff.
>
> > In the functional programming spirit I am missing a postfix notation

> > forMap[ ].

>
> How about:
>
> RightVector[a_,f_]:=Map[f, a]
> RightVector[a_,more__]:=RightVector[Map[{more}[[1]],a],Sequence@@Drop[{more },1]]
>
> Then:
>
> {1,2,3}\[RightVector](#^2&)\[RightVector]g
>
> yields:
>
> {g[1],g[4],g[9]}
>
> (it looks nicer in a notebook)

Yes,

THIS IS IT

surprisingly easy, surprisingly not yet standard in Mathematica

can even be prettyfied a little bit:

RightVector[a_,f_]:=f/@a
RightVector[a_,more__]:=RightVector[First@{more}/
@a,Sequence@@Rest@{more}]

or we can use LeftTee[ ] which in contrast to RightArrow[ ] already
implements the neccesary left-assocciativitiy such that:

LeftTee[a_, f_] := f /@ a

is all we need.

{1,2,3}\[LeftTee]Sin\[LeftTee]Sqrt
(looks nicer in a notebook)

Robert

branton.campbell

unread,

Mar 8, 2012, 4:38:51 AM3/8/12

to

> In the functional programming spirit I am missing a postfix notation
> for Map[ ].

I have wanted just such an operation for years. Excellent suggestion.

roby

unread,

Mar 8, 2012, 4:40:25 AM3/8/12

to

On 4 Mrz., 10:37, noqsiaerosp...@gmail.com wrote:

even more tricky:

RightVector[a_,first_,rest___]:=
If[rest===Null,first/@a,RightVector@@{first/@a,rest}]

Robert

roby

unread,

Mar 8, 2012, 4:40:56 AM3/8/12

to

On 4 Mrz., 10:37, noqsiaerosp...@gmail.com wrote:

... sorry for flooding the group, but got it even nicer:

RightVector[a_, first_, rest___] := If[rest === Null, first /@ a,
RightVector[first /@ a, rest]]

Robert

roby

unread,

Mar 9, 2012, 6:11:21 AM3/9/12

to

Ok, next version.

One can look for an prefix operator with no buit in meaning to modify
the function in question such that it acts mapping,
this way we can use the standard // postfix operator and just modify
the behavoir of the function:

\[Del] fn_ := fn /@ # &

{1,2,3,4}//\[Del]f//\[Del]g

Out[5]= {g[f[1]], g[f[2]], g[f[3]], g[f[4]]}

(looks all nice in a Notebook)

Robert

Barrie Stokes

unread,

Mar 10, 2012, 6:14:57 AM3/10/12

to

Hi Roby

Very nice also; even prettier is, e.g.,

In[288]:= {1, 2, 3} \[LeftTee] (s \[Function] Sin[ s^(2 Log[ s]) ])

Out[288]= {Sin[1], Sin[2^(2 Log[2])], Sin[3^(2 Log[3])]}

and

In[289]:= {1, 2, 3} \[LeftTee] Sin \[LeftTee] Sqrt \[LeftTee] (s \[Function] Sin[ s^(2 Log[ s ]) ])

Out[289]= {Sin[Sin[1]^(1/2 Log[Sin[1]])],
Sin[Sin[2]^(1/2 Log[Sin[2]])], Sin[Sin[3]^(1/2 Log[Sin[3]])]}

for someone who thinks "#" and "@" are ugly.

I think I like LeftTee more than RightVector, since the former sort of "points" in the direction of application of the pure function.

Maybe LeftVector is another possibility?

Now I just need to devise a mnemonic keyboard shortcut ...

Cheers

Barrie

>>> On 08/03/2012 at 8:36 pm, in message <2012030809...@smc.vnet.net>, roby

<roby....@gmail.com> wrote:
> On 4 Mrz., 10:37, noqsiaerosp...@gmail.com wrote:

>> On Saturday, March 3, 2012 8:52:46 PM UTC+9, roby wrote:
>> > Dear Group and Mathematica staff.
>>
>> > In the functional programming spirit I am missing a postfix notation

>> > forMap[ ].

>>
>> How about:
>>
>> RightVector[a_,f_]:=Map[f, a]
>> RightVector[a_,more__]:=RightVector[Map[{more}[[1]],a],Sequence@@Drop[{more
> },1]]
>>
>> Then:
>>
>> {1,2,3}\[RightVector](#^2&)\[RightVector]g
>>
>> yields:
>>
>> {g[1],g[4],g[9]}
>>
>> (it looks nicer in a notebook)
>

Barrie Stokes

unread,

Mar 10, 2012, 6:15:28 AM3/10/12

to

Hi Robert

Nice!

But for even greater elegance, IMHO, how about

In[277]:= {a, b, c} \[RightVector] (s \[Function] s^2)

Out[277]= {a^2, b^2, c^2}

Cheers

Barrie

>>> On 08/03/2012 at 8:39 pm, in message <2012030809...@smc.vnet.net>, roby

<roby....@gmail.com> wrote:
> On 4 Mrz., 10:37, noqsiaerosp...@gmail.com wrote:

Bill Rowe

unread,

Mar 10, 2012, 6:16:30 AM3/10/12

to

I don't have any problem agreeing this notation looks nicer than say

{1, 2, 3, 4} // f /@ # & // g /@ # &

And, I can set up the definition in init.m so that it is always
available without needing to define it in each notebook where I
would use it.

But it presents another issue. Unless you are writing code for
yourself you will never share with someone else, you will be
making your code much more difficult to understand.

Arguably something like

f/@{1,2,3,4}

is already opaque to a new Mathematica user in terms of
understanding code. But, since this is standard syntax one could
highlight the /@ then use the built-in documentation to
determine what the code is doing. But once you start using
custom notation, this ability is lost. Then, even a well
seasoned user will have great difficulty in determining what the
code does.

And in fact, unless you use such custom notation often, you are
likely to have difficulty with your own code if you need to
review/modify it say a year or two after it was written.

Murray Eisenberg

unread,

Mar 10, 2012, 6:21:39 AM3/10/12

to

An unfortunate choice of notation, \[Del], for that operator. After all
\[Del] is a universal notation for grad, the gradient operator.

On 3/9/12 6:09 AM, roby wrote:
> Ok, next version.
>
> One can look for an prefix operator with no buit in meaning to modify
> the function in question such that it acts mapping,
> this way we can use the standard // postfix operator and just modify
> the behavoir of the function:
>
>
> \[Del] fn_ := fn /@ #&
>
> {1,2,3,4}//\[Del]f//\[Del]g
>
> Out[5]= {g[f[1]], g[f[2]], g[f[3]], g[f[4]]}
>
> (looks all nice in a Notebook)
>
>
>

> Robert
>

--
Murray Eisenberg mur...@math.umass.edu
Mathematics & Statistics Dept.
Lederle Graduate Research Tower phone 413 549-1020 (H)
University of Massachusetts 413 545-2859 (W)
710 North Pleasant Street fax 413 545-1801
Amherst, MA 01003-9305

roby

unread,

Mar 13, 2012, 4:01:10 AM3/13/12

to

> An unfortunate choice of notation, \[Del], for that operator. After all
> \[Del] is a universal notation for grad, the gradient operator.

Yes, you are right of course, but \[Del] beside \[PlusMinus] and \
[MinusPlus] are the only prefix operators without predefined meaning/
function in Mathematica.
Every other prefix operator would need Unprotect[ ].

Robert

roby

unread,

Mar 14, 2012, 1:34:12 AM3/14/12

to

>
> I don't have any problem agreeing this notation looks nicer than say
>
> {1, 2, 3, 4} // f /@ # & // g /@ # &
>
> And, I can set up the definition in init.m so that it is always
> available without needing to define it in each notebook where I
> would use it.
>
> But it presents another issue. Unless you are writing code for
> yourself you will never share with someone else, you will be
> making your code much more difficult to understand.
>

Thats why I would prefer /// as postfix-map operator to be implemented
by the Mathematica staff.
Any Mathematica staff member listening ?

Robert

John Doty

unread,

Mar 18, 2012, 3:43:46 AM3/18/12

to

On Tuesday, March 13, 2012 11:34:12 PM UTC-6, roby wrote:
> >
> > I don't have any problem agreeing this notation looks nicer than say
> >
> > {1, 2, 3, 4} // f /@ # & // g /@ # &
> >
> > And, I can set up the definition in init.m so that it is always
> > available without needing to define it in each notebook where I
> > would use it.
> >
> > But it presents another issue. Unless you are writing code for
> > yourself you will never share with someone else, you will be
> > making your code much more difficult to understand.
> >

Not any more so than any other specialized function you might define for your problem. You always need to be clear about notation and conventions in Mathematica code. This case is much easier than most, I think.

>
>
>
> Thats why I would prefer /// as postfix-map operator to be implemented
> by the Mathematica staff.
> Any Mathematica staff member listening ?

Please, no. Mathematica is already bloated with functions trivially implementable using more basic functions. That creates a information fog that makes *all* Mathematica code harder to understand, and Mathematica much harder to learn than it used to be.

roby

unread,

Mar 20, 2012, 3:19:23 AM3/20/12

to

> That creates a information fog that makes *all* Mathematica code harder to understand, and Mathematica much harder to learn than it used to be.

{1, 2, 3, 4} /// f///g

> {1, 2, 3, 4} // f /@ # & // g /@ # &

sorry but I absolutly can't agree with your opinion in this case, the
former expression is more or less fogless and would be much easier to
understand.
The latter expression bears a lot of clutter.

Robert

John Doty

unread,

Mar 21, 2012, 6:47:14 AM3/21/12

to

On Tuesday, March 20, 2012 1:19:23 AM UTC-6, roby wrote:
> > That creates a information fog that makes *all* Mathematica code harder to understand, and Mathematica much harder to learn than it used to be.
>
> {1, 2, 3, 4} /// f///g
>
>

> > {1, 2, 3, 4} // f /@ # & // g /@ # &
>

> sorry but I absolutly can't agree with your opinion in this case, the
> former expression is more or less fogless and would be much easier to
> understand.
> The latter expression bears a lot of clutter.
>
> Robert

It isn't clutter in any specific piece of code that's the problem: it's all the cluttered documentation. Many of us appreciated the wonderful Mathematica book when it existed, but Mathematica has too many unnecessary functions these days, so a book is impractical. A vast fog of hypertext isn't as easy to navigate as a book. For functions like the one we're discussing, it's much better to define it only when needed. Then, those trying to understand code that *doesn't* use that function (almost all Mathematica code ever written) won't have to waste time looking past it in the documentation.

DrMajorBob

unread,

Mar 21, 2012, 6:48:46 AM3/21/12

to

Here SIX several equivalent expressions from (IMHO) most intuitive or
readable to least:

Composition[g, f] /@ {1, 2, 3, 4}