# dependently typed programming language

> programming language

**Wikidata**: [Q56223375](https://www.wikidata.org/wiki/Q56223375)  
**Source**: https://4ort.xyz/entity/dependently-typed-programming-language

## Summary
A dependently typed programming language is a class of programming language defined by its use of a dependent typing discipline. These languages allow types to depend on values, enabling them to function as both instruction sets for machines and tools for formal proof assistance and program verification.

## Key Facts
- Classified as a subclass of the "programming language" category.
- Utilizes a typing discipline known as dependent typing.
- Includes the Rocq prover, a proof assistant established in France in 1984.
- Agda and Idris are prominent purely functional examples, both founded in 2007.
- Epigram was introduced in 2004 as a functional programming language featuring dependent types.
- ATS is a programming language within this class that dates back to 2006.
- F* is a functional language inspired by ML specifically aimed at program verification.
- Other examples of this language type include Cayenne.

## FAQs
### Q: What is the defining feature of a dependently typed programming language?
A: The defining feature is its typing discipline, where types are allowed to depend on values. This creates a more expressive type system that can be used to verify complex logic and program properties at compile-time.

### Q: Which dependently typed languages are also considered proof assistants?
A: Agda and the Rocq prover are notable examples that function as both programming languages and proof assistants. These tools allow users to write programs and formally prove mathematical theorems within the same environment.

### Q: When did modern dependently typed languages like Idris and Agda emerge?
A: Both Idris and Agda had their inception in 2007. They followed earlier developments in the field, such as the Rocq prover in 1984 and Epigram in 2004.

## Why It Matters
Dependently typed programming languages represent a critical intersection between software engineering and formal logic. By allowing types to depend on values, these languages provide a framework where the type system itself can be used to prove the correctness of code. This is particularly significant for program verification, as seen in languages like F*, which aim to eliminate errors in high-stakes software. 

The dual nature of these entities—serving as both functional programming languages and proof assistants—allows for a unified workflow where development and mathematical verification occur simultaneously. This role is essential for the field of formal methods, providing the tools necessary to build high-assurance systems that are mathematically guaranteed to meet their specifications.

## Notable For
- **Dual Functionality:** Languages like Agda and Rocq are distinguished by their ability to serve as both purely functional programming languages and formal proof assistants.
- **Program Verification:** F* is specifically noted for its focus on program verification, drawing technical inspiration from the ML language family.
- **Purely Functional Paradigm:** Many leading dependently typed languages, including Idris and Agda, maintain a purely functional programming structure.
- **Historical Longevity:** The category includes long-standing academic and technical tools, most notably the Rocq prover, which has been in development since 1984.

## Body
### Classification and Technical Definition
A dependently typed programming language is a specialized subclass of the broader "programming language" class. Its primary technical distinction is the "dependent typing" discipline. Unlike standard typing systems, dependent types allow for a more integrated relationship where types can be parameterized by values, increasing the expressive power of the language's logic.

### Historical Development
The evolution of these languages spans several decades, beginning with early proof assistants and moving toward modern functional languages:
*   **1984:** The Rocq prover is established in France as a proof assistant.
*   **2004:** Epigram is introduced as a functional programming language incorporating dependent types.
*   **2006:** The ATS programming language is founded.
*   **2007:** Both Agda and Idris are established, marking the inception of two major purely functional dependently typed languages.

### Specialized Languages and Applications
Different languages within this category serve distinct roles in computer science:
*   **Agda:** Functions as both a dependently typed, purely functional language and a proof assistant.
*   **Idris:** A purely functional language that utilizes dependent types for general-purpose programming.
*   **F*:** A functional language inspired by ML that is specifically aimed at the verification of programs.
*   **Cayenne:** An early example of a programming language utilizing this typing discipline.
*   **Epigram:** Specifically designed as a functional language with dependent types to explore new programming paradigms.

## Schema Markup
```json
{
  "@context": "https://schema.org",
  "@type": "Thing",
  "name": "Dependently typed programming language",
  "description": "A subclass of programming language characterized by a dependent typing discipline, often used for functional programming and proof assistance.",
  "additionalType": "programming language"
}