basic (Float : #Ord)
basic (Int : #Ord)
basic (String : #Ord)
basic (Char : #Ord)
basic (Bool : #Ord)
basic Unit

//

decl not : Bool -> Bool
def not : x =
  (match x with
     | true -> false
     | false -> true)

decl ( && ) : Bool -> Bool -> Bool
def ( && ) : x y =
  match x with
    | true -> (
      match y with
        | true -> true
        | false -> false
    )
    | false -> false

decl ( || ) : Bool -> Bool -> Bool
def ( || ) : x y =
  match x with
    | true -> true
    | false -> (
      match y with
        | true -> true
        | false -> false
    )

// Eq typeclass

typeclass Eq =
  & var ( == ) : Eq -> Bool
  & var ( != ) : Eq -> Bool

namespace var Eq {
  def ( != ) : x = not: (self == x)
}

//

struct Order =
  | EQ
  | LT
  | GT

typeclass (Ord : #Eq) =
  & var compare : Ord -> Order
  & var ( < ) : Ord -> Bool
  & var ( >= ) : Ord -> Bool
  & var ( > ) : Ord -> Bool
  & var ( <= ) : Ord -> Bool

decl min ('A : #Ord) : 'A -> 'A -> 'A
def min : x y = if x < y then x else y

decl max ('A : #Ord) : 'A -> 'A -> 'A
def max : x y = if x < y then y else x

namespace var Ord {
  def compare : x =
    if self == x then $EQ
    elif self < x then $LT
    else $GT

  def ( >= ) : x = not: (self < x)
  def ( > ) : x = x < self
  def ( <= ) : x = not: (x < self)
}

//

typeclass Show =
  & var show : -> String

typeclass Read =
  & var read : String -> Read

typeclass Debug =
  & debug : -> String

//

typeclass Default =
  & default : -> Default

//

typeclass Bounded =
  & min_bound : -> Bounded
  & max_bound : -> Bounded
  & var is_max_bound : -> Bool
  & var is_min_bound : -> Bool

//

typeclass Enum =
  & var succ : -> (Optional Enum)
  & var pred : -> (Optional Enum)
  & to_enum : Int -> Enum
  & var from_enum : -> Int

//

// // bad
// typeclass Functor 'A =
//   & fmap 'B ('F : (#Functor 'B)) : ('A -> 'B) -> Functor -> 'F

// typeclass (Iterator : #Eq) =
//   & next : -> Unit
//   & prev : -> Unit
//
// typeclass Iterable ('Iter : #Iterable) =
//   & begin : -> 'Iter
//   & end : -> 'Iter

//

decl ( -- ) : Int -> Int -> Int_0
def ( -- ) : begin end = {
  var current = begin
  return (while current < end do {
    ; current += 1
    return current - 1
  })
}

decl print : String -> Unit
decl scan : -> String

decl func : String -> Int
def func : s = {
  ; print: s
  return 5
}

exec main {
  for i in (,0 ,1 ,2 ,3) do func: "abacaba"
  ; print: ({
    if true then bring scan: else { ; print: "aaa" }
    bring "nothing"
    ; print: "aaa"
  })
}