Third argument of Compile

Question

In his last comment on this answer, halirutan shows an example in which the third argument of Compile does not have any effect. The example is as follows.

cfu = Compile[{}, Module[{y = {}}, AppendTo[y, 1]], {{y, _Integer, 1}}];
cfu[]

Outputs

{1.}

rather than {1}

Does anybody know an example where using the third optional argument of Compile does have an effect?

Answer 1

To my knowledge, one of the situations where the third argument of Compile is required is when your compiled code needs to make a MainEvaluate call. Often, the situation is the other way around: you have code and you try to compile it down completely, so that no MainEvaluate call is necessary. Honestly, most of the questions about Compile here deal to some extend with this issue.

What is, when it is out of question that some part of your code has to be run by the kernel and cannot be compiled under no circumstances? Then the task is to build this into your compiled code, so that it works and the compiler can determine the type of your external call. Let's assume a simple function which collects some prime numbers:

primes[n_] := Last[Last[Reap[Table[If[PrimeQ[i], Sow[i]], {i, n}]]]]

and now you want to have a compiled function which multiplies such a list with an integer giving you an integer list back. First, you can play around with this snipped

Compile[{{n, _Integer}}, Module[{a = 2},
  a*Last[Last[Reap[Table[If[PrimeQ[i], Sow[i]], {i, n}]]]]
  ]
 ]

but this is not fun and Reap and Sow are bad for compiling anyway. The solution is the third argument to Compile:

fc = Compile[{{n, _Integer}}, Module[{a = 2},
   a*primes[n]
  ], {{primes[_], _Integer, 1}}
]

because you can get a working and readable version of your function. Now assume that you have a compiled function where you need the result of NMinimize or some similar (uncompilable) function. This is your use-case.

As for your initial problem with y and AppendTo: The type of local variables can be coerced in other ways. For instance, if you want to say that y should be an integer list, then initialize it with Most[{1}] which gives you an empty list, but the compiler saw that you want an integer list :-)

cfu = Compile[{}, Module[{y = Most[{1}]}, AppendTo[y, 1]]];
cfu[]
(* {1} *)

Answer 2

Leonids comment encouraged me to experiment with unscoped variables. I then the following difference, which is not particularly useful.

cfu2 = Compile[
   {},
   Module[
    {x = y}
    ,
    AppendTo[x, 2]
    ],
   {{y, _Integer, 1}}
   ];

cfu3 = Compile[
   {},
   Module[
    {x = y}
    ,
    AppendTo[x, 2]
    ]
   ];

The functions give different results

y = {}; cfu2[]
y = {}; cfu3[]

{2} 
{2.}

I think the trick mentioned by Leonid in the comments should normally be faster, as it avoids MainEvaluate. We should probably not use this to "declare" variables in Compile. The use case described by halirutan is much more useful.