module type T = sig

  type t
  val muted : t -> t

  val a : [`Closed | `Opened] -> t
  val e : [`Closed | `Opened] -> t
  val eu : [`Closed | `Opened] -> t

  val o : [`Closed | `Opened] -> t
  val schwa : unit -> t
  val i : [`Closed | `Opened] -> t


  val nasal: t -> t

  val none: t

  val p: t
  val b: t
  val t: t
  val k: t
  val f: t
  val s: unit -> t
  val sz: unit -> t
  val ch: unit -> t
  val z: unit -> t

  val n: unit -> t

  val r: unit -> t
  val l: unit -> t

  val is_voyel : t -> bool
  val is_nasal : t -> bool

  type code =
    | None
    | SZ

  val code : t -> code

end

module T = struct
  type kind =
    | None
    | Voyel

  type code =
    | None
    | SZ

  type t =
    { code : code
    ; repr : string
    ; muted : bool
    ; kind : kind
    ; nasal : bool
    }

end

module Repr = struct

  let a = "a"
  and a_nasal = "@"

  and o_nasal = "§"

end

module S = struct

  include T

  let is_voyel t = t.kind = Voyel
  let is_nasal t = t.nasal

  let none =
    { repr = "."
    ; muted = false
    ; kind = None
    ; nasal = false
    ; code = None }

  let code t = t.code

  let nasal t =
    match t.repr with
    | "a" -> { t with repr = Repr.a_nasal ; nasal = true }
    | "o" -> { t with repr = Repr.o_nasal ; nasal = true }
    | _ -> t

  let muted f =
    { none with
      repr = "(" ^ f.repr ^ ")"
    ; muted = true }

  let a _ =
    { none with repr = Repr.a }

  let e = function
    | `Closed -> { none with repr = "e" }
    | `Opened -> { none with repr = "E" }

  let eu = function
    | `Closed -> { none with repr = "2" }
    | `Opened -> { none with repr = "9" }


  let schwa () =
    { none with repr = "°" }

  let o _ =
    { none with repr = "o" }

  let i _ =
    { none with repr = "i" }

  let p =
    { none with repr = "p" }

  let b =
    { none with repr = "b" }

  let t =
    { none with repr = "t" }

  let k =
    { none with repr = "k" }

  let f =
    { none with repr = "f" }

  let s () =
    { none with repr = "s" }

  let sz () =
    { (s()) with code = SZ }

  let ch () =
    { none with repr = "S" }

  let z () =
    { none with repr = "z" }

  let n () =
    { none with
      repr = "n"
    ; nasal = true }

  let l () =
    { none with repr = "L" }

  let r () =
    { none with repr = "R" }

end

include S