Abstract data type

<h2 id="history">History</h2>
ADTs were first proposed by <a href="/facts/Barbara_Liskov/EgjpztD5">Barbara Liskov</a> and Stephen N. Zilles in 1974, as part of the development of the <a href="/facts/CLU_(programming_language)/419zw4k9">CLU</a> language.<a class="footnote-ref" id="fnref:2" href="#fn:2">2</a> <a href="/facts/Algebraic_specification/uryGMv1W">Algebraic specification</a> was an important subject of research in CS around 1980 and almost a synonym for abstract data types at that time.<a class="footnote-ref" id="fnref:3" href="#fn:3">3</a> It has a mathematical foundation in <a href="/facts/Universal_algebra/uMJAL6ER">universal algebra</a>.<a class="footnote-ref" id="fnref:4" href="#fn:4">4</a>

<h2 id="definition">Definition</h2>
Formally, an ADT is analogous to an <a href="/facts/Algebraic_structure/TkuXca24">algebraic structure</a> in mathematics,<a class="footnote-ref" id="fnref:5" href="#fn:5">5</a> consisting of a domain, a collection of operations, and a set of constraints the operations must satisfy.<a class="footnote-ref" id="fnref:6" href="#fn:6">6</a> The domain is often defined implicitly, for example the <a href="/facts/Free_object/VxL28y8B">free object</a> over the set of ADT operations. The <a href="/facts/Interface_(computer_science)/zdfp8unT">interface</a> of the ADT typically refers only to the domain and operations, and perhaps some of the constraints on the operations, such as pre-conditions and post-conditions; but not to other constraints, such as relations between the operations, which are considered behavior. There are two main styles of formal specifications for behavior, <a href="/facts/Axiomatic_semantics/m7NWmGoV">axiomatic semantics</a> and <a href="/facts/Operational_semantics/G24LXz6e">operational semantics</a>.<a class="footnote-ref" id="fnref:7" href="#fn:7">7</a>
Despite not being part of the interface, the constraints are still important to the definition of the ADT; for example a <a href="/facts/Stack_(abstract_data_type)/bj7l94v1">stack</a> and a <a href="/facts/Queue_(abstract_data_type)/hVPjPXus">queue</a> have similar add element/remove element interfaces, but it is the constraints that distinguish last-in-first-out from first-in-first-out behavior. The constraints do not consist only of equations such as fetch(store(S,v))=v but also <a href="/facts/Logical_formula/YpTVlzuj">logical formulas</a>.

<h3>Operational semantics</h3>
In the spirit of <a href="/facts/Imperative_programming/6b5dUnE1">imperative programming</a>, an abstract data structure is conceived as an entity that is mutable—meaning that there is a notion of time and the ADT may be in different states at different times. Operations then change the state of the ADT over time; therefore, the order in which operations are evaluated is important, and the same operation on the same entities may have different effects if executed at different times. This is analogous to the instructions of a computer or the commands and procedures of an imperative language. To underscore this view, it is customary to say that the operations are executed or applied, rather than evaluated, similar to the imperative style often used when describing abstract algorithms. The constraints are typically specified in prose.

<h3>Auxiliary operations</h3>
Presentations of ADTs are often limited in scope to only key operations. More thorough presentations often specify auxiliary operations on ADTs, such as:

<ul><li>create(), that yields a new instance of the ADT;</li>
<li>compare(s, t), that tests whether two instances' states are equivalent in some sense;</li>
<li>hash(s), that computes some standard <a href="/facts/Hash_function/rk6MlCt3">hash function</a> from the instance's state;</li>
<li>print(s) or show(s), that produces a human-readable representation of the instance's state.</li></ul>
These names are illustrative and may vary between authors. In imperative-style ADT definitions, one often finds also:

<ul><li>initialize(s), that prepares a newly created instance s for further operations, or resets it to some "initial state";</li>
<li>copy(s, t), that puts instance s in a state equivalent to that of t;</li>
<li>clone(t), that performs s ← create(), copy(s, t), and returns s;</li>
<li>free(s) or destroy(s), that reclaims the memory and other resources used by s.</li></ul>
The free operation is not normally relevant or meaningful, since ADTs are theoretical entities that do not "use memory". However, it may be necessary when one needs to analyze the storage used by an algorithm that uses the ADT. In that case, one needs additional axioms that specify how much memory each ADT instance uses, as a function of its state, and how much of it is returned to the pool by free.

