# Alpha conversion

### From HaskellWiki

(Difference between revisions)

(Added throwaway remark about usage.) |
m |
||

(One intermediate revision by one user 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 13: | Line 14: | ||

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.) |
+ | 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*.

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