Intro To Agda

transcript

Intro to Agda

by Larry Diehl (larrytheliquid)

induction centric

data Nat : Set where zero : Nat suc : Nat -> Nat

one = suc zerotwo = suc (suc zero)

unicode centric

data ℕ : Set where zero : ℕ suc : ℕ → ℕ

suc₂ : ℕ → ℕsuc₂ n = suc (suc n)

unicode in emacs

\r →\bn ℕ\:: ∷\member ∈ \equiv ≡\and ∧\or ∨\neg ¬\ex ∃\all ∀

built-ins

data ℕ : Set where zero : ℕ suc : ℕ → ℕ

{-# BUILTIN NATURAL ℕ #-}{-# BUILTIN ZERO zero #-}{-# BUILTIN SUC suc #-}

nine = suc₂ 7

standard library

open import Data.Nat

infix & pattern matching

infixl 6 _+_infixl 7 _*__+_ : ℕ → ℕ → ℕzero + n = nsuc m + n = suc (m + n)

_*_ : ℕ → ℕ → ℕzero * n = zerosuc m * n = n + m * n

emacs goal mode

_+_ : ℕ → ℕ → ℕ n + m = ? _+_ : ℕ → ℕ → ℕn + m = {!!}

_+_ : ℕ → ℕ → ℕn + m = { }0-- ?0 : ℕ

coverage checking

data Day : Set where Sunday Monday Tuesday : Day Wednesday Thursday : Day Friday Saturday : Day isWeekend : Day → BoolisWeekend Sunday = trueisWeekend Saturday = trueisWeekend _ = false

termination checking (fail)

isWeekend : Day → BoolisWeekend day = isWeekend day

isWeekend : Day → BoolisWeekend Sunday = trueisWeekend Saturday = isWeekend SundayisWeekend _ = false

termination checking (win)

_+_ : ℕ → ℕ → ℕzero + n = nsuc m + n = suc (m + n)

_*_ : ℕ → ℕ → ℕzero * n = zerosuc m * n = n + m * n

data type polymorphism

data List (A : Set) : Set where [] : List A _∷_ : (x : A) (xs : List A) → List A

-- open import Data.List

type-restriction

append : List ℕ → List ℕ → List ℕappend [] ys = ysappend (x ∷ xs) ys = x ∷ (append xs ys)

parametric polymorphism

append : (A : Set) → List A → List A → List Aappend A [] ys = ysappend A (x ∷ xs) ys = x ∷ (append A xs ys)

implicit arguments

append : {A : Set} → List A → List A → List Aappend [] ys = ysappend (x ∷ xs) ys = x ∷ (append xs ys)

-- append = _++_

indexed types

data Vec (A : Set) : ℕ → Set where [] : Vec A zero _∷_ : {n : ℕ} (x : A) (xs : Vec A n) → Vec A (suc n)

bool-vec : Vec Bool 2bool-vec = _∷_ {1} true (_∷_ {0} false []) bool-vec : Vec Bool 2bool-vec = true ∷ false ∷ []

indexed types

append : {n m : ℕ} {A : Set} → Vec A n → Vec A m → Vec A (n + m)append [] ys = ysappend (x ∷ xs) ys = x ∷ (append xs ys)

coverage checking

head : {A : Set} → Vec A 9 → Ahead (x ∷ xs) = x head : {n : ℕ} {A : Set} → Vec A (suc n) → Ahead (x ∷ xs) = x head : {n : ℕ} {A : Set} → Vec A (1 + 1 * n) → Ahead (x ∷ xs) = x

records

record Car : Set where field make : Make model : Model year : ℕ

electricCar : CarelectricCar = record { make = Tesla ; model = Roadster ; year = 2010 }

records

record Car : Set where constructor _,_,_ field make : Make model : Model year : ℕ

electricCar : CarelectricCar = Tesla , Roadster , 2010carYear : ℕcarYear = Car.year electricCar

truth & absurdity

record ⊤ : Set wheredata ⊥ : Set where

T : Bool → SetT true = ⊤T false = ⊥

preconditions

even : ℕ → Booleven zero = trueeven (suc zero) = falseeven (suc (suc n)) = even n

evenSquare : (n : ℕ) → {_ : T (even n)} → ℕevenSquare n = n * n

preconditions

nonZero : ℕ → BoolnonZero zero = falsenonZero _ = true

postulate _div_ : ℕ → (n : ℕ) → {_ : T (nonZero n)} → ℕ

propositional equality

infix 4 _≡_data _≡_ {A : Set} (x : A) : A → Set where refl : x ≡ x

testMultiplication : 56 ≡ 8 * 7testMultiplication = refl

preconditions

lookup : {A : Set}(n : ℕ)(xs : List A) {_ : T (n < length xs)} → Alookup n []{()}lookup zero (x ∷ xs) = xlookup (suc n) (x ∷ xs) {p} = lookup n xs {p}

testLookup : 2 ≡ lookup 1 (1 ∷ 2 ∷ [])testLookup = refl

finite sets

data Fin : ℕ → Set where zero : {n : ℕ} → Fin (suc n) suc : {n : ℕ} (i : Fin n) → Fin (suc n)

finTest : Fin 3finTest = zero

finTest₂ : Fin 3finTest₂ = suc (suc zero)

precondition with indexes

lookup : {A : Set}{n : ℕ} → Fin n → Vec A n → Alookup zero (x ∷ xs) = xlookup (suc i) (x ∷ xs) = lookup i xs testLookup : 2 ≡ lookup (suc zero) (1 ∷ 2 ∷ [])testLookup = refl

testLookup₂ : 2 ≡ lookup (fromℕ 1) (1 ∷ 2 ∷ [])testLookup₂ = refl

doubleOrNothing : ℕ → ℕdoubleOrNothing n with even ndoubleOrNothing n | true = n * 2doubleOrNothing n | false = 0 doubleOrNothing : ℕ → ℕdoubleOrNothing n with even n... | true = n * 2... | false = 0

parity : (n : ℕ) → Parity nparity zero = even zeroparity (suc n) with parity nparity (suc .(k * 2)) | even k = odd kparity (suc .(1 + k * 2)) | odd k = even (suc k)

half : ℕ → ℕhalf n with parity nhalf .(k * 2) | even k = khalf .(1 + k * 2) | odd k = k

inverse

data Image_∋_ {A B : Set}(f : A → B) : B → Set where im : {x : A} → Image f ∋ f x

inv : {A B : Set}(f : A → B)(y : B) → Image f ∋ y → Ainv f .(f x) (im {x}) = x

inverse

Bool-to-ℕ : Bool → ℕBool-to-ℕ false = 0Bool-to-ℕ true = 1

testImage : Image Bool-to-ℕ ∋ 0testImage = imtestImage₂ : Image Bool-to-ℕ ∋ 1testImage₂ = im

testInv : inv Bool-to-ℕ 0 im ≡ falsetestInv = refltestInv₂ : inv Bool-to-ℕ 1 im ≡ truetestInv₂ = refl

intuitionistic logic

data _∧_ (A B : Set) : Set where <_,_> : A → B → A ∧ B

fst : {A B : Set} → A ∧ B → Afst < a , _ > = asnd : {A B : Set} → A ∧ B → Bsnd < _ , b > = b

data _∨_ (A B : Set) : Set where left : A → A ∨ B right : B → A ∨ B

case : {A B C : Set} → A ∨ B → (A → C) → (B → C) → Ccase (left a) x _ = x acase (right b) _ y = y b

record ⊤ : Set where constructor tt

data ⊥ : Set where

exFalso : {A : Set} → ⊥ → AexFalso ()

¬ : Set → Set¬ A = A → ⊥

_=>_ : (A B : Set) → SetA => B = A → B

modusPonens : {A B : Set} → A => B → A → BmodusPonens f a = f a

_<=>_ : Set → Set → SetA <=> B = (A => B) ∧ (B => A)

∀′ : (A : Set)(B : A → Set) → Set∀′ A B = (a : A) → B a

data ∃ (A : Set)(B : A → Set) : Set where exists : (a : A) → B a → ∃ A B

witness : {A : Set}{B : A → Set} → ∃ A B → Awitness (exists a _) = a

data Man : Set where person : Man

isMan : Man → SetisMan m = ⊤

isMortal : Man → SetisMortal m = ⊤

socratesIsMortal : {Socrates : Man} → (∀′ Man isMortal ∧ isMan Socrates) => isMortal SocratessocratesIsMortal {soc} < lemma , _ > = lemma soc

The End

Agda Wikihttp://is.gd/8YgYM

Dependently Typed Programming in Agdahttp://is.gd/8Ygyz

Dependent Types at Work

http://is.gd/8YggR

lemmatheultimate.com

Intro To Agda

Technology