<h3>Restricted types</h3>
The definition of an ADT often restricts the stored value(s) for its instances, to members of a specific set X called the range of those variables. For example, an abstract variable may be constrained to only store integers. As in programming languages, such restrictions may simplify the description and <a href="/facts/Analysis_of_algorithms/pStoBgBn">analysis of algorithms</a>, and improve its readability.

<h3>Aliasing</h3>
In the operational style, it is often unclear how multiple instances are handled and if modifying one instance may affect others. A common style of defining ADTs writes the operations as if only one instance exists during the execution of the algorithm, and all operations are applied to that instance. For example, a stack may have operations push(x) and pop(), that operate on the only existing stack. ADT definitions in this style can be easily rewritten to admit multiple coexisting instances of the ADT, by adding an explicit instance parameter (like S in the stack example below) to every operation that uses or modifies the implicit instance. Some ADTs cannot be meaningfully defined without allowing multiple instances, for example when a single operation takes two distinct instances of the ADT as parameters, such as a union operation on sets or a compare operation on lists.
The multiple instance style is sometimes combined with an <a href="/facts/Aliasing_(computing)/C7wT3dQy">aliasing</a> axiom, namely that the result of create() is distinct from any instance already in use by the algorithm. Implementations of ADTs may still reuse memory and allow implementations of create() to yield a previously created instance; however, defining that such an instance even is "reused" is difficult in the ADT formalism.
More generally, this axiom may be strengthened to exclude also partial aliasing with other instances, so that composite ADTs (such as trees or records) and reference-style ADTs (such as pointers) may be assumed to be completely disjoint. For example, when extending the definition of an abstract variable to include abstract <a href="/facts/Record_(computer_science)/1fvSgenB">records</a>, operations upon a field F of a record variable R, clearly involve F, which is distinct from, but also a part of, R. A partial aliasing axiom would state that changing a field of one record variable does not affect any other records.

<h3>Complexity analysis</h3>
Some authors also include the <a href="/facts/Computational_complexity_theory/etHuVF3U">computational complexity</a> ("cost") of each operation, both in terms of time (for computing operations) and space (for representing values), to aid in <a href="/facts/Analysis_of_algorithms/pStoBgBn">analysis of algorithms</a>. For example, one may specify that each operation takes the same time and each value takes the same space regardless of the state of the ADT, or that there is a "size" of the ADT and the operations are linear, quadratic, etc. in the size of the ADT. <a href="/facts/Alexander_Stepanov/znVUvH2I">Alexander Stepanov</a>, designer of the C++ <a href="/facts/Standard_Template_Library/IxqpRzWU">Standard Template Library</a>, included complexity guarantees in the STL specification, arguing:

<blockquote>The reason for introducing the notion of abstract data types was to allow interchangeable software modules. You cannot have interchangeable modules unless these modules share similar complexity behavior. If I replace one module with another module with the same functional behavior but with different complexity tradeoffs, the user of this code will be unpleasantly surprised. I could tell him anything I like about data abstraction, and he still would not want to use the code. Complexity assertions have to be part of the interface.— Alexander Stepanov<a class="footnote-ref" id="fnref:8" href="#fn:8">8</a></blockquote>
Other authors disagree, arguing that a stack ADT is the same whether it is implemented with a linked list or an array, despite the difference in operation costs, and that an ADT specification should be independent of implementation.

<h2 id="examples">Examples</h2>
<h3>Abstract variable</h3>
An abstract variable may be regarded as the simplest non-trivial ADT, with the semantics of an imperative variable. It admits two operations, fetch and store. Operational definitions are often written in terms of abstract variables. In the axiomatic semantics, letting 
 
 
 
 V
 
 
 {\displaystyle V}
 
 be the type of the abstract variable and 
 
 
 
 X
 
 
 {\displaystyle X}
 
 be the type of its contents, fetch is a function 
 
 
 
 V
 →
 X
 
 
 {\displaystyle V\to X}
 
 and store is a function of type 
 
 
 
 V
 →
 X
 →
 V
 
 
 {\displaystyle V\to X\to V}
 
