# Nested definition: How can I define a function with a passed-in expression?

Here's a simplified version of what I'm trying to do:

SetAttributes[def, HoldFirst]
def[s_Symbol, v_] := (s[x_] := v)
def[f, x^2]
f[3] (* Expected result: 9 *)
(*
x^2
*)
?f (* Expected result: f[x_] := x^2 *)
(*
Globalf

f[x$_] := x^2 *)  Obviously the x in the x_ pattern gets replaced by x$. Is there a way I can prevent that? That is, from calling def[f,x^2] I want to result the definition f[x_] := x^2. I don't of course care about the name of the variable, so if the resulting function definition reads f[x$_] := x$^2 I'm fine with that, too.

I tried

def[s_Symbol, v_] := With[{x$= x}, s[x_] := v] def[s_Symbol, v_] := With[{x = x$}, s[x_] := v]
def[s_Symbol, v_] := (s[x_] := v) /. x :> x$ and def[s_Symbol, v_] := (s[x_] := v) /. x$ :> x


but none worked.

• How about SetAttributes[def, HoldFirst]; def[s_Symbol, v_] := With[{temp = v}, s = Function @@ {x, temp}]? – J. M.'s discontentment Aug 31 '12 at 9:28
• @J.M.: Thanks, I didn't think of anonymous functions; that's a solution that indeed works for my case. – celtschk Aug 31 '12 at 9:36
• @J.M.: I have to retract that it works for my problem: I just noticed that anonymous functions don't seem to support optional arguments. – celtschk Aug 31 '12 at 9:43

With your proposed definition style, the user of that function def has to know that v could/should/must depend on x for this to work; x really should be an argument of def. Perhaps something like this were better suited.

ClearAll[def]
ClearAll[f]
(*SetAttributes[def,HoldFirst]*)

def[s_Symbol, v_, vars_List] :=
With[{h = s @@ (Pattern[#, Blank[]] & /@ vars)}, (h := v)]
def[f, x^2, {x}]

f[3]
(* 9 *)

• This indirect pattern building did the trick! – celtschk Aug 31 '12 at 9:51

Try for example

SetAttributes[def, HoldAll]
def[s_Symbol, v_] := Function[Null, s[x_] := #, HoldFirst][v]


Unnamed functions just don't care :)

Other alternatives that should also work (but I would use the previous approach)

def[s_Symbol, v_] := Identity[SetDelayed][HoldPattern@s[x_], v];
def[s_Symbol, v_] := Unevaluated[s[x_] := "Hello"] /. "Hello" -> v

• Elegant! +1. (I edited to better respect the semantics of SetDelayed. If you don't like the result, feel free to revert!) – Oleksandr R. Aug 31 '12 at 21:33
• Thanks @OleksandrR. Your edit is fine. I had done it that way based on the question being HoldFirst, but HoldAll makes more sense to me too – Rojo Sep 1 '12 at 1:21

I propose these:

SetAttributes[def, HoldAllComplete]

def[s_Symbol, v_] := SetDelayed @@ Hold[s[x_], v]

def[s_Symbol, v_] := With[{L := s[x_]}, L := v]

def[s_Symbol, v_] := Reverse @ Unevaluated[v := s[x_]]


The HoldAllComplete (or SequenceHold) attribute is necessary for an assignment such as:

def[q, Sequence[1, 2, x]]


head[1, 2, 5]
`