Pure functions from pure functions

Question

I study the behavior of spatial curves and it is very convenient to write curvature and torsion as pure functions (PF).
It is often necessary to obtain their combinations, integrals and differentiates as pure functions also.
For example, we have curvature as crv = Log[1+#]& or smth like this.
Fortunately crv' directly produce PF.
But further there are difficulties. For sphere there is an equation for torsion:

trs = crv'/(crv Sqrt[crv^2 - 1])

But we don’t get PF if we just put crv. In this post it is proposed to enter mergeF as

mergeF[expr_] := Function @@ (Hold[expr] /. Function[body_] :> body)

so mergeF[crv'/(crv Sqrt[crv^2 - 1])] produce needed result: 1/(Log[1 + #1] Sqrt[-1 + Log[1 + #1]^2] (1 + #1)) &

In other cases it is necessary to obtain an integral from crv also as PF.
I found only a naive way to do it, and same I found here:

intCrv = Evaluate[Integrate[crv[s], {s, 0, #}]] &

But it looks unnatural, and also gives an answer with conditions that I don’t need.
And if we try to integrate a combination of PF, everything is confused at all.

The question arises whether there is a universal natural way (not list of tricks for possible special cases) to operate with PF to get PF?

Clarification
Let $f_1, f_2, \dots$ - some simple enough scalar functions as pure functions in Mathematica.
We know that:

• f' is a PF
• Derivative[-1][f] is a PF (thanks to @xzczd)
• If expr is a combination of PF then mergeF[expr] is PF

But I can’t figure out how to get PF universally as result from smth like this (and more complicated expressions):

$$\int \left(f_1 \cdot \left( \int f_2 \cdot f'_3 \right)\right)$$

Answer 1

You seem to need a depth-first evaluation. I've done this before with a special head, but I don't know where the old code is, so I threw this together:

ClearAll[mergeF`myF];
mergeF`myF /: h_[a___, f_mergeF`myF, b___] := 
  Block[{mergeF`myF = Function}, mergeF[h[a, f, b]]];
ClearAll[mergeF];
mergeF[expr_Function] := expr; (* Function has bubbled to the top *)
mergeF[expr_] /; mergeF`myF === Function := (* myF has evaluated *)
  Function @@ (Hold[expr] /. Function[body_] :> body);
mergeF[expr_] /; ! FreeQ[expr, Function] := 
  mergeF[expr /. Function -> mergeF`myF];
mergeF[expr_] := expr &; (* no Function; give error msg instead? *)

{f1, f2, f3} = {3 + # &, #^7 &, Log[1 + #] &};
Derivative[-1][f1*Derivative[-1][f2 *f3]] // mergeF
(*
1/604800#1 (171360 + 141120 #1 - 18480 #1^2 + 13860 #1^3 - 
     9828 #1^4 + 7350 #1^5 - 5760 #1^6 + 4680 #1^7 - 3910 #1^8 - 
     1701 #1^9) + 
  1/240 Log[1 + #1] (-68 - 90 #1 - 15 #1^2 + 10 #1^9 + 3 #1^10) &
*)

Answer 2

Here's my solution (just an update for Kuba's answer):

Clear@mergeF; 
mergeF[expr_] := 
 Function @@ {expr //. {Derivative[i_][h_] :> Derivative[i][mergeF@h],
      Function[body_] :> body}};
int = Derivative[-1];

{f1, f2, f3} = {3 + # &, #^7 &, Log[1 + #] &};
  
int[f1 int[f2 f3']] // mergeF
(* -(1/2) Log[1 + #1] (5 + 6 #1 + #1^2) + 1/
  5040#1 (12600 + 8820 #1 - 840 #1^2 + 630 #1^3 - 420 #1^4 + 
     294 #1^5 - 216 #1^6 + 165 #1^7 + 80 #1^8) & *)

Answer 3

mergeF[expr_] := Module[{result},
  result = expr /. Function[a_] -> Function[a][#];
  result = Evaluate[result] &;
  result
  ]
crv = Log[1 + #] &
expr = crv'/(crv Sqrt[crv^2 - 1])
expr // mergeF
Derivative[-1][result] result // mergeF

Result: $$\frac{1}{(\text{$\#$1}+1) \log (\text{$\#$1}+1) \sqrt{\log ^2(\text{$\#$1}+1)-1}}\&$$ $$\frac{\tan ^{-1}\left(\sqrt{\log ^2(\text{$\#$1}+1)-1}\right)}{(\text{$\#$1}+1) \log (\text{$\#$1}+1) \sqrt{\log ^2(\text{$\#$1}+1)-1}}\&$$

Explanation

In simplifying these expressions we implicitly assume these functions have the same argument. To see what I mean, let's say you have the functions $f(x)=x^2$ and $g(y)=1/y$. If you take the product $f\cdot g$, you can either interpret it as a new function with two variables, $f(x)g(y)=x^2/y$, or you can assume point wise multiplication, $f(x)g(x)=x$. Since we assume the latter, we are well justified to simply evaluate every function at some variable, and then re-interpret the result as a function. The cleanest way to do this is by evaluating at $\#$.

Note: This version also works with functions like Function[x, x^2]. If you only want to work with pure functions of the form #^2&, Kuba's answer also works.