Abstract definitions

Definitions can be marked as abstract, for the purpose of hiding implementation details, or to speed up type-checking of other parts. In essence, abstract definitions behave like postulates, thus, do not reduce/compute. For instance, proofs whose content does not matter could be marked abstract, to prevent Agda from unfolding them (which might slow down type-checking).

As a guiding principle, all the rules concerning abstract are designed to prevent the leaking of implementation details of abstract definitions. Similar concepts of other programming language include (non-representative sample): UCSD Pascal’s and Java’s interfaces and ML’s signatures. (Especially when abstract definitions are used in combination with modules.)

Synopsis

  • Declarations can be marked as abstract using the block keyword abstract.

  • Outside of abstract blocks, abstract definitions do not reduce, they are treated as postulates, in particular:

    • Abstract functions never match, thus, do not reduce.

    • Abstract data types do not expose their constructors.

    • Abstract record types do not expose their fields nor constructor.

    • Other declarations cannot be abstract.

  • Inside abstract blocks, abstract definitions reduce while type checking definitions, but not while checking their type signatures. Otherwise, due to dependent types, one could leak implementation details (e.g. expose reduction behavior by using propositional equality).

    Consequently information from checking the body of a definition cannot leak into its type signature, effectively disabling type inference for abstract definitions. This means that all abstract definitions need a complete type signature.

  • The reach of the abstract keyword block extends recursively to the where-blocks of a function and the declarations inside of a record declaration, but not inside modules declared in an abstract block.

Examples

Integers can be implemented in various ways, e.g. as difference of two natural numbers:

  1. module Integer where
  3.   abstract
  5.     ℤ : Set
  6.     ℤ = Nat × Nat
  8.     0ℤ : ℤ
  9.     0ℤ = 0 , 0
  11.     1ℤ : ℤ
  12.     1ℤ = 1 , 0
  14.     _+ℤ_ : (x y : ℤ) → ℤ
  15.     (p , n) +ℤ (p' , n') = (p + p') , (n + n')
  17.     _*ℤ_ : (x y : ℤ) → ℤ
  18.     (a , b) *ℤ (c , d) = ((a * c) + (b * d)) , ((a * d) + (b * c))
  20.     infixl 20 _+ℤ_
  21.     infixl 30 _*ℤ_
  23.     -ℤ_ : ℤ → ℤ
  24.     -ℤ (p , n) = (n , p)
  26.     _≡ℤ_ : (x y : ℤ) → Set
  27.     (p , n) ≡ℤ (p' , n') = (p + n') ≡ (p' + n)
  29.     infix 10 _≡ℤ_
  31.     private
  32.       postulate
  33.         +comm : ∀ n m → (n + m) ≡ (m + n)
  35.     invℤ : ∀ x → (x +ℤ (-ℤ x)) ≡ℤ 0ℤ
  36.     invℤ (p , n) rewrite +comm (p + n) 0 | +comm p n = refl

Using abstract we do not give away the actual representation of integers, nor the implementation of the operations. We can construct them from 0ℤ, 1ℤ, _+ℤ_, and -ℤ, but only reason about equality ≡ℤ with the provided lemma invℤ.

The following property shape-of-0ℤ of the integer zero exposes the representation of integers as pairs. As such, it is rejected by Agda: when checking its type signature, proj₁ x fails to type check since x is of abstract type ℤ. Remember that the abstract definition of ℤ does not unfold in type signatures, even when in an abstract block! To work around this we have to define aliases for the projections functions:

  1. -- A property about the representation of zero integers:
  3.   abstract
  4.     private
  5.       posZ : ℤ → Nat
  6.       posZ = proj₁
  8.       negZ : ℤ → Nat
  9.       negZ = proj₂
  11.       shape-of-0ℤ : ∀ (x : ℤ) (is0ℤ : x ≡ℤ 0ℤ) → posZ x ≡ negZ x
  12.       shape-of-0ℤ (p , n) refl rewrite +comm p 0 = refl

By requiring shape-of-0ℤ to be private to type-check, leaking of representation details is prevented.

Scope of abstraction

In child modules, when checking an abstract definition, the abstract definitions of the parent module are transparent:

  1. module M1 where
  2.   abstract
  3.     x : Nat
  4.     x = 0
  6.   module M2 where
  7.     abstract
  8.       x-is-0 : x ≡ 0
  9.       x-is-0 = refl

Thus, child modules can see into the representation choices of their parent modules. However, parent modules cannot see like this into child modules, nor can sibling modules see through each others abstract definitions. An exception to this is anonymous modules, which share abstract scope with their parent module, allowing parent or sibling modules to see inside their abstract definitions.

The reach of the abstract keyword does not extend into modules:

  1. module Parent where
  2.   abstract
  3.     module Child where
  4.       y : Nat
  5.       y = 0
  6.     x : Nat
  7.     x = 0  -- to avoid "useless abstract" error
  9.   y-is-0 : Child.y ≡ 0
  10.   y-is-0 = refl

The declarations in module Child are not abstract!

Abstract definitions with where-blocks

Definitions in a where block of an abstract definition are abstract as well. This means, they can see through the abstractions of their uncles:

  1. module Where where
  2.   abstract
  3.     x : Nat
  4.     x = 0
  5.     y : Nat
  6.     y = x
  7.       where
  8.       x≡y : x ≡ 0
  9.       x≡y = refl