It is unfortunate that this no longer works. I like metaprogramming, and I felt that inlining variables is a nice exercise, so I can share some functions with you that make things easier.

Your approach using `With`

seems reasonable. I also saw you test an example using `Evaluate`

, but relying on the fact that `x[[i]]`

evaluates to `x[[i]]`

if `i`

not an integer and `x`

has no value is quite bad.

You say that your approach using `With`

will not work for more complicated cases. If the issue is that you want to use evaluation to determine the values of your parameters, you can use the following.

```
ClearAll@inlineEval
SetAttributes[inlineEval, HoldAll];
inlineEval[expr_, symbols__] :=
Unevaluated[expr] /.
Thread[Rule[HoldPattern /@ Unevaluated[{symbols}], {symbols}]]
```

You can use it as follows. Let's set up a situation that is relatively hard to deal with to test it.

```
b := c[1, 2]
c[x_, y_] := x + y
```

Now we can do

```
cfu =
inlineEval[
Compile[{{x, _Integer}}, Sum[1, {i, x + b}]]
,
b
];
cfu[3]
```

```
6
```

If you don't want to use evaluation, you can use the following.

```
SetAttributes[inlineAll, HoldAll]
inlineAll[expr_, symbols__Symbol] :=
ReleaseHold[
HoldComplete[expr] //.
Flatten[Function[Null, {OwnValues@#, DownValues@#}, HoldAll] /@
Unevaluated[{symbols}]]
];
```

Now you can also this, but note that you have to specify that `c`

has to be inlined as well.

```
cfu2 =
inlineAll[
Compile[{{x, _Integer}}, Sum[1, {i, x + b}]]
,
b, c
];
cfu2[3]
```

```
6
```

Note that both functions also with symbols that have `DownValues`

, which is something I believe "InlineExternalDefinitions" could not deal with to begin with. The previous examples dealt only with constants, but here is an example where we inline a function.

```
f[x_] := Norm[x];
cfu3 =
inlineAll[
Compile[{{x, _Real, 1}}, f[x] + 3]
,
f
];
cfu3[{1., 1.}] == Sqrt[2] + 3
```

```
True
```

This technique allows you to make large compiled functions, while maintaining readability. You could imagine that when compiled functions get too large, you simply let one compiled function call another compiled function, and optionally using "InlineCompiledFunctions". But I like this alternative :).

Related (but probably less nice than this)

2On the other hand,

`nPara = 3; cf = Compile[{{x, _Real, 1}}, Total[x[[1 ;; nPara]]], CompilationOptions -> {"InlineExternalDefinitions" -> True}]`

works ok in v10. Is it the use of the`Sum`

that breaks the compilation? – Yasha Gindikin – 2014-07-12T22:04:27.403`Sum`

itself is compilable. Also`Compile[{{x, _Real, 1}}, Plus @@ x[[;; nPara]], CompilationOptions -> "InlineExternalDefinitions" -> True}]`

works fine. The real problem is, that it is not clear, when parameters are inlined and when not. Furthermore it would be nice to know when notebooks that worked in Mma v9 don't anymore in v10. – Karsten 7. – 2014-07-12T22:44:28.507Not inlined in this case, too:

`Compile[{{x, _Real, 1}}, Module[{sum = 0.}, Do[sum += x[[i]], {i, nPara}]], CompilationOptions -> {"InlineExternalDefinitions" -> True}]`

– Michael E2 – 2014-07-12T23:33:41.8031The value of the iterator is also not inlined for

`Table`

, but strangly is for`Range`

. – Karsten 7. – 2014-07-13T00:03:12.933Using

`Compile[{{x, _Real, 1}}, Evaluate@Sum[x[[i]], {i, nPara}], CompilationOptions -> {"InlineExternalDefinitions" -> True}]`

will give some messages but completely compiles and works as expected. – Karsten 7. – 2014-07-13T00:16:18.047In

v9`nPara = 3; cf = Compile[{{x, _Real, 1}}, Table[x[[i]], {i, nPara}], CompilationOptions -> {"InlineExternalDefinitions" -> True} ]`

can't be fully compiled so the behavior of`"InlineExternalDefinitions"`

inv10is more consistent in a sense 囧. – xzczd – 2017-06-05T13:10:25.390