# 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]] | ||

Also see [[Lambda calculus]] and the [http://en.wikipedia.org/wiki/Lambda_calculus wikipedia lambda calculus article]. | 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.