# multiple sequential definitions, defining own set function

I want to define a function for doing multiple definitions, where I apply the same function f to all values, and definitions are done not at the same time but after each other.

A simple example: the function I want is multiDef, where

multiDef[{{a, 1}, {b, 2}, {c, a}}, f]


should be identical to the sequence of assignments

a = f;
b = f;
c = f[a];


A simple attempt, with slightly different syntax, is

multiDef[list1_List, list2_List, fct_] /; Length[list1] == Length[list2] :=
list1 = fct /@ list2


Aside from the different syntax the problem here is that it will not set c to f[f], but to f[a] (or to f if we had a = 5 before running this).

The first proposed syntax of multiDef can be implemented like this:

SetAttributes[multiDef, HoldAll]
multiDef[{b:{_Symbol, _}...}, f_] :=
(CompoundExpression @@ Replace[Hold[b], {s_, v_} :> (s = f@v), {1}];)


The key is make sure that the symbols in the argument list are not evaluated until after the appropriate Set expressions have been assembled. This is necessary to prevent the symbols from being replaced by any existing values that they may already have.

The HoldAll attribute prevents such unwelcome evaluation of the argument list. Inside the function, we temporarily wrap the symbol/value pairs in Hold to prevent further evaluation of the pairs as we operate upon them. Replace is used to transform each pair into an assignment. Finally, we convert the Hold expression into a CompoundExpression, adding an extra semicolon after the last assignment.

Here is multiDef in action:

multiDef[{{a, 1}, {b, 2}, {c, 3 + 4}}, f]

{a, b, c}
(* {f, f, f} *)


Note that the definition ensures that the supplied variable values are not evaluated prior to passing them to the supplied function -- in case that function wants to hold them itself:

multiDef[{{a, 1}, {b, 2}, {c, 3 + 4}}, Hold]

{a, b, c}
(* {Hold, Hold, Hold[3 + 4]} *)


We can use TracePrint to peek under the covers and see the result of the Replace transformation:

TracePrint[multiDef[{{a, 1}, {b, 2}, {c, 3 + 4}}, f], _CompoundExpression]
(*
CompoundExpression @@ Replace[Hold[{a,1},{b,2},{c,3+4}],{s$_,v$_}:>(s$=f[v$]),{1}];
a = f; b = f; c = f[3+4]
*)


When defining macros like multiDef, it is a good idea to signal an error if the expression does not conform to the expected syntax:

m:multiDef[___] := (Message[multiDef::malformed, HoldForm[m]]; Abort[])
multiDef::malformed = "Malformed arguments in ";


This extra definition will catch simple syntax errors as they happen rather than blindly carrying on with the evaluation:

multiDef[{a, b, c}, f]
(*
multiDef::malformed: Malformed arguments in multiDef[{a,b,c},f]
\$Aborted
*)

• Thanks, this is what I was looking for. The compound expression guarantees evaluation in the order of input. – Jansen Jun 21 '14 at 8:47

If a, b and c do not already have values, you can simply use

In:= (#1 = f[#2]) & @@@ {{a, 1}, {b, 2}, {c, a}}
Out= {f, f, f[f]}

In:= a
Out= f

In:= b
Out= f

In:= c
Out= f[f]


If they do have values then I do not recommend storing the input in a simple list such as {{a,1}, ...}. It is necessary to Hold the result in some way, e.g. Hold[{a,1}, ...]. Then you can use the same solution from above and use ReleaseHoldat the end.

You can also use this construct if your left- and right-hand sides are in different lists:

MapThread[Set, {{a, b, c}, f /@ {1, 2, a}}]
{a, b, c}


{f, f, f[f]}

@Szabolcs's remarks are equally applicable here.

Try this also:

m = {{a, 1}, {b, 2}, {c, a}};
(Evaluate@m[[;; , 1]]) = f /@ m[[;; , 2]]

(*{f, f, f[f]}*)


One thing I want to add, when you run this, a,b, and c will not be empty symbols. So I would suggest you add clear command if you want to always run this.

Clear[a, b, c]