. The main constraint is that fetch always returns the value x used in the most recent store operation on the same variable V, i.e. fetch(store(V,x)) = x. We may also require that store overwrites the value fully, store(store(V,x1),x2) = store(V,x2).
In the operational semantics, fetch(V) is a procedure that returns the current value in the location V, and store(V, x) is a procedure with void return type that stores the value x in the location V. The constraints are described informally as that reads are consistent with writes. As in many programming languages, the operation store(V, x) is often written V ← x (or some similar notation), and fetch(V) is implied whenever a variable V is used in a context where a value is required. Thus, for example, V ← V + 1 is commonly understood to be a shorthand for store(V,fetch(V) + 1).
In this definition, it is implicitly assumed that names are always distinct: storing a value into a variable U has no effect on the state of a distinct variable V. To make this assumption explicit, one could add the constraint that:

<ul><li>if U and V are distinct variables, the sequence { store(U, x); store(V, y) } is equivalent to { store(V, y); store(U, x) }.</li></ul>
This definition does not say anything about the result of evaluating fetch(V) when V is un-initialized, that is, before performing any store operation on V. Fetching before storing can be disallowed, defined to have a certain result, or left unspecified. There are some algorithms whose efficiency depends on the assumption that such a fetch is legal, and returns some arbitrary value in the variable's range.

<h3>Abstract stack</h3>
An abstract <a href="/facts/Stack_(abstract_data_type)/bj7l94v1">stack</a> is a last-in-first-out structure, It is generally defined by three key operations: push, that inserts a data item onto the stack; pop, that removes a data item from it; and peek or top, that accesses a data item on top of the stack without removal. A complete abstract stack definition includes also a <a href="/facts/Boolean_value/0GWYLDoC">Boolean</a>-valued function empty(S) and a create() operation that returns an initial stack instance.
In the axiomatic semantics, letting 
 
 
 
 S
 
 
 {\displaystyle S}
 
 be the type of stack states and 
 
 
 
 X
 
 
 {\displaystyle X}
 
 be the type of values contained in the stack, these could have the types 
 
 
 
 p
 u
 s
 h
 :
 S
 →
 X
 →
 S
 
 
 {\displaystyle push:S\to X\to S}
 
, 
 
 
 
 p
 o
 p
 :
 S
 →
 (
 S
 ,
 X
 )
 
 
 {\displaystyle pop:S\to (S,X)}
 
, 
 
 
 
 t
 o
 p
 :
 S
 →
 X
 
 
 {\displaystyle top:S\to X}
 
, 
 
 
 
 c
 r
 e
 a
 t
 e
 :
 S
 
 
 {\displaystyle create:S}
 
, and 
 
 
 
 e
 m
 p
 t
 y
 :
 S
 →
 
 B
 
 
 
 {\displaystyle empty:S\to \mathbb {B} }
 
. In the axiomatic semantics, creating the initial stack is a "trivial" operation, and always returns the same distinguished state. Therefore, it is often designated by a special symbol like <a href="/facts/Lambda/ykr3WSse">Λ</a> or "()". The empty operation predicate can then be written simply as 
 
 
 
 s
 =
 Λ
 
 
 {\displaystyle s=\Lambda }
 
 or 
 
 
 
 s
 ≠
 Λ
 
 
 {\displaystyle s\neq \Lambda }
 
.
The constraints are then pop(push(S,v))=(S,v), top(push(S,v))=v,<a class="footnote-ref" id="fnref:9" href="#fn:9">9</a> empty(create) = T (a newly created stack is empty), empty(push(S, x)) = F (pushing something into a stack makes it non-empty). These axioms do not define the effect of top(s) or pop(s), unless s is a stack state returned by a push. Since push leaves the stack non-empty, those two operations can be defined to be invalid when s = Λ. From these axioms (and the lack of side effects), it can be deduced that push(Λ, x) ≠ Λ. Also, push(s, x) = push(t, y) <a href="/facts/If_and_only_if/bYSxGJ66">if and only if</a> x = y and s = t.
As in some other branches of mathematics, it is customary to assume also that the stack states are only those whose existence can be proved from the axioms in a finite number of steps. In this case, it means that every stack is a finite sequence of values, that becomes the empty stack (Λ) after a finite number of pops. By themselves, the axioms above do not exclude the existence of infinite stacks (that can be popped forever, each time yielding a different state) or circular stacks (that return to the same state after a finite number of pops). In particular, they do not exclude states s such that pop(s) = s or push(s, x) = s for some x. However, since one cannot obtain such stack states from the initial stack state with the given operations, they are assumed "not to exist".
In the operational definition of an abstract stack, push(S, x) returns nothing and pop(S) yields the value as the result but not the new state of the stack. There is then the constraint that, for any value x and any abstract variable V, the sequence of operations { push(S, x); V ← pop(S) } is equivalent to V ← x. Since the assignment V ← x, by definition, cannot change the state of S, this condition implies that V ← pop(S) restores S to the state it had before the push(S, x). From this condition and from the properties of abstract variables, it follows, for example, that the sequence:

