Difference between revisions of "Alpha conversion"

From HaskellWiki
Jump to navigation Jump to search
(Added throwaway remark about usage.)
m
 
(One intermediate revision by one other 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.

Haskell theoretical foundations

General:
Mathematics - Category theory
Research - Curry/Howard/Lambek

Lambda calculus:
Alpha conversion - Beta reduction
Eta conversion - Lambda abstraction

Other:
Recursion - Combinatory logic
Chaitin's construction - Turing machine
Relational algebra

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.