How to leave function unevaluated programmatically?

Question

Is it possible to write a function in such manner, that it can be either evaluated or left unevaluated?

This is a general question. Sample below is just a sample. No need to find solution for this sample. Need a general solution.

Hypothetical sample:

F[x_] := If[x>=0,
    Sqrt[x],
    Fail[]
];

So that it gives

F[4]
(* ==> 2 *)

But

F[-4]
(* ==> F[-4] *)

I.e. hypothetical function Fail[] stays for "drop evaluation and leave expression unevaluated".

I know I can use Condition

F[x_] := Sqrt[x] /; x >= 0

But I wish to do that in imperative programming way. Is this possible?

UPDATE

I don't understand why this is not working:

F[x_] := Block[{fail},
  (If[x >= 0,
     fail = False;
     Sqrt[x],
     fail = True
     ]) /; ! fail]

UPDATE 1

Manual has a good example

f[x_] := Module[{a}, a = Prime[10^x];
  (FactorInteger[a + 1]) /; a < 10^6]

which is checking internal variables, not arguments. But why my version above not works then?

Answer 1

Your posted code does not work because some of the code you want to evaluate is given as an argument to Condition which holds its arguments, you could make it work by changing this

f[x_] := Block[{ans, success},
    ans = If[x >= 0, success = 1; Sqrt[x], success = 0];
    ans /; (success == 1)
    ]

Notice that the first line of code is process outside of Condition. It might be easier to see if you write it in expression form:

f[x_] := Block[{ans, success},
     ans = If[x >= 0, success = 1; Sqrt[x], success = 0];
     Condition[ans,success == 1]
     ]

Compare this with how your example would be in expression form:

 F[x_] := Block[{fail},
  Condition[If[x >= 0,fail = False;Sqrt[x],fail = True], ! fail]]

You should be able to tell the difference. In the working code the code that sets fail is evaluated before Condition is evaluated. In your code, Condition is evaluated first, which holds the evaluation of the code. This is because condition has Attributes HoldAll.

Answer 2

Yes, it is possible. However, it requires the use of the undocumented System`Private`$Localized, which was (as far as I know) first discovered by @Rojo. This symbol is most likely an internal implementation detail of the evaluator and, being located in a context that is obviously not meant for manipulation by the user, should be approached with caution.

It is, however, quite simple to use:

Clear[F1];
p : F1[x_] := (
  p = System`Private`$Localized;
  If[x >= 0, Sqrt[x], p, p]
 );

We thus have a re-implementation of Condition in terms of If:

F1[2]
(* -> Sqrt[2] *)

F1[-2]
(* F1[-2] *)

F1[a]
(* F1[a] *)

Note that this result lacks the HoldForm/Defer wrappers one requires with other approaches.

Answer 3

A great resource about such stuff is the Tutorial: Package Design. Luckily, it was written by Todd Gayley who is also a registered member of Mathematica.SE.

The important part can be found in section Error Handling

If a more complex test of the input is required, you can put the Condition as the last statement in a Module:

f[x_List] := Module[{result, test},
                    some calculations here...
                    test = true or false depending on calculations
                    result /; test
             ]

If test is set to False, the Condition fails and Mathematica pretends that the match to f[x_List] never happened, moving on to try other rules for f. This is a little-known tidbit of Mathematica programming. Note that Condition must be the last statement in the Module (or Block or CompoundExpression) for it to work.

But this is only a small part of this fine material. For instance, to return an error message, which contains the unevaluated function call, he give the following implementation

Clear[f]
f[a_List] := something
p:HoldPattern[f[a_]] := holycow /; Message[f::list, HoldForm[p], 1]

f[1]
(* f::list: List expected at position 1 in f[1]. *)

This tutorial is definitely worth looking.

Answer 4

Using the 4th argument of If should do the trick

F[x_] := If[x >= 0, Sqrt[x], Defer[F[x]], Defer[F[x]]]

{F[2], F[-2],F[a]} 

(* {Sqrt[2],F[-2],F[a]}  *)

or may be

F[x_] := If[x >= 0, Sqrt[x], HoldForm[F[x]], HoldForm[F[x]]]

so that

F[a]/. a-> 2//ReleaseHold

(*  Sqrt[2] *)   

The first form (using Defer) would work also with F[a]/. a-> 2 but you would need to say evaluate it in place, see the documentation

Answer 5

I'm going to go out on a limb here and just assume that your problem is that you are nesting conditionals inside your code definitions, and that deeper levels are ignored. If that is the case, what you could do is to use a conditional check to see if your code processed without throwing exceptions, and use exceptions as your Fail[] function.

mysquare[x_] :=
 Module[{n = Catch[

   (*Your code goes here*)
    If[x < 0, Throw[stop]];
    a=Sqrt[x];
    If[x == 7, Throw[stop]];
    a    
    ]},
  n /; ! (n === stop)
 ]

The you can halt the computation at different locations along the code and let it stay in an unevaluated form: mysquare[-2] returns mysquare[-2], mysquare[4] returns 2, and mysquare[7] will evaluate Sqrt[7] but return mysquare[7].

If this is close to what you are actually doing, I would suggest adding some tag to the objects you pass along, that signify that they where already evaluated and didn't change. Otherwise you will end up reassessing that they should remain unevaluated every time you pass them along. This problem can be seen for instance calling Trace[mysquare[7] // Sin] where the calculation needed to assert that mysquare should not evaluate will run twice.

Update

So just for kicks I tried to encapsulate this in a function, but since you need the condtional to wrap the code, I belive that it is not possible to keep a function only on the right hand side to carry this out (Someone correct me please if this can actually be done!). So what I did was create a function that transforms a function definition to include the Exception check condition:

 SetAttributes[noException, HoldAll]
   noException[f_[a_, b_]] /; (f === SetDelayed) := (SetDelayed[a, 
   Module[{n = Catch[b]}, n /; ! (n === stop)]])

Meaning you could carry out the above definition as:

  noException[mysquare[x_]:=(
     If[x < 0, Throw[stop]];
     a=Sqrt[x];
     If[x == 7, Throw[stop]];
     a
   )]

The parenthasis on the right hand of the definition is needed because of the way compound expressions is parsed, but can be omitted with a refined definition:

 noException2[
 CompoundExpression[f_[a_, b_], c__]] /; (f === SetDelayed) := 
  (SetDelayed[a, Module[{n = Catch[CompoundExpression[b, c]]}, n /; ! (n === stop)]])

Which corrects the error if you forget the parenthasis.