{ push(S, x); push(S, y); U ← pop(S); push(S, z); V ← pop(S); W ← pop(S) }
where x, y, and z are any values, and U, V, W are pairwise distinct variables, is equivalent to:

{ U ← y; V ← z; W ← x }
Unlike the axiomatic semantics, the operational semantics can suffer from aliasing. Here it is implicitly assumed that operations on a stack instance do not modify the state of any other ADT instance, including other stacks; that is:

<ul><li>For any values x, y, and any distinct stacks S and T, the sequence { push(S, x); push(T, y) } is equivalent to { push(T, y); push(S, x) }.</li></ul>
<h3>Boom hierarchy</h3>
A more involved example is the Boom hierarchy of the <a href="/facts/Binary_tree/TDV7GMpu">binary tree</a>, <a href="/facts/List_(abstract_data_type)/9tzhAH6M">list</a>, <a href="/facts/Set_(abstract_data_type)/ovoXUmF9">bag</a> and <a href="/facts/Set_(computer_science)/ovoXUmF9">set</a> abstract data types.<a class="footnote-ref" id="fnref:10" href="#fn:10">10</a> All these data types can be declared by three operations: null, which constructs the empty container, single, which constructs a container from a single element and append, which combines two containers of the same type. The complete specification for the four data types can then be given by successively adding the following rules over these operations:

<table><tbody><tr><td>null is the left and right neutral for a tree</td><td>append(null,A) = A, append(A,null) = A.</td></tr><tr><td>lists add that append is associative</td><td>append(append(A,B),C) = append(A,append(B,C)).</td></tr><tr><td>bags add commutativit</td><td>append(B,A) = append(A,B).</td></tr><tr><td>finally, sets are also idempotent</td><td>append(A,A) = A.</td></tr></tbody></table>
Access to the data can be specified by pattern-matching over the three operations, e.g. a member function for these containers by:

<table><tbody><tr><td>member(X,single(Y)) = eq(X,Y)</td></tr><tr><td>member(X,null) = false</td></tr><tr><td>member(X,append(A,B)) = or(member(X,A), member(X,B))</td></tr></tbody></table>
Care must be taken to ensure that the function is invariant under the relevant rules for the data type. Within each of the equivalence classes implied by the chosen subset of equations, it has to yield the same result for all of its members.

<h3>Common ADTs</h3>
Some common ADTs, which have proved useful in a great variety of applications, are

<ul><li><a href="/facts/Collection_(abstract_data_type)/KdjDzR7v">Collection</a></li>
<li><a href="/facts/Container_(abstract_data_type)/gsC5UcqD">Container</a></li>
<li><a href="/facts/List_(abstract_data_type)/9tzhAH6M">List</a></li>
<li><a href="/facts/String_(computer_science)/4ChJu5WS">String</a></li>
<li><a href="/facts/Set_(abstract_data_type)/ovoXUmF9">Set</a></li>
<li><a href="/facts/Multiset/bPFJGMDo">Multiset</a></li>
<li><a href="/facts/Associative_array/IFGd2xcP">Map</a></li>
<li><a href="/facts/Multimap/v3kbRyrF">Multimap</a></li>
<li><a href="/facts/Graph_(abstract_data_type)/b8qcddXa">Graph</a></li>
<li><a href="/facts/Tree_(data_structure)/RcXz9noF">Tree</a></li>
<li><a href="/facts/Stack_(abstract_data_type)/bj7l94v1">Stack</a></li>
<li><a href="/facts/Queue_(abstract_data_type)/hVPjPXus">Queue</a></li>
<li><a href="/facts/Priority_queue/1uXVo4Uf">Priority queue</a></li>
<li><a href="/facts/Double-ended_queue/pQboJcly">Double-ended queue</a></li>
<li><a href="/facts/Double-ended_priority_queue/ovYgERoT">Double-ended priority queue</a></li></ul>

