This article includes a list of references, related reading or external links, but its sources remain unclear because it lacks inline citations .(October 2020) (Learn how and when to remove this template message) |

In programming languages and type theory, a **product** of *types* is another, compounded, type in a structure. The "operands" of the product are types, and the structure of a product type is determined by the fixed order of the operands in the product. An instance of a product type retains the fixed order, but otherwise may contain all possible instances of its primitive data types. The expression of an instance of a product type will be a tuple, and is called a "tuple type" of expression. A product of types is a direct product of two or more types.

If there are only two component types, it can be called a "pair type". For example, if two component types **A** and **B** are the set of all possible values of that type, the product type written **A** × **B** contains elements that are pairs (a,b), where "a" and "b" are instances of **A** and **B** respectively. The pair type is a special case of the dependent pair type, where the type **B** may depend on the instance picked from **A**.

In many languages, product types take the form of a record type, for which the components of a tuple can be accessed by label. In languages that have algebraic data types, as in most functional programming languages, algebraic data types with one constructor are isomorphic to a product type.

In the Curry–Howard correspondence, product types are associated with logical conjunction (AND) in logic.

The notion directly extends to the product of an arbitrary finite number of types (a n-ary product type), and in this case, it characterizes the expressions which behave as tuples of expressions of the corresponding types. A degenerated form of product type is the unit type: it is the product of no types.

In call-by-value programming languages, a product type can be interpreted as a set of pairs whose first component is a value in the first type and whose second component is a value in the second type. In short, it is a cartesian product and it corresponds to a product in the category of types.

Most functional programming languages have a primitive notion of product type. For instance, the product of *type _{1}*, ...,

`*`

...`*`

`(`

`,`

...`,`

`)`

in Haskell. In both these languages, tuples are written `(`

`,`

...`,`

`)`

and the components of a tuple are extracted by pattern-matching. Additionally, many functional programming languages provide more general algebraic data types, which extend both product and sum types. Product types are the dual of sum types.In mathematics, a **binary operation** or **dyadic operation** is a calculation that combines two elements to produce another element. More formally, a binary operation is an operation of arity two.

In mathematics and computer science, **currying** is the technique of converting a function that takes multiple arguments into a sequence of functions that each takes a single argument. For example, currying a function that takes three arguments creates three functions:

In logic, mathematics and linguistics, And is the truth-functional operator of **logical conjunction**; the *and* of a set of operands is true if and only if *all* of its operands are true. The logical connective that represents this operator is typically written as or ⋅ .

The **relational model** (**RM**) for database management is an approach to managing data using a structure and language consistent with first-order predicate logic, first described in 1969 by English computer scientist Edgar F. Codd, where all data is represented in terms of tuples, grouped into relations. A database organized in terms of the relational model is a relational database.

**Arity** is the number of arguments or operands taken by a function or operation in logic, mathematics, and computer science. In mathematics, arity may also be named *rank*, but this word can have many other meanings in mathematics. In logic and philosophy, it is also called **adicity** and **degree**. In linguistics, it is usually named **valency**.

In computer science and computer programming, a **data type** or simply **type** is an attribute of data which tells the compiler or interpreter how the programmer intends to use the data. Most programming languages support basic data types of integer numbers, floating-point numbers, characters and Booleans. A data type constrains the values that an expression, such as a variable or a function, might take. This data type defines the operations that can be done on the data, the meaning of the data, and the way values of that type can be stored. A data type provides a set of values from which an expression may take its values.

In mathematics, a **tuple** is a finite ordered list (sequence) of elements. An **n-tuple** is a sequence of n elements, where n is a non-negative integer. There is only one 0-tuple, referred to as *the empty tuple*. An n-tuple is defined inductively using the construction of an ordered pair.

In database theory, **relational algebra** is a theory that uses algebraic structures with a well-founded semantics for modeling data, and defining queries on it. The theory has been introduced by Edgar F. Codd.

In computer programming, especially functional programming and type theory, an **algebraic data type** is a kind of composite type, i.e., a type formed by combining other types.

In computer programming, an **assignment statement** sets and/or re-sets the value stored in the storage location(s) denoted by a variable name; in other words, it copies a value into the variable. In most imperative programming languages, the assignment statement is a fundamental construct.

**Intuitionistic type theory** is a type theory and an alternative foundation of mathematics. Intuitionistic type theory was created by Per Martin-Löf, a Swedish mathematician and philosopher, who first published it in 1972. There are multiple versions of the type theory: Martin-Löf proposed both intensional and extensional variants of the theory and early impredicative versions, shown to be inconsistent by Girard's paradox, gave way to predicative versions. However, all versions keep the core design of constructive logic using dependent types.

In functional programming, a **monad** is an abstraction that allows structuring programs generically. Supporting languages may use monads to abstract away boilerplate code needed by the program logic. Monads achieve this by providing their own data type, which represents a specific form of computation, along with two procedures:

The **vertical bar**, ** | **, is a glyph with various uses in mathematics, computing, and typography. It has many names, often related to particular meanings: Sheffer stroke, **pipe**, **vbar**, **stick**, **vertical line**, **vertical slash,****bar**, **pike**, or **verti-bar**, and several variants on these names. It is occasionally considered an allograph of **broken bar**.

In computer science and logic, a **dependent type** is a type whose definition depends on a value. It is an overlapping feature of type theory and type systems. In intuitionistic type theory, dependent types are used to encode logic's quantifiers like "for all" and "there exists". In functional programming languages like Agda, ATS, Coq, F*, Epigram, and Idris, dependent types may help reduce bugs by enabling the programmer to assign types that further restrain the set of possible implementations.

In relational algebra, a **projection** is a unary operation written as , where is a relation and are attribute names. Its result is defined as the set obtained when the components of the tuples in are restricted to the set – it *discards* the other attributes.

In category theory, the concept of **catamorphism** denotes the unique homomorphism from an initial algebra into some other algebra.

In functional programming, a **generalized algebraic data type** is a generalization of parametric algebraic data types.

**OptimJ** is an extension for Java with language support for writing optimization models and abstractions for bulk data processing. The extensions and the proprietary product implementing the extensions were developed by Ateji which went out of business in September 2011. OptimJ aims at providing a clear and concise algebraic notation for optimization modeling, removing compatibility barriers between optimization modeling and application programming tools, and bringing software engineering techniques such as object-orientation and modern IDE support to optimization experts.

In mathematical logic and computer science, **homotopy type theory** refers to various lines of development of intuitionistic type theory, based on the interpretation of types as objects to which the intuition of (abstract) homotopy theory applies.

In mathematics, **equivalent definitions** are used in two somewhat different ways. First, within a particular mathematical theory, a notion may have more than one definition. These definitions are equivalent in the context of a given mathematical structure. Second, a mathematical structure may have more than one definition.

This page is based on this Wikipedia article

Text is available under the CC BY-SA 4.0 license; additional terms may apply.

Images, videos and audio are available under their respective licenses.

Text is available under the CC BY-SA 4.0 license; additional terms may apply.

Images, videos and audio are available under their respective licenses.