Recursive data type

An example is the list type, in Haskell: data List a = Nil | Cons a (List a) This indicates that a list of a's is either an empty list or a cons cell containing an 'a' (the "head" of the list) and another list (the "tail"). Another example is a similar singly linked type in Java: public class LinkedList { private E value; private LinkedList next; // constructor and methods... } This indicates that non-empty list of type E contains a data member of type E, and a reference to another List object for the rest of the list (or a null reference to indicate that this is the end of the list). Mutually recursive data types Data types can also be defined by mutual recursion. The most important basic example of this is a tree, which can be defined mutually recursively in terms of a forest (a list of trees). Symbolically: f: [t[1], ..., t[k t: v f A forest f consists of a list of trees, while a tree t consists of a pair of a value v and a forest f (its children). This definition is elegant and easy to work with abstractly (such as when proving theorems about properties of trees), as it expresses a tree in simple terms: a list of one type, and a pair of two types. This mutually recursive definition can be converted to a singly recursive definition by inlining the definition of a forest: t: v [t[1], ..., t[k A tree t consists of a pair of a value v and a list of trees (its children). This definition is more compact, but somewhat messier: a tree consists of a pair of one type and a list another, which require disentangling to prove results about. In Standard ML, the tree and forest data types can be mutually recursively defined as follows, allowing empty trees: datatype 'a tree = Empty | Node of 'a * 'a forest and 'a forest = Nil | Cons of 'a tree * 'a forest In Haskell, the tree and forest data types can be defined similarly: data Tree a = Empty | Node (a, Forest a) data Forest a = Nil | Cons (Tree a) (Forest a) ==Theory==

In type theory, a recursive type has the general form μα.T where the type variable α may appear in the type T and stands for the entire type itself. For example, the natural numbers (see Peano arithmetic) may be defined by the Haskell datatype: data Nat = Zero | Succ Nat In type theory, we would say: \text{nat} = \mu \alpha. 1 + \alpha where the two arms of the sum type represent the Zero and Succ data constructors. Zero takes no arguments (thus represented by the unit type) and Succ takes another Nat (thus another element of \mu \alpha. 1 + \alpha). There are two forms of recursive types: the so-called isorecursive types, and equirecursive types. The two forms differ in how terms of a recursive type are introduced and eliminated. Isorecursive types With isorecursive types, the recursive type \mu \alpha . T and its expansion (or unrolling) T[\mu \alpha.T / \alpha] (where the notation X[Y/Z] indicates that all instances of Z are replaced with Y in X) are distinct (and disjoint) types with special term constructs, usually called roll and unroll, that form an isomorphism between them. To be precise: roll : T[\mu\alpha.T/\alpha] \to \mu\alpha.T and unroll : \mu\alpha.T \to T[\mu\alpha.T/\alpha], and these two are inverse functions. Equirecursive types Under equirecursive rules, a recursive type \mu \alpha . T and its unrolling T[\mu\alpha.T/\alpha] are equal – that is, those two type expressions are understood to denote the same type. In fact, most theories of equirecursive types go further and essentially specify that any two type expressions with the same "infinite expansion" are equivalent. As a result of these rules, equirecursive types contribute significantly more complexity to a type system than isorecursive types do. Algorithmic problems such as type checking and type inference are more difficult for equirecursive types as well. Since direct comparison does not make sense on an equirecursive type, they can be converted into a canonical form in O(n log n) time, which can easily be compared. Isorecursive types capture the form of self-referential (or mutually referential) type definitions seen in nominal object-oriented programming languages, and also arise in type-theoretic semantics of objects and classes. In functional programming languages, isorecursive types (in the guise of datatypes) are common too. ==Recursive type synonyms==

In TypeScript, recursion is allowed in type aliases. ==See also==