Each of these ADTs may be defined in many ways and variants, not necessarily equivalent. For example, an abstract stack may or may not have a count operation that tells how many items have been pushed and not yet popped. This choice makes a difference not only for its clients but also for the implementation.

Abstract graphical data type
An extension of ADT for computer graphics was proposed in 1979:<a class="footnote-ref" id="fnref:11" href="#fn:11">11</a> an <a href="/facts/Abstract_graphical_data_type/pmWHNSxj">abstract graphical data type</a> (AGDT). It was introduced by <a href="/facts/Nadia_Magnenat_Thalmann/duQM5kJC">Nadia Magnenat Thalmann</a>, and <a href="/facts/Daniel_Thalmann/JkJe6Bof">Daniel Thalmann</a>. AGDTs provide the advantages of ADTs with facilities to build graphical objects in a structured way.

<h2 id="implementation">Implementation</h2>
Abstract data types are theoretical entities, used (among other things) to simplify the description of abstract algorithms, to classify and evaluate data structures, and to formally describe the <a href="/facts/Type_system/Tz0bAMS9">type systems</a> of programming languages. However, an ADT may be <a href="/facts/Implementation/IH1KXgP3">implemented</a>. This means each ADT instance or state is represented by some concrete <a href="/facts/Data_type/fcx5hgVL">data type</a> or <a href="/facts/Data_structure/yNsNvL1I">data structure</a>, and for each abstract operation there is a corresponding <a href="/facts/Subroutine/9vFJrg0A">procedure or function</a>, and these implemented procedures satisfy the ADT's specifications and axioms up to some standard. In practice, the implementation is not perfect, and users must be aware of issues due to limitations of the representation and implemented procedures.
For example, <a href="/facts/Integer/PUwwrawx">integers</a> may be specified as an ADT, defined by the distinguished values 0 and 1, the operations of addition, subtraction, multiplication, division (with care for division by zero), comparison, etc., behaving according to the familiar mathematical axioms in abstract algebra such as associativity, commutativity, and so on. However, in a computer, integers are most commonly represented as fixed-width <a href="/facts/32-bit_computing/TDMVce8s">32-bit</a> or <a href="/facts/64-bit_computing/AgvkQHkM">64-bit</a> <a href="/facts/Binary_number/a6JDSRPs">binary numbers</a>. Users must be aware of issues with this representation, such as <a href="/facts/Arithmetic_overflow/sVNnSolT">arithmetic overflow</a>, where the ADT specifies a valid result but the representation is unable to accommodate this value. Nonetheless, for many purposes, the user can ignore these infidelities and simply use the implementation as if it were the abstract data type.
Usually, there are many ways to implement the same ADT, using several different concrete data structures. Thus, for example, an abstract stack can be implemented by a <a href="/facts/Linked_list/Ik4JTgJW">linked list</a> or by an <a href="/facts/Array_data_structure/BKGvF8AM">array</a>. Different implementations of the ADT, having all the same properties and abilities, can be considered semantically equivalent and may be used somewhat interchangeably in code that uses the ADT. This provides a form of <a href="/facts/Abstraction_(computer_science)/hAnxmJle">abstraction</a> or encapsulation, and gives a great deal of flexibility when using ADT objects in different situations. For example, different implementations of the ADT may be more efficient in different situations; it is possible to use each in the situation where they are preferable, thus increasing overall efficiency. Code that uses an ADT implementation according to its interface will continue working even if the implementation of the ADT is changed.
In order to prevent clients from depending on the implementation, an ADT is often packaged as an <a href="/facts/Opaque_data_type/yMAgh1Kj">opaque data type</a> or <a href="/facts/Handle_(computing)/gKL1X2sX">handle</a> of some sort,<a class="footnote-ref" id="fnref:12" href="#fn:12">12</a> in one or more <a href="/facts/Module_(programming)/sNoqKvRD">modules</a>, whose interface contains only the signature (number and types of the parameters and results) of the operations. The implementation of the module—namely, the bodies of the procedures and the concrete data structure used—can then be hidden from most clients of the module. This makes it possible to change the implementation without affecting the clients. If the implementation is exposed, it is known instead as a transparent data type.
Modern object-oriented languages, such as <a href="/facts/C%252B%252B/Et0F2qn9">C++</a> and <a href="/facts/Java_programming_language/9ScgFyAL">Java</a>, support a form of abstract data types. When a class is used as a type, it is an abstract type that refers to a hidden representation. In this model, an ADT is typically implemented as a <a href="/facts/Class_(computer_science)/zvzkSAtE">class</a>, and each instance of the ADT is usually an <a href="/facts/Object_(computer_science)/eX99dtAw">object</a> of that class. The module's interface typically declares the constructors as ordinary procedures, and most of the other ADT operations as <a href="/facts/Method_(computer_programming)/8kAXxVYs">methods</a> of that class. Many modern programming languages, such as C++ and Java, come with standard libraries that implement numerous ADTs in this style. However, such an approach does not easily encapsulate multiple representational variants found in an ADT. It also can undermine the extensibility of object-oriented programs. In a pure object-oriented program that uses interfaces as types, types refer to behaviours, not representations.
The specification of some programming languages is intentionally vague about the representation of certain built-in data types, defining only the operations that can be done on them. Therefore, those types can be viewed as "built-in ADTs". Examples are the arrays in many scripting languages, such as <a href="/facts/Awk/lAQ0leyj">Awk</a>, <a href="/facts/Lua/N9uxzpWK">Lua</a>, and <a href="/facts/Perl/fx31kjlT">Perl</a>, which can be regarded as an implementation of the abstract list.
In a <a href="/facts/Formal_specification_language/vqNInfdh">formal specification language</a>, ADTs may be defined axiomatically, and the language then allows manipulating values of these ADTs, thus providing a straightforward and immediate implementation. The <a href="/facts/OBJ_(programming_language)/Szx6UMoD">OBJ</a> family of programming languages for instance allows defining <a href="/facts/Equation/pxFzLAVR">equations</a> for specification and <a href="/facts/Rewriting/9PHlnnnJ">rewriting</a> to run them. Such automatic implementations are usually not as efficient as dedicated implementations, however.

