basic (Float : #Ord #Div #Str)
basic (Int : #Ord #IDiv #Str)
basic (String : #Ord #Str #CharContainer #Copy)
basic (Char : #Ord #Str #Copy)
basic (Bool : #Ord #Str #Copy)
basic (Unit : #Str #Copy)

//

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
    )

//

typeclass CharContainer =
  & var size : -> Int
  & var at : Int -> Char

//

typeclass Move = // TODO
  & var ( <- ) : Move -> Unit

typeclass Copy =
  & var ( = ) : Copy -> Unit

//

typeclass (Sum : #Copy) =
  & var ( += ) : Sum -> Unit
  & var ( -= ) : Sum -> Unit
  & var ( + ) : Sum -> Sum
  & var ( - ) : Sum -> Sum
  & zero : -> Sum

namespace var Sum {
  def ( + ) : x = {
    var ans = self
    ; ans += x
    return ans
  }

  def ( - ) : x = {
    var ans = self
    ; ans -= x
    return ans
  }
}

typeclass (Mult : #Sum) =
  & var ( *= ) : Mult -> Unit
  & var ( * ) : Mult -> Mult

namespace var Mult {
  def ( * ) : x = {
    var ans = self
    ; ans *= x
    return ans
  }
}

typeclass (IDiv : #Mult) =
  & var div : IDiv -> IDiv
  & var mod : IDiv -> IDiv

namespace var IDiv {
  def mod : x = self -. x * self.div: x
}

typeclass (Div : #Mult) =
  & var ( /= ) : Div -> Unit
  & var ( / ) : Div -> Div

namespace var Div {
  def ( / ) : x = {
    var ans = self
    ; ans /= x
    return ans
  }
}

//

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 =
  & read : String -> Read

typeclass (Str : #Show #Read)

// typeclass DebugShow = // TODO
//   & debug_show : -> 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

//

namespace IO {
  decl print : String -> Unit
  decl scan : -> String
  decl random : -> Int // TODO
}

//

// // 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
    bring current - 1
  })
}

// decl func : String -> Int -> Int
// def func : s i = {
//   ; print: s
//   var x = s
//   ; print: (i.show:)
//   return 5
// }
//
// exec main {
//   for i in 0--19 do func: "a" (i * 2 +. 3)
//   ; print: ({
//     if true then bring scan: else { ; print: "aaa" }
//     bring "nothing"
//     ; print: "aaa"
//   })
// }

decl scan_int : -> Int
def scan_int = Int.read: (IO.scan:)

decl print_int : Int -> Unit
def print_int : x = IO.print: (x.show:)

decl scan_anything ('A : #Read) : -> 'A
def scan_anything = 'A.read: (IO.scan:)

decl print_anything ('A : #Show) : 'A -> Unit
def print_anything : x = IO.print: (x.show:)

// decl sorted ('A : #Ord #Copy): 'A_0 -> Int -> 'A_0
// def sorted : a sz = {
//   var a_copy = a
//   if sz == 2 then {
//     if a_copy`0 > a_copy`1 then {
//       var x = a_copy`0
//       a_copy`0 = a_copy`1
//       a_copy`1 = x
//     }
//     return a_copy
//   }
//
//   var center = sz.div: 2
//
//   var a_left = for i in 0--center do a`i
//   var a_right = for i in center-sz do a`i
//
//   return a_copy
// }
/*
struct Array 'A = & data : 'A_0

namespace Array {
  decl of : 'A_0 -> Array
  def of: x = $(Array 'A) & data = x
}*/

struct ThreeTuple = & String & String & String

decl scan_three_t : -> ThreeTuple
def scan_three_t = $ThreeTuple & IO.scan: & IO.scan: & IO.scan:

decl scan_three : -> (& String & String & String)
def scan_three = & IO.scan: & IO.scan: & IO.scan:

//   var n = scan_anything Int:
//   var a = $(Array Int) & data = (for _ in 0--n do scan_int:)
//   ; print_anything Int: n

exec main {
  var & a & b & c = scan_three_t:
  ; IO.print: b
  var & d & e & f = scan_three:
  ; IO.print: e
}