quox/examples/either.quox

load "misc.quox";
load "bool.quox";

namespace either {

def0 Tag : ★₀ = {left, right};

def0 Payload : 0.(A : ★₀) → 0.(B : ★₀) → 1.Tag → ★₀ =
  λ A B tag ⇒ case1 tag return ★₀ of { 'left ⇒ A; 'right ⇒ B };

def0 Either : 0.★₀ → 0.★₀ → ★₀ =
  λ A B ⇒ (tag : Tag) × Payload A B tag;

def Left : 0.(A : ★₀) → 0.(B : ★₀) → 1.A → Either A B =
  λ A B x ⇒ ('left, x);

def Right : 0.(A : ★₀) → 0.(B : ★₀) → 1.B → Either A B =
  λ A B x ⇒ ('right, x);

def elim' :
    0.(A : ★₀) → 0.(B : ★₀) →
    0.(P : 0.(Either A B) → ★₀) →
    ω.(1.(x : A) → P (Left  A B x)) →
    ω.(1.(x : B) → P (Right A B x)) →
    1.(t : Tag) → 1.(a : Payload A B t) → P (t, a) =
  λ A B P f g t ⇒
    case1 t
    return t' ⇒ 1.(a : Payload A B t') → P (t', a)
    of { 'left ⇒ f; 'right ⇒ g };

def elim :
    0.(A : ★₀) → 0.(B : ★₀) →
    0.(P : 0.(Either A B) → ★₀) →
    ω.(1.(x : A) → P (Left  A B x)) →
    ω.(1.(x : B) → P (Right A B x)) →
    1.(x : Either A B) → P x =
  λ A B P f g e ⇒
    case1 e return e' ⇒ P e' of { (t, a) ⇒ elim' A B P f g t a };


}

def0 Either = either.Either;
def  Left   = either.Left;
def  Right  = either.Right;


namespace dec {

def0 Dec : 0.★₀ → ★₀ = λ A ⇒ Either [0.A] [0.Not A];

def Yes : 0.(A : ★₀) → 0.A       → Dec A = λ A y ⇒ Left  [0.A] [0.Not A] [y];
def No  : 0.(A : ★₀) → 0.(Not A) → Dec A = λ A n ⇒ Right [0.A] [0.Not A] [n];

def0 DecEq : 0.★₀ → ★₀ =
  λ A ⇒ ω.(x : A) → ω.(y : A) → Dec (x ≡ y : A);

def elim :
    0.(A : ★₀) → 0.(P : 0.(Dec A) → ★₀) →
    ω.(0.(y : A)     → P (Yes A y)) →
    ω.(0.(n : Not A) → P (No  A n)) →
    1.(x : Dec A) → P x =
  λ A P f g ⇒
    either.elim [0.A] [0.Not A] P
      (λ y ⇒ case0 y return y' ⇒ P (Left  [0.A] [0.Not A] y') of {[y'] ⇒ f y'})
      (λ n ⇒ case0 n return n' ⇒ P (Right [0.A] [0.Not A] n') of {[n'] ⇒ g n'});

def bool : 0.(A : ★₀) → 1.(Dec A) → Bool =
  λ A ⇒ elim A (λ _ ⇒ Bool) (λ _ ⇒ 'true) (λ _ ⇒ 'false);

}

def0 Dec   = dec.Dec;
def0 DecEq = dec.DecEq;
def  Yes   = dec.Yes;
def  No    = dec.No;