<h3>Example: implementation of the abstract stack</h3>
As an example, here is an implementation of the abstract stack above in the <a href="/facts/C_(programming_language)/Ky2No763">C programming language</a>.

<h4>Imperative-style interface</h4>
An imperative-style interface might be:

typedef struct stack_Rep stack_Rep; // type: stack instance representation (opaque record)
typedef stack_Rep* stack_T; // type: handle to a stack instance (opaque pointer)
typedef void* stack_Item; // type: value stored in stack instance (arbitrary address)

stack_T stack_create(void);               // creates a new empty stack instance
void stack_push(stack_T s, stack_Item x); // adds an item at the top of the stack
stack_Item stack_pop(stack_T s);          // removes the top item from the stack and returns it
bool stack_empty(stack_T s);              // checks whether stack is empty

This interface could be used in the following manner:

#include <stack.h> // includes the stack interface

stack_T s = stack_create(); // creates a new empty stack instance
int x = 17;
stack_push(s, &x);          // adds the address of x at the top of the stack
void* y = stack_pop(s);     // removes the address of x from the stack and returns it
if (stack_empty(s)) { }     // does something if stack is empty

This interface can be implemented in many ways. The implementation may be arbitrarily inefficient, since the formal definition of the ADT, above, does not specify how much space the stack may use, nor how long each operation should take. It also does not specify whether the stack state s continues to exist after a call x ← pop(s).
In practice the formal definition should specify that the space is proportional to the number of items pushed and not yet popped; and that every one of the operations above must finish in a constant amount of time, independently of that number. To comply with these additional specifications, the implementation could use a linked list, or an array (with dynamic resizing) together with two integers (an item count and the array size).

<h4>Functional-style interface</h4>
Functional-style ADT definitions are more appropriate for functional programming languages, and vice versa. However, one can provide a functional-style interface even in an imperative language like C. For example:

