Using patterns in pure functions

Question

Pure functions may be handy if you don't want to assign your function a name. For example I would calculate $x(x-1)$ for some numbers $x$ by

In: #(#-1) & /@ {1, 2, 3}
Out: {0, 2, 6}

Is it possible to use patterns in this construction? For example something like

f[x_Integer] := x(x-1)

but then without defining a function f first.

Answer 1

You could write something like this:

# /. x_Integer :> x (x - 1) & /@ {1, 2, 3}

{0, 2, 6}

Answer 2

To complement WReach's answer, I suggest that you are actually looking for replacement rules. A function with patterns is effected with replacement rules:

f[x_Integer] := x(x-1)

DownValues[f]

{HoldPattern[f[x_Integer]] :> x (x - 1)}

You you don't need to actually set this definition (DownValue) to use the same rule.

Clear[f]

f /@ {1, 2, Sqrt[7], 0.3} /. {f[x_Integer] :> x (x - 1)}

{0, 2, f[Sqrt[7]], f[0.3]}

I suggest doing the replacement directly, and I recommend using Replace rather than ReplaceAll (/.) if you want something analogous to a pure function. Using /. would result in Sqrt[42] in this example:

Replace[{1, 2, Sqrt[7], 0.3}, {x_Integer :> x (x - 1), x_ :> f[x]}, {1}]

{0, 2, f[Sqrt[7]], f[0.3]}

You can of course do something else with arguments that do not match x_Integer besides wrapping in f. If you want a pure function to map onto individual elements you could use:

Replace[#, x_Integer :> x (x - 1)]& /@ {1, 2, Sqrt[7], 0.3}

{0, 2, Sqrt[7], 0.3}

Answer 3

Four ways from If:

If[IntegerQ@#, # (# - 1), #] & /@ {3, π}
 (* {6, π} *)

If[# ∈ Integers, # (# - 1), #] & /@ {3, π}
 (* {6, π} *)

If[Head@# === Integer, # (# - 1), #] & /@ {3, π}
 (* {6, π} *)

If[MatchQ[#, _Integer], # (# - 1), #] & /@ {3, π}
 (* {6, π} *)

The last two work also with user-defined heads. The 2nd argument to MatchQ can be any pattern.

If you like, you can return the pure function unevaluated on arguments that don't match the pattern:

If[MatchQ[#, _Integer], # (# - 1), Hold[#0][#]] & /@ {3, π}
 (* {6, Hold[If[MatchQ[#1, _Integer], #1 (#1 - 1), 
 Hold[#0][#1]] &][π]} *)

although I don't see a use for it.

I'm not advocating using If, just pointing out what is possible.

Answer 4

No, this is not possible, for the following reason (in my opinion):

When you define

f[x_Integer] := ...

and evaluate f[Pi] (where Pi is not of type Integer), then the function will stay unevaluated in the form f[Pi]. If you could use a pure function in the hypothetical form of Function[x_Integer, x(x+1)], then of course it could stay unevaluated in the form Function[x_Integer, x(x+1)][Pi], but I am not sure this would be useful. (Well, it might be if you pass it a symbol that you may later replace with an integer.)

Anyway, it is not possible.

There are some ways one can make use of patterns in pure functions (for example through replace rules). So now the question is: what do you want to achieve by using a pattern in a pure function? If it is preventing evaluation, it's not possible. If it's something else, it might be.

Answer 5

Map is unnecessary in this case, so the most succinct expression is:

{1, 2, 3} /. x_Integer :> x (x - 1)

Answer 6

This is very similar to the answer by Mr.Wizard, but avoids to introduce a named expression and therefore rewriting the function by using Condition:

Replace[_, {_ /; IntegerQ[#] :> # (# - 1), _ :> #}] & /@ {1, 2, 3, x}

{0, 2, 6, x}

---

A more direct way is to use Switch:

Switch[#,
   _Integer, # (# - 1),
   _, #] & /@ {1, 2, 3, x}

{0, 2, 6, x}

Answer 7

You can return a closure with encapsulated pattern-defined function using some custom assignment operator, like this one:

ClearAll[deff];
SetAttributes[deff, HoldAll];
deff[lhs_ :> rhs_] :=
  Module[{f},
    f[lhs] := rhs;
    f[##] &]

This can be trivially generalized to many rules. You can then use it as

With[{fn = deff[x_Integer :> x*(x - 1)]},
   Map[fn, Range[10]]]

(*    {0, 2, 6, 12, 20, 30, 42, 56, 72, 90}  *)

One problem you still have to solve in this approach is a proper garbage-collection of such functions. You may also want to use some form of memoization for deff, so that it does not produce a brand new pure function every time when called on the same rule (modulo pattern variables names). Both problems are solvable, if not completely trivial. Finally, note that wrapping in a pure function restricts the set of Attributes which can be used, since not all possible Attributes for symbols make sense for a pure function (I did not include attributes here for simplicity).

All in all, while I can see some cases where this may be nice to have, in most cases this is probably more work than it's worth. In fact, in the above approach, it is much easier for deff to return just the generated symbol f itself, which is probably a better solution if you want some auto-generated functions and don't want to bother with the naming. This will also automatically take care of the Attributes issue.

Answer 8

You can write a pure function whose application to an argument not matching the pattern you specified is returned unevaluated, using a trick with Defer and #0:

(If[MatchQ[_Integer][#1], #1 (#1 - 1), Evaluate[Defer][#0][#1]] &)[5]
(* 20 *)
(If[MatchQ[_Integer][#1], #1 (#1 - 1), Evaluate[Defer][#0][#1]] &)[x]
(* (If[MatchQ[_Integer][#1], #1 (#1 - 1), Evaluate[Defer][#0][#1]] &)[x] *)
(If[MatchQ[_Integer][#1], #1 (#1 - 1), Evaluate[Defer][#0][#1]] &)[1.5 + 2.7]
(* (If[MatchQ[_Integer][#1], #1 (#1 - 1), Evaluate[Defer][#0][#1]] &)[4.2] *)
FullForm[%]
(* Defer[Function[If[MatchQ[Blank[Integer]][Slot[1]], 
     Times[Slot[1], Plus[Slot[1], -1]], 
     Evaluate[Defer][Slot[0][Slot[1]]]]][0.1`]] *)

As you can see, there is a head Defer (invisible in the standard form) that is automatically stripped if you edit or copy the output and use it as a new input. If you edit the argument to be an integer (as required by the pattern) and evaluate the expression, it will evaluate to an integer, otherwise it will return unevaluated again.

---

Alternatively, you can construct a pure function that explicitly wraps its application into Hold if it is to stay unevaluated. Or you can use HoldForm that has the same effect as Hold, but it is not displayed in the standard form (although, unlike Defer, it is not stripped automatically if the output is edited or copied). Both Hold and HoldForm can be explicitly unwrapped using ReleaseHold:

(If[MatchQ[_Integer][#1], #1 (#1 - 1), Hold[#0[#1]]] &)[x]
(* Hold[(If[MatchQ[_Integer][#1], #1 (#1 - 1), Hold[#0[#1]]] &)[x]] *)
ReleaseHold[%]
(* evaluates to the same held result again *)
ReleaseHold[% /. x -> 5] (* substitute 5 as an argument before releasing hold )
( 20 *)

---

Or, you can use Inactivate instead, whose effect can be reversed by Activate:

(If[MatchQ[_Integer][#1], #1 (#1 - 1), Inactivate[#0][#1]] &)[x]
(* The result is displayed in the standard form as
(If[MatchQ[_Integer][#1], #1 × (#1 + -1), Inactivate[#0][#1]] &)[x]
with inactive symbols tan-colored, which is actually
Inactive[Function][
    Inactive[If][Inactive[MatchQ][_Integer][#1], 
     Inactive[Times][#1, Inactive[Plus][#1, -1]], 
      Inactive[Inactivate][#0][#1]]][x] *)
Activate[%]
(* evaluates to the same inactive result *)
Activate[% /. x -> 5] (* substitute 5 as an argument before activating )
( 20 *)

Answer 9

First make an Association between the Head of a your input and your input. The Keys of such Association will serve as the pattern:

#Integer (#Integer - 1) &@<|ToString@Head@# -> #|> & /@ {1, 2, 3}