Define a delayed function depending on a global variable as though the variable's contents was pasted

Question

Problem

Say I previously defined a variable (maybe through some extensive calculation)

thing = (a+x)y

Then, I want to use that expression elsewhere. In general, I can't just type "thing". For example, the following doesn't work

thingy[a_,y_] := NIntegrate[ thing ,{x,0,10}]

What I want

I want a way to use variables such that it always behaves like I copied and pasted its contents directly e.g. I want to type:

thingy[a_,y_] := NIntegrate[ Paste[thing] ,{x,0,10}]

and have it behave like:

thingy[a_,y_] := NIntegrate[ (a+x)y ,{x,0,10}]

Not just in this particular example, but in all use cases.

What I am not looking for

Making this use case work.

Yes, I know that I can fix it with:

thingy[a1_,y1_] := NIntegrate[ thing /. {a->a1,y->y1} ,{x,0,10}]

I'd like a built-in function, even if it behaves slightly differently from the way I described, rather than a hard-coded user-defined function (unless it's a very short).

Answer 1

3 possibilities:

• InputAutoReplacements

• Inactive/Activate

• $PreRead

the last I am less sure is safe as I never used that.

---

1st possibility : InputAutoReplacements

Edit

You can use InputAliases or InputAutoReplacements. I do not see why one would want to use InputAliases here so we can consider InputAutoReplacements.

The code:

thing = a + b y;
SetOptions[EvaluationNotebook[], 
 InputAutoReplacements -> {"pastedthing" -> ToString@thing}]

---

2nd possibility : Inactive/Activate

In this case one could use (note that I used = instead of :=):

thing = (a + x) y;
thingy[a_, y_] = NIntegrate[thing, {x, 0, 10}] // Inactivate

thingy[4, 8]

(* Inactive[NIntegrate][8 (4 + x), {x, 0, 10}] *)

Notice that the integrand has been evaluated which I feel is more pleasant than using HoldForm.

then

thingy //Activate

(* 720. *)

(* Note: see @att's suggestion to use Activate on the DownValues of thingy *)

Check that the result is the same as using NIntegrate directly:

NIntegrate[8 (4 + x), {x, 0, 10}]

(* 720. *)

If writing Inactive[NIntegrate] each time is tedious you could add nintegrate=Inactive[NIntegrate] to your init.m file (some people do not recommend this as you will likely forget what you put there and could cause issues with some code 3 months from now).

---

3rd possibility: $PreRead

Another possibility which I have never used before, so it might cause issues, is to define a function for $PreRead to set up an alias between the character "thing" and it's evaluated output :

$PreRead = ReplaceAll[#, "thing" -> ToString[thing]] &

Then you can use

thingy[a_, y_] := NIntegrate[thing, {x, 0, 10}];

thingy[4, 3]

One issue with doing that is that you will not be able to clear the variable using:

Clear[thing]

Because Mathematica will see the evaluated form

Clear[(a + x) y];

Probably also a lot of the functions that have Attribute HoldFirst or HoldAll will not work as expected. As such it might be better to use a different name for the alias than for the expression to remember what we are doing when we type.

Answer 2

I'm keying off of the copy/paste idea that you emphasize. You might be interested in Iconize. Let's say you did that complicated calculation and saved it to thing. We'll let this represent that situation:

thing = (a + x) y

Now you can do either of these:

Iconize[(a + x) y, "thing"]
Iconize[thing, "thing"] (* since Iconize doesn't hold its arguments unevaluated *)

As the output you'll see an icon, like a token. It will be labeled thing, and the actual expression will be hidden. You can expand it to see some meta data. The important thing here is that whatever interactions you do with this icon/token will work pretty much as if you were interacting with the full expression directly. In particular, you can copy/paste this thing and the effect is the same as if you had copy/pasted the entire expression. By giving it the label "thing", it kind of looks like the symbol thing.

Answer 3

You can Inactivate the definition to resolve variables in it (if they are not the head of an expression), then immediately Activate it to evaluate the definition.

thing = (a + x) y;
Activate@Inactivate[thingy[a_, y_] := NIntegrate[thing, {x, 0, 10}]];
DownValues@thingy

{HoldPattern[thingy[a_, y_]] :> NIntegrate[(a + x) y, {x, 0, 10}]}

You can wrap variables you don't wish to expand in Inactive to prevent unwanted substitutions.

Block[{x = 2, test}, 
 Activate@
  Inactivate[test[b_] := Integrate[x, {x, 0, b}]]; 
 DownValues@test]
Block[{x = 2, test}, 
 Activate@
  Inactivate[test[b_] := Integrate[Inactive@x, {Inactive@x, 0, b}]]; 
 DownValues@test]

{HoldPattern[test[b_]] :> \!\(
\*SubsuperscriptBox[\(\[Integral]\), \(0\), \(b\)]\(2 \
\[DifferentialD]2\)\)}
    (* {HoldPattern[test[b_]] :> Integrate[2, {2, 0, b}]} *)

{HoldPattern[test[b_]] :> \!\(
\*SubsuperscriptBox[\(\[Integral]\), \(0\), \(b\)]\(x \
\[DifferentialD]x\)\)}
    (* {HoldPattern[test[b_]] :> Integrate[x, {x, 0, b}]} *)

---

In the original expression, since := (SetDelayed) does not evaluate its right hand side, variables present there will not be expanded.

Inactivate[...] works by wrapping all heads in an expression with Inactive, inhibiting those heads' further evaluation. Importantly, the now-inactivated head Inactive[SetDelayed] does not prevent evaluation of its right hand side. This allows evaluation to proceed into the expression, identify that thing evaluates to (a + x) y, and perform the substitution accordingly. This yields an Inactivated definition where variable substitutions have been made.

Activate@
  Inactivate[thingy[a_, y_] := NIntegrate[thing, {x, 0, 10}]] // Trace

(* Mathematica formats Inactive heads in output with TemplateBox.
   Here they are shown in bold italics instead. *)
{{Inactivate[thingy[a_, y_] := NIntegrate[thing, {x, 0, 10}]], 
  thingy[a_, y_] := 
   NIntegrate[thing, {x, 0, 10}], {{thing, (a + x) y}, 
   NIntegrate[(a + x) y, {x, 0, 10}]}, 
  thingy[a_, y_] := NIntegrate[(a + x) y, {x, 0, 10}]}, 
 Activate[thingy[a_, y_] := NIntegrate[(a + x) y, {x, 0, 10}]], 
 thingy[a_, y_] := NIntegrate[(a + x) y, {x, 0, 10}], Null}

Finally, we Activate to remove the Inactives, and the definition evaluates.

Answer 4

Maybe this will work for you?

thing[a_, y_, x_] := (a + x) y;
thingy[a_, y_] := NIntegrate[thing[a, y, x], {x, 0, 10}];
thingy[3, 2]
(* 160 *)