# Alpha conversion

### From HaskellWiki

(Difference between revisions)

(Can somebody word this better?) |
m |
||

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

Line 1: | Line 1: | ||

− | An ''alpha conversion'' (also written ''α conversion'') essentially involves 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 11: | Line 12: | ||

This is clearly the same function, even though it uses different variable names. This process of renaming variables is ''alpha conversion''. |
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. 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 radically different!) |
+ | 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]] |
||

+ | |||

+ | Also see [[Lambda calculus]] and the [http://en.wikipedia.org/wiki/Lambda_calculus wikipedia lambda calculus article]. |

## 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*.

*name capture*. For example, if we rename

x

y

\x -> x + y

\y -> y + y

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.