typedef struct stack_Rep stack_Rep; // type: stack state representation (opaque record)
typedef stack_Rep* stack_T; // type: handle to a stack state (opaque pointer)
typedef void* stack_Item; // type: value of a stack state (arbitrary address)

stack_T stack_empty(void);                   // returns the empty stack state
stack_T stack_push(stack_T s, stack_Item x); // adds an item at the top of the stack state and returns the resulting stack state
stack_T stack_pop(stack_T s);                // removes the top item from the stack state and returns the resulting stack state
stack_Item stack_top(stack_T s);             // returns the top item of the stack state

<h2 id="see-also">See also</h2>
<ul><li><a href="/facts/Concept_(generic_programming)/fCkxQo4W">Concept (generic programming)</a></li>
<li><a href="/facts/Formal_methods/tw4FCWIb">Formal methods</a></li>
<li><a href="/facts/Functional_specification/8TVokFw6">Functional specification</a></li>
<li><a href="/facts/Generalized_algebraic_data_type/c2tQGjcq">Generalized algebraic data type</a></li>
<li><a href="/facts/Initial_algebra/KbryBRxs">Initial algebra</a></li>
<li><a href="/facts/Liskov_substitution_principle/r2vHVwa5">Liskov substitution principle</a></li>
<li><a href="/facts/Type_theory/xj0xzVqI">Type theory</a></li>
<li><a href="/facts/Walls_and_Mirrors/AuW8TfPW">Walls and Mirrors</a></li></ul>
<h2 id="notes">Notes</h2>

<h2 id="citations">Citations</h2>

<ul><li><a href="/facts/Barbara_Liskov/EgjpztD5">Liskov, Barbara</a>; Zilles, Stephen (1974). "Programming with abstract data types". Proceedings of the ACM SIGPLAN Symposium on Very High Level Languages. SIGPLAN Notices. Vol. 9. pp. 50–59. <a href="/facts/CiteSeerX_(identifier)/SceDmd3c">CiteSeerX</a> <a href="https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.136.3043">10.1.1.136.3043</a>. <a href="/facts/Doi_(identifier)/muM9Etpq">doi</a>:<a href="https://doi.org/10.1145%2F800233.807045">10.1145/800233.807045</a>.</li>
<li>Dale, Nell; Walker, Henry M. (1996). Abstract Data Types: Specifications, Implementations, and Applications. Jones & Bartlett Learning. <a href="/facts/ISBN_(identifier)/15AdSPa9">ISBN</a> 978-0-66940000-7.</li></ul>

<h2 id="further-reading">Further reading</h2>
<ul><li><a href="/facts/John_C._Mitchell/8tzw9FNg">Mitchell, John C.</a>; <a href="/facts/Gordon_Plotkin/2CrnVkVj">Plotkin, Gordon</a> (July 1988). <a href="http://theory.stanford.edu/~jcm/papers/mitch-plotkin-88.pdf">"Abstract Types Have Existential Type"</a> (PDF). ACM Transactions on Programming Languages and Systems. 10 (3): 470–502. <a href="/facts/Doi_(identifier)/muM9Etpq">doi</a>:<a href="https://doi.org/10.1145%2F44501.45065">10.1145/44501.45065</a>. <a href="/facts/S2CID_(identifier)/ldJsHa2Y">S2CID</a> <a href="https://api.semanticscholar.org/CorpusID:1222153">1222153</a>. <a href="https://ghostarchive.org/archive/20221009/http://theory.stanford.edu/~jcm/papers/mitch-plotkin-88.pdf">Archived</a> (PDF) from the original on 2022-10-09.</li></ul>
<h2 id="external-links">External links</h2>
<ul><li> Media related to Abstract data types at Wikimedia Commons</li>
<li><a href="https://xlinux.nist.gov/dads/HTML/abstractDataType.html">Abstract data type</a> in <a href="/facts/NIST/gr9Fnh85">NIST</a> Dictionary of Algorithms and Data Structures</li></ul>

<h2 id="references">References</h2>

