# Difference between revisions of "Alpha conversion"

From HaskellWiki

BrettGiles (talk | contribs) (My 2 cents on wording.) |
m |
||

(2 intermediate revisions by 2 users not shown) | |||

Line 1: | Line 1: | ||

− | An ''alpha conversion'' (also written ''α conversion'') is a renaming variables. |
+ | An ''alpha conversion'' (also written ''α conversion'') is a renaming of variables. |

+ | {{Foundations infobox}} |
||

For example, suppose we have an expression such as |
For example, suppose we have an expression such as |
||

<haskell> |
<haskell> |
||

Line 12: | Line 13: | ||

Note that alpha conversion is not as simple as it first seems. We must be careful to avoid ''name capture''. For example, if we rename <hask>x</hask> to <hask>y</hask> in <hask>\x -> x + y</hask> then we end up with <hask>\y -> y + y</hask>, which is not the same function! |
Note that alpha conversion is not as simple as it first seems. We must be careful to avoid ''name capture''. For example, if we rename <hask>x</hask> to <hask>y</hask> in <hask>\x -> x + y</hask> then we end up with <hask>\y -> y + y</hask>, which is not the same function! |
||

+ | |||

+ | Some compilers include an alpha-conversion stage to rename all program variables such that variable names become unique. (This simplifies subsequent processing somewhat.) |
||

[[Category:Glossary]] |
[[Category:Glossary]] |

## Latest revision as of 18:23, 3 February 2007

An *alpha conversion* (also written *α conversion*) is a renaming of variables.

For example, suppose we have an expression such as

```
\x y -> 2*x*x + y
```

and we change this to

```
\a b -> 2*a*a + b
```

This is clearly the same function, even though it uses different variable names. This process of renaming variables is *alpha conversion*.

Note that alpha conversion is not as simple as it first seems. We must be careful to avoid *name capture*. For example, if we rename `x`

to `y`

in `\x -> x + y`

then we end up with `\y -> y + y`

, which is not the same function!

Some compilers include an alpha-conversion stage to rename all program variables such that variable names become unique. (This simplifies subsequent processing somewhat.)

Also see Lambda calculus and the wikipedia lambda calculus article.