Substitute a function's definition for its name

Question

I'm having trouble with a function which is supposed to work on another function. Simplified version:

one[x_] := 1 (* the argument *)
problem[f_] := Integrate[f[t], {t, 0, #}] & (* the function doing the work *)

Simple enough, right? But when I pass

problem[one] // InputForm (* to paste into se *)

I get

Integrate[one[t], {t, 0, #1}] &

and even

FullSimplify[problem[one]] // InputForm

just gives

Integrate[one[t], {t, 0, #1}] &

But I know that the function is there, since if I evaluate

problem[one][17]

it (properly) gives

17

How do I get Mathematica to substitute the function's definition for its name so it can simplify the result (in this case, evaluate the integral)?

(System details: 64-bit Mathematica 10.0.2.0, Windows 7 Pro SP1, i7-4770.)

Answer 1

The problem is that the function name f is substituted into Function (&) which is HoldAll. This means f[t] will not be evaluated until the Function is evaluated, such as in the OP's example problem[one][17].

So the trick is to evaluate the integrand before inserting it into the Function. Here is one way.

one[x_] := 1 (*the argument*)
problem[f_] := With[{integrand = f[\[FormalT]]},
  Integrate[integrand, {\[FormalT], 0, #}] & 
  ]

problem[one]
(*  Integrate[1, {\[FormalT], 0, #1}] &  *)

As @Guess who it is pointed out, the use of \[FormalT] or Esc$tEsc is safer way to define problem. If ones uses a simple t instead and t already has a value, say t = 2, then the evaluation of f[t] will substitute the value of t, and we would get f[2] for the integrand instead of a function of t. Since formal symbols cannot be assigned a value, this problem cannot occur with \[FormalT].

However, if for some reason the definition of f contained \[FormalT], say as a parameter, then we run into trouble. So maybe a better way is to use Module to localize t. This should offer even more protect at the expense of having a slightly unreadable module variable:

problem[f_] := Module[{t},
  With[{integrand = f[t]}, Integrate[integrand, {t, 0, #}] &]
  ]

problem[one]
(*  Integrate[1, {t$64741, 0, #1}] &  *)

Within one's own project, one should be able to pick a formal symbol that is never used as a parameter. So practically the first answer above should suffice.