<ol>
<li id="fn:1">"Reading 10: Abstract Data Types". MIT. <a href="https://web.mit.edu/6.031/www/sp21/classes/10-abstract-data-types/" target="_blank">https://web.mit.edu/6.031/www/sp21/classes/10-abstract-data-types/</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></li>
<li id="fn:2">Liskov & Zilles 1974. - Liskov, Barbara; Zilles, Stephen (1974). "Programming with abstract data types". Proceedings of the ACM SIGPLAN Symposium on Very High Level Languages. SIGPLAN Notices. Vol. 9. pp. 50–59. CiteSeerX 10.1.1.136.3043. doi:10.1145/800233.807045. <a href="https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.136.3043" target="_blank">https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.136.3043</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></li>
<li id="fn:3">Ehrig, H. (1985). Fundamentals of Algebraic Specification 1 - Equations and Initial Semantics. Springer-Verlag. ISBN 0-387-13718-1. <a href="0-387-13718-1" target="_blank">0-387-13718-1</a> <a href="#fnref:3" class="footnote-back-ref">↩</a></li>
<li id="fn:4">Wechler, Wolfgang (1992). Universal Algebra for Computer Scientists. Springer-Verlag. ISBN 0-387-54280-9. <a href="0-387-54280-9" target="_blank">0-387-54280-9</a> <a href="#fnref:4" class="footnote-back-ref">↩</a></li>
<li id="fn:5">Rudolf Lidl (2004). Abstract Algebra. Springer. ISBN 978-81-8128-149-4., Chapter 7, section 40. <a href="978-81-8128-149-4" target="_blank">978-81-8128-149-4</a> <a href="#fnref:5" class="footnote-back-ref">↩</a></li>
<li id="fn:6">Dale & Walker 1996, p. 3. - Dale, Nell; Walker, Henry M. (1996). Abstract Data Types: Specifications, Implementations, and Applications. Jones & Bartlett Learning. ISBN 978-0-66940000-7. <a href="#fnref:6" class="footnote-back-ref">↩</a></li>
<li id="fn:7">Dale & Walker 1996, p. 4. - Dale, Nell; Walker, Henry M. (1996). Abstract Data Types: Specifications, Implementations, and Applications. Jones & Bartlett Learning. ISBN 978-0-66940000-7. <a href="#fnref:7" class="footnote-back-ref">↩</a></li>
<li id="fn:8">Stevens, Al (March 1995). "Al Stevens Interviews Alex Stepanov". Dr. Dobb's Journal. Retrieved 31 January 2015. <a href="http://www.sgi.com/tech/stl/drdobbs-interview.html" target="_blank">http://www.sgi.com/tech/stl/drdobbs-interview.html</a> <a href="#fnref:8" class="footnote-back-ref">↩</a></li>
<li id="fn:9">Black, Paul E. (24 August 2005). "axiomatic semantics". Dictionary of Algorithms and Data Structures. Retrieved 25 November 2023. <a href="https://xlinux.nist.gov/dads/HTML/axiomaticSemantics.html" target="_blank">https://xlinux.nist.gov/dads/HTML/axiomaticSemantics.html</a> <a href="#fnref:9" class="footnote-back-ref">↩</a></li>
<li id="fn:10">Bunkenburg, Alexander (1994). "The Boom Hierarchy". Functional Programming, Glasgow 1993. Workshops in Computing: 1–8. CiteSeerX 10.1.1.49.3252. doi:10.1007/978-1-4471-3236-3_1. ISBN 978-3-540-19879-6. <a href="978-3-540-19879-6" target="_blank">978-3-540-19879-6</a> <a href="#fnref:10" class="footnote-back-ref">↩</a></li>
<li id="fn:11">D. Thalmann, N. Magnenat Thalmann (1979). Design and Implementation of Abstract Graphical Data Types. IEEE. doi:10.1109/CMPSAC.1979.762551., Proc. 3rd International Computer Software and Applications Conference (COMPSAC'79), IEEE, Chicago, USA, pp.519-524 <a href="/wiki/Doi_(identifier)" target="_blank">/wiki/Doi_(identifier)</a> <a href="#fnref:11" class="footnote-back-ref">↩</a></li>
<li id="fn:12">Robert Sedgewick (1998). Algorithms in C. Addison/Wesley. ISBN 978-0-201-31452-6., definition 4.4. <a href="978-0-201-31452-6" target="_blank">978-0-201-31452-6</a> <a href="#fnref:12" class="footnote-back-ref">↩</a></li>
</ol>

Abstract data type open-in-new

Abstract data type