{-# PRIMITIVE Type #-}
{-# PRIMITIVE Pretype #-}

I : Pretype
{-# PRIMITIVE Interval I #-}

i0 : I
i1 : I
{-# PRIMITIVE i0 #-}
{-# PRIMITIVE i1 #-}

iand : I -> I -> I
{-# PRIMITIVE iand #-}

ior : I -> I -> I
{-# PRIMITIVE ior #-}

inot : I -> I
{-# PRIMITIVE inot #-}

PathP : (A : I -> Pretype) -> A i0 -> A i1 -> Type
{-# PRIMITIVE PathP #-}

Path : {A : Pretype} -> A -> A -> Type
Path {A} = PathP (\i -> A)

refl : {A : Pretype} {x : A} -> Path x x
refl {A} {x} i = x

sym : {A : I -> Pretype} {x : A i0} {y : A i1} -> PathP A x y -> PathP (\i -> A (inot i)) y x
sym p i = p (inot i)

id : {A : Type} -> A -> A
id x = x

the : (A : Pretype) -> A -> A
the A x = x

iElim : {A : I -> Pretype} {x : A i0} {y : A i1} -> PathP A x y -> (i : I) -> A i
iElim p i = p i

Singl : (A : Type) -> A -> Type
Singl A x = (y : A) * Path x y

isContr : Type -> Type
isContr A = (x : A) * ((y : A) -> Path x y)

singContr : {A : Type} {a : A} -> isContr (Singl A a)
singContr {A} {a} = ((a, \i -> a), \y i -> (y.2 i, \j -> y.2 (iand i j)))

cong : {A : Type} {B : A -> Type} (f : (x : A) -> B x) {x : A} {y : A} (p : Path x y) -> PathP (\i -> B (p i)) (f x) (f y)
cong f p i = f (p i)

congComp : {A : Type} {B : Type} {C : Type}
           {f : A -> B} {g : B -> C} {x : A} {y : A}
           (p : Path x y)
        -> Path (cong g (cong f p)) (cong (\x -> g (f x)) p)
congComp p = refl

congId : {A : Type} {x : A} {y : A}
         (p : Path x y)
     -> Path (cong (id {A}) p) p
congId p = refl

IsOne : I -> Type
{-# PRIMITIVE IsOne #-}

itIs1 : IsOne i1
{-# PRIMITIVE itIs1 #-}

isOneL : {i : I} {j : I} -> IsOne i -> IsOne (ior i j)
{-# PRIMITIVE isOneL #-}

isOneR : {i : I} {j : I} -> IsOne j -> IsOne (ior i j)
{-# PRIMITIVE isOneR #-}

Partial : I -> Type -> Pretype
{-# PRIMITIVE Partial #-}

PartialP : (phi : I) -> Partial phi Type -> Pretype
{-# PRIMITIVE PartialP #-}

Bool : Type
tt, ff : Bool

foo : (i : I) -> (j : I) -> Partial (ior (inot i) (ior i (iand i j))) Bool
foo i j = \ { (i = i0) -> tt, (i = i1) -> ff, (i = i1) && (j = i1) -> ff }

apPartial : {B : Type} {A : Type} -> (phi : I) -> (A -> B) -> Partial phi A -> Partial phi B
apPartial phi f p is1 = f (p is1)