The Mercury Language Reference Manual: Top

Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies.

Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided also that the entire resulting derived work is distributed under the terms of a permission notice identical to this one.

Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions.

1 Introduction
2 Syntax
- 2.1 Syntax overview
- 2.2 Character set
- 2.3 Whitespace
- 2.4 Tokens
- 2.5 Terms
- 2.6 Builtin operators
- 2.7 Items
- 2.8 Declarations
- 2.9 Facts
- 2.10 Rules
- 2.11 Goals
- 2.12 State variables
- 2.13 DCG-rules
- 2.14 DCG-goals
- 2.15 Data-terms
- 2.16 Variable scoping
- 2.17 Implicit quantification
- 2.18 Elimination of double negation
3 Types
- 3.1 Builtin types
  - 3.1.1 Primitive types
  - 3.1.2 Other builtin types
- 3.2 User-defined types
- 3.3 Predicate and function type declarations
- 3.4 Field access functions
- 3.5 The standard ordering
4 Modes
- 4.1 Insts, modes, and mode definitions
- 4.2 Predicate and function mode declarations
- 4.3 Constrained polymorphic modes
- 4.4 Different clauses for different modes
5 Unique modes
- 5.1 Destructive update
- 5.2 Backtrackable destructive update
- 5.3 Limitations of the current implementation
6 Determinism
- 6.1 Determinism categories
- 6.2 Determinism checking and inference
- 6.3 Replacing compile-time checking with run-time checking
- 6.4 Interfacing nondeterministic code with the real world
- 6.5 Committed choice nondeterminism
7 User-defined equality and comparison
8 Higher-order programming
- 8.1 Creating higher-order terms
- 8.2 Calling higher-order terms
- 8.3 Higher-order insts and modes
9 Modules
- 9.1 The module system
- 9.2 An example module
- 9.3 Submodules
- 9.4 Module initialisation
- 9.5 Module finalisation
- 9.6 Module-local mutable variables
10 Type classes
- 10.1 Typeclass declarations
- 10.2 Instance declarations
- 10.3 Abstract typeclass declarations
- 10.4 Abstract instance declarations
- 10.5 Type class constraints on predicates and functions
- 10.6 Type class constraints on type class declarations
- 10.7 Type class constraints on instance declarations
- 10.8 Functional dependencies
11 Existential types
- 11.1 Existentially typed predicates and functions
- 11.2 Existential class constraints
- 11.3 Existentially typed data types
- 11.4 Some idioms using existentially quantified types
12 Type conversions
13 Exception handling
14 Semantics
15 Foreign language interface
- 15.1 Calling foreign code from Mercury
  - 15.1.1 pragma foreign_proc
  - 15.1.2 Foreign code attributes
- 15.2 Calling Mercury from foreign code
- 15.3 Data passing conventions
- 15.4 Using foreign types from Mercury
- 15.5 Using foreign enumerations in Mercury code
- 15.6 Using Mercury enumerations in foreign code
- 15.7 Adding foreign declarations
- 15.8 Declaring Mercury exports to other modules
- 15.9 Adding foreign definitions
- 15.10 Language specific bindings
16 Impurity declarations
- 16.1 Choosing the right level of purity
- 16.2 Purity ordering
- 16.3 Semantics
- 16.4 Declaring impure functions and predicates
- 16.5 Marking a goal as impure
- 16.6 Promising that a predicate is pure
- 16.7 An example using impurity
- 16.8 Using impurity with higher-order code
17 Solver types
- 17.1 The ‘any’ inst
- 17.2 Abstract solver type declarations
- 17.3 Solver type definitions
- 17.4 Implementing solver types
- 17.5 Solver types and negated contexts
18 Trace goals
19 Pragmas
- 19.1 Inlining
- 19.2 Type specialization
- 19.3 Obsolescence
- 19.4 No determinism warnings
- 19.5 No dead predicate warnings
- 19.6 Source file name
20 Implementation-dependent extensions
- 20.1 Fact tables
- 20.2 Tabled evaluation
- 20.3 Termination analysis
- 20.4 Feature sets
- 20.5 Trailing
21 Bibliography
- [1]
- [2]
- [3]
- [4]
- [5]

• Introduction:		A brief introduction to Mercury.
• Syntax:		A description of Mercury’s syntax.
• Types:		Mercury has a strong parametric polymorphic type system.
• Modes:		Modes allow you to specify the direction of data flow.
• Unique modes:		Unique modes allow you to specify when there is only one reference to a particular value, so the compiler can safely use destructive update to modify that value.
• Determinism:		Determinism declarations let you specify that a predicate should never fail or should never succeed more than once.
• User-defined equality and comparison:		User-defined types can have user-defined equality and comparison predicates.
• Higher-order:		Mercury supports higher-order predicates and functions, with closures, lambda expressions, and currying.
• Modules:		Modules allow you to divide a program into smaller parts.
• Type classes:		Constrained polymorphism.
• Existential types:		Support for data abstraction and heterogeneous collections.
• Type conversions:		Converting between subtypes and supertypes.
• Exception handling:		Catching exceptions to recover from exceptional situations.
• Semantics:		Declarative and operational semantics of Mercury programs.
• Foreign language interface:		Calling code written in other programming languages from Mercury code
• Impurity:		Users can write impure Mercury code.
• Solver types:		Support for constraint logic programming
• Trace goals:		Trace goals allow programmers to add debugging and logging code to their programs.
• Pragmas:		Various compiler directives, used for example to control optimization.
• Implementation-dependent extensions:		The Melbourne Mercury implementation supports several extensions to the Mercury language.
• Bibliography:		References for further reading.

The Mercury Language Reference Manual

Table of Contents

The Mercury Language Reference Manual, version 22.01.8