Question: [This question](https://mathematica.stackexchange.com/questions/2440/effective-matrix-power-like-algorithm) mentions "`x := x =` trickery".

What does defining a function as `f[x_] := f[x] = ...` do and what is it good for?

Answer: 
[Memoization](http://reference.wolfram.com/mathematica/tutorial/FunctionsThatRememberValuesTheyHaveFound.html) is perhaps the most common application, but it is not the *meaning* of that construct.

More generally it is a construct for a function that redefines itself. This has many uses beyond memoization. Consider this function:

```
f[y_] := (f[y] = Sequence[]; y)

```

It is used to remove duplicates in a list. When the function is first called with a particular argument (expression) it redefines itself, only for that argument, to `Sequence[]`. The next time it is applied to that expression it therefore resolves to `Sequence[]` (because the more specific definition has priority) and the expression is effectively removed. (Of course it must be [reinitialized](https://mathematica.stackexchange.com/a/2423/121) between lists unless you want to remove duplicates globally.)

```
f /@ {3, 5, 2, 3, 2, 4, 3}

```

> 
> 
> ```
> {3, 5, 2, 4}
> 
> ```
> 
> 

You can also write a function that changes its behavior after the first use.  

Note the different pattern name to avoid conflict.

```
g[x_] := (g[y_] := y - 1; x + 1)

g /@ {1, 2, 3}

```

> 
> 
> ```
> {2, 1, 2}
> 
> ```
> 
> 

This can even be nested deeper:

```
g[x_] := (g[y_] := (g[z_] := z + 4; y - 1); x + 1)

g /@ {1, 2, 3}

```

> 
> 
> ```
> {2, 1, 7}
> 
> ```
> 
> 

---

Syntax for memoization
----------------------

When using this construct for memoization it is often nice to use a named pattern for the entire left-hand-side, e.g.:

```
mem : f[x_] := mem = . . .

```

This is equivalent to `f[x_] := f[x] = . . .`. In this simple case it is not an improvement, but when the definition becomes longer it has the advantages of being:

* more concise
* less prone to error as there is less code to retype
* a convenient label for purpose of the construct

If one adopts this convention seeing `mem :` will immediately let one know this is a memoized function.

As a contrived example:

```
mem : combinations[set_Integer?Positive, choose_Integer?Positive] := 
  mem = set!/(choose! (set - choose)!)

```

Memoization is not the only application of a pattern that matches the entire left-hand-side and by using consistent pattern names for each application one can impart valuable metadata about the nature of the code to follow.

Reference:

* [How does a construct like `i : func[arg\_] := i = an expression using arg` work?](https://mathematica.stackexchange.com/q/119035/121)
It's ... oh, why not let the docs speak:

[tutorial/FunctionsThatRememberValuesTheyHaveFound](http://reference.wolfram.com/mathematica/tutorial/FunctionsThatRememberValuesTheyHaveFound.html)

(in Doc center)

**Edit**

You may also find additional information by searching for "memoization" on this site. This has always been a great trick to avoid having to re-evaluate the result of a computationally intensive function call. In the above link, it is also used to do recursion.

I'll try to explain things without the added complication of recursion: The basic idea is that when you define a function using

```
f[x_]:= x^2

```

you are using `x` as the name of a pattern playing the role of a dummy variable. The `:=` (meaning `SetDelayed`) has the property of leaving whatever is on the right-hand side *unevaluated* until it's needed, and this happens when a pattern matching the left side is encountered, say, `f[4]`. 

To make Mathematica remember things, you can't assign a value to a pattern, so you would normally say

```
f[4]=16

```

Now such definitions are found by Mathematica *before* it looks for matching pattern definitions such as `f[x_]:=x^2` above. So in other words, if I type `f[4]` after having executed the above two lines, my "function definition" doesn't actually have to be used at all because the system already knows the result for the specific value `4`. 

The memoization trick now combines the above lines, which would lead to

```
f[x_]:=f[x]=x^2

```

The right-hand side of `SetDelayed` is now telling us to take whatever was passed in through the dummy variable `x` and assign this to `f[x]` using `Set` (the `=` sign). The result of that last operation is that a "non-pattern" `f[x]` with a specific new value of `x` has been defined for later use, and the value that got assigned to that is also returned as the replacement for the pattern `f[x_]` (i.e., the function value in the initial function call). 

Whenever a new `x` is passed to `f[x]`, we now get a new "permanent" definition added to the memory so that the function (the pattern) doesn't need to be evaluated again for that `x`. 

It's best to play around with this yourself by defining a function along the lines above, and then periodically checking what Mathematica knows about your function by typing `?f`.