/* Input/Output

A sample code using this module:

```
import ck/io

fun main()
  val a = read(int)
  val (b, c) = read(int, int)
  val s = read(string)
  println(a + b + c, s)
```
\/
*/
module ck/iock/io

import std/num/int64std/num/int64
import std/os/pathstd/os/path
import std/os/filestd/os/file
import std/os/readlinestd/os/readline

pub fun read-stdinck/io/read-stdin: () -> <exn,fsys> string()result: -> <exn,fsys> string: <std/core/types/total: Eexnstd/core/exn/exn: (E, V) -> V,fsysstd/core/fsys: X> stringstd/core/types/string: V
  read-text-filestd/os/file/read-text-file: (path : path) -> <exn,fsys> string(pathstd/os/path/path: (s : string) -> <exn,fsys> path("/dev/stdin"literal: string
count= 10))

/// Implementation notes of `read`:
/// - Parser functions should have type `(s: string) -> exn a` but not
///   `(s: string) -> maybe<a>`. The latter functions are slower than the
///   former ones.

// Read a single value in a line
pub inline fun single/readck/io/single/read: forall<a> (parse : (s : string) -> exn a) -> <console,exn> a(
  parseparse: (s : string) -> exn $281: (s: stringstd/core/types/string: V) -> exnstd/core/exn/exn: (E, V) -> V aa: V
)result: -> <console,exn> 297: <std/core/types/total: Econsolestd/core/console/console: X,exnstd/core/exn/exn: (E, V) -> V> aa: V
  readlinestd/os/readline/readline: () -> <console,exn> string().parseparse: (s : string) -> <exn,console> $281

// Read two values in a line.
// The values must be separated by a single space, and each value except the
// last must not contain spaces.
pub inline fun tuple2/readck/io/tuple2/read: forall<a,b> (parse1 : (s : string) -> exn a, parse2 : (s : string) -> exn b) -> <console,exn> (a, b)(
  parse1parse1: (s : string) -> exn $302: (s: stringstd/core/types/string: V) -> exnstd/core/exn/exn: (E, V) -> V aa: V,
  parse2parse2: (s : string) -> exn $303: (s: stringstd/core/types/string: V) -> exnstd/core/exn/exn: (E, V) -> V bb: V
)result: -> <console,exn> (370, 371): <std/core/types/total: Econsolestd/core/console/console: X,exnstd/core/exn/exn: (E, V) -> V> (std/core/types/tuple2: (V, V) -> Vaa: V, bb: V)
  match readlinestd/os/readline/readline: () -> <console,exn> string().splitstd/core/string/splitn/split: (s : string, sep : string, n : int) -> <console,exn> list<string>(" "literal: string
count= 1, 2literal: int
dec  = 2
hex8 = 0x02
bit8 = 0b00000010)
    [s1std/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>, s2std/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>]std/core/types/Nil: forall<a> list<a> -> (std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)s1s1: string.parse1parse1: (s : string) -> <exn,console> $302, s2s2: string.parse2parse2: (s : string) -> <exn,console> $303)std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)
    _ -> throwstd/core/exn/throw: (message : string, info : ? exception-info) -> <exn,console> ($302, $303)("expect two values"literal: string
count= 17)

// Read three values in a line.
// The values must be separated by a single space, and each value except the
// last must not contain spaces.
pub inline fun tuple3/readck/io/tuple3/read: forall<a,b,c> (parse1 : (s : string) -> exn a, parse2 : (s : string) -> exn b, parse3 : (s : string) -> exn c) -> <console,exn> (a, b, c)(
  parse1parse1: (s : string) -> exn $379: (s: stringstd/core/types/string: V) -> exnstd/core/exn/exn: (E, V) -> V aa: V,
  parse2parse2: (s : string) -> exn $380: (s: stringstd/core/types/string: V) -> exnstd/core/exn/exn: (E, V) -> V bb: V,
  parse3parse3: (s : string) -> exn $381: (s: stringstd/core/types/string: V) -> exnstd/core/exn/exn: (E, V) -> V cc: V
)result: -> <console,exn> (463, 464, 465): <std/core/types/total: Econsolestd/core/console/console: X,exnstd/core/exn/exn: (E, V) -> V> (std/core/types/tuple3: (V, V, V) -> Vaa: V, bb: V, cc: V)
  match readlinestd/os/readline/readline: () -> <console,exn> string().splitstd/core/string/splitn/split: (s : string, sep : string, n : int) -> <console,exn> list<string>(" "literal: string
count= 1, 3literal: int
dec  = 3
hex8 = 0x03
bit8 = 0b00000011)
    [s1std/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>, s2std/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>, s3std/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>]std/core/types/Nil: forall<a> list<a> -> (std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c)s1s1: string.parse1parse1: (s : string) -> <exn,console> $379, s2s2: string.parse2parse2: (s : string) -> <exn,console> $380, s3s3: string.parse3parse3: (s : string) -> <exn,console> $381)std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c)
    _ -> throwstd/core/exn/throw: (message : string, info : ? exception-info) -> <exn,console> ($379, $380, $381)("expect three values"literal: string
count= 19)

// Read four values in a line.
// The values must be separated by a single space, and each value except the
// last must not contain spaces.
pub inline fun tuple4/readck/io/tuple4/read: forall<a,b,c,d> (parse1 : (s : string) -> exn a, parse2 : (s : string) -> exn b, parse3 : (s : string) -> exn c, parse4 : (s : string) -> exn d) -> <console,exn> (a, b, c, d)(
  parse1parse1: (s : string) -> exn $476: (s: stringstd/core/types/string: V) -> exnstd/core/exn/exn: (E, V) -> V aa: V,
  parse2parse2: (s : string) -> exn $477: (s: stringstd/core/types/string: V) -> exnstd/core/exn/exn: (E, V) -> V bb: V,
  parse3parse3: (s : string) -> exn $478: (s: stringstd/core/types/string: V) -> exnstd/core/exn/exn: (E, V) -> V cc: V,
  parse4parse4: (s : string) -> exn $479: (s: stringstd/core/types/string: V) -> exnstd/core/exn/exn: (E, V) -> V dd: V
)result: -> <console,exn> (576, 577, 578, 579): <std/core/types/total: Econsolestd/core/console/console: X,exnstd/core/exn/exn: (E, V) -> V> (std/core/types/tuple4: (V, V, V, V) -> Vaa: V, bb: V, cc: V, dd: V)
  match readlinestd/os/readline/readline: () -> <console,exn> string().splitstd/core/string/splitn/split: (s : string, sep : string, n : int) -> <console,exn> list<string>(" "literal: string
count= 1, 4literal: int
dec  = 4
hex8 = 0x04
bit8 = 0b00000100)
    [s1std/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>, s2std/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>, s3std/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>, s4std/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>]std/core/types/Nil: forall<a> list<a> -> (std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)
      s1s1: string.parse1parse1: (s : string) -> <exn,console> $476,
      s2s2: string.parse2parse2: (s : string) -> <exn,console> $477,
      s3s3: string.parse3parse3: (s : string) -> <exn,console> $478,
      s4s4: string.parse4parse4: (s : string) -> <exn,console> $479
    )std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)
    _ -> throwstd/core/exn/throw: (message : string, info : ? exception-info) -> <exn,console> ($476, $477, $478, $479)("expect four values"literal: string
count= 18)

// Read five values in a line.
// The values must be separated by a single space, and each value except the
// last must not contain spaces.
pub inline fun tuple5/readck/io/tuple5/read: forall<a,b,c,d,a1> (parse1 : (s : string) -> exn a, parse2 : (s : string) -> exn b, parse3 : (s : string) -> exn c, parse4 : (s : string) -> exn d, parse5 : (s : string) -> exn a1) -> <console,exn> (a, b, c, d, a1)(
  parse1parse1: (s : string) -> exn $593: (s: stringstd/core/types/string: V) -> exnstd/core/exn/exn: (E, V) -> V aa: V,
  parse2parse2: (s : string) -> exn $594: (s: stringstd/core/types/string: V) -> exnstd/core/exn/exn: (E, V) -> V bb: V,
  parse3parse3: (s : string) -> exn $595: (s: stringstd/core/types/string: V) -> exnstd/core/exn/exn: (E, V) -> V cc: V,
  parse4parse4: (s : string) -> exn $596: (s: stringstd/core/types/string: V) -> exnstd/core/exn/exn: (E, V) -> V dd: V,
  parse5parse5: (s : string) -> exn $597: (s: stringstd/core/types/string: V) -> exnstd/core/exn/exn: (E, V) -> V ee: V
)result: -> <console,exn> (709, 710, 711, 712, 713): <std/core/types/total: Econsolestd/core/console/console: X,exnstd/core/exn/exn: (E, V) -> V> (std/core/types/tuple5: (V, V, V, V, V) -> Vaa: V, bb: V, cc: V, dd: V, ee: V)
  match readlinestd/os/readline/readline: () -> <console,exn> string().splitstd/core/string/splitn/split: (s : string, sep : string, n : int) -> <console,exn> list<string>(" "literal: string
count= 1, 5literal: int
dec  = 5
hex8 = 0x05
bit8 = 0b00000101)
    [s1std/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>, s2std/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>, s3std/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>, s4std/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>, s5std/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>]std/core/types/Nil: forall<a> list<a> -> (std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)
      s1s1: string.parse1parse1: (s : string) -> <exn,console> $593,
      s2s2: string.parse2parse2: (s : string) -> <exn,console> $594,
      s3s3: string.parse3parse3: (s : string) -> <exn,console> $595,
      s4s4: string.parse4parse4: (s : string) -> <exn,console> $596,
      s5s5: string.parse5parse5: (s : string) -> <exn,console> $597
    )std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)
    _ -> throwstd/core/exn/throw: (message : string, info : ? exception-info) -> <exn,console> ($593, $594, $595, $596, $597)("expect five values"literal: string
count= 18)

extern unsafe/read-int64-internalck/io/unsafe/read-int64-internal: (i : int64) -> console int64(ii: int64: int64std/core/types/int64: V): consolestd/core/console/console: X int64std/core/types/int64: V
  c inline "(scanf(\"%\" SCNd64, &#1), #1)"

// Unsafe: read int64 from the standard input.
// This function is necessary for strict time limits.
pub fun unsafe/read-int64ck/io/unsafe/read-int64: () -> console int64()result: -> console int64: consolestd/core/console/console: X int64std/core/types/int64: V
  read-int64-internalck/io/unsafe/read-int64-internal: (i : int64) -> console int64(0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000.int64std/num/int64/int64: (i : int) -> console int64)

extern unsafe/read-float64-internalck/io/unsafe/read-float64-internal: (f : float64) -> console float64(ff: float64: float64std/core/types/float64: V): consolestd/core/console/console: X float64std/core/types/float64: V
  c inline "(scanf(\"%lf\", &#1), #1)"

// Unsafe: read float64 from the standard input
// This function is necessary for strict time limits.
pub fun unsafe/read-float64ck/io/unsafe/read-float64: () -> console float64()result: -> console float64: consolestd/core/console/console: X float64std/core/types/float64: V
  read-float64-internalck/io/unsafe/read-float64-internal: (f : float64) -> console float64(0.0literal: float64
hex64= 0x0p+0)

/// Implementation notes of */print:
/// - The implicit parameters are ?print not ?show because show/string/show is
///   chosen for strings in default and it outputs unnecessary double quotes.
/// - The inlined version of default/double/print was faster than the non-inlined
///   version in a benchmark. But for default/triple/print and its successors,
///   inlining made a slight difference in performance. Hence only default/double/print
///   is inlined.

pub inline fun default/double/printck/io/default/double/print: forall<a,b> (a : a, b : b, @implicit/a/print : (a) -> console (), @implicit/b/print : (b) -> console ()) -> console ()(aa: $812: aa: V, bb: $813: bb: V, @implicit/a/print?a/print: ($812) -> console (): aa: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V, @implicit/b/print?b/print: ($813) -> console (): bb: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V)result: -> console ()
  print?a/print: ($812) -> console ()(aa: $812)
  printstd/core/console/string/print: (s : string) -> console ()(" "literal: string
count= 1)
  print?b/print: ($813) -> console ()(bb: $813)

pub inline fun default/double/printlnck/io/default/double/println: forall<a,b> (a : a, b : b, @implicit/a/print : (a) -> console (), @implicit/b/print : (b) -> console ()) -> console ()(aa: $2326: aa: V, bb: $2327: bb: V, @implicit/a/print?a/print: ($2326) -> console (): aa: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V, @implicit/b/print?b/print: ($2327) -> console (): bb: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V)result: -> console ()
  printck/io/default/double/print: (a : $2326, b : $2327, @implicit/a/print : ($2326) -> console (), @implicit/b/print : ($2327) -> console ()) -> console ()
?a/print=?a/print
?b/print=?b/print(aa: $2326, bb: $2327)
  printstd/core/console/string/print: (s : string) -> console ()("\n"literal: string
count= 1)

pub fun default/triple/printck/io/default/triple/print: forall<a,b,c> (a : a, b : b, c : c, @implicit/a/print : (a) -> console (), @implicit/b/print : (b) -> console (), @implicit/c/print : (c) -> console ()) -> console ()(
  aa: $1660: aa: V, bb: $1661: bb: V, cc: $1662: cc: V,
  @implicit/a/print?a/print: ($1660) -> console (): aa: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V, @implicit/b/print?b/print: ($1661) -> console (): bb: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V, @implicit/c/print?c/print: ($1662) -> console (): cc: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V
)result: -> console ()
  print?a/print: ($1660) -> console ()(aa: $1660)
  printstd/core/console/string/print: (s : string) -> console ()(" "literal: string
count= 1)
  print?b/print: ($1661) -> console ()(bb: $1661)
  printstd/core/console/string/print: (s : string) -> console ()(" "literal: string
count= 1)
  print?c/print: ($1662) -> console ()(cc: $1662)

pub fun default/triple/printlnck/io/default/triple/println: forall<a,b,c> (a : a, b : b, c : c, @implicit/a/print : (a) -> console (), @implicit/b/print : (b) -> console (), @implicit/c/print : (c) -> console ()) -> console ()(
  aa: $2824: aa: V, bb: $2825: bb: V, cc: $2826: cc: V,
  @implicit/a/print?a/print: ($2824) -> console (): aa: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V, @implicit/b/print?b/print: ($2825) -> console (): bb: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V, @implicit/c/print?c/print: ($2826) -> console (): cc: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V
)result: -> console ()
  printck/io/default/triple/print: (a : $2824, b : $2825, c : $2826, @implicit/a/print : ($2824) -> console (), @implicit/b/print : ($2825) -> console (), @implicit/c/print : ($2826) -> console ()) -> console ()
?a/print=?a/print
?b/print=?b/print
?c/print=?c/print(aa: $2824, bb: $2825, cc: $2826)
  printstd/core/console/string/print: (s : string) -> console ()("\n"literal: string
count= 1)

pub fun default/quadruple/printck/io/default/quadruple/print: forall<a,b,c,d> (a : a, b : b, c : c, d : d, @implicit/a/print : (a) -> console (), @implicit/b/print : (b) -> console (), @implicit/c/print : (c) -> console (), @implicit/d/print : (d) -> console ()) -> console ()(
  aa: $948: aa: V, bb: $949: bb: V, cc: $950: cc: V, dd: $951: dd: V,
  @implicit/a/print?a/print: ($948) -> console (): aa: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V, @implicit/b/print?b/print: ($949) -> console (): bb: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V, @implicit/c/print?c/print: ($950) -> console (): cc: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V, @implicit/d/print?d/print: ($951) -> console (): dd: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V
)result: -> console ()
  print?a/print: ($948) -> console ()(aa: $948)
  printstd/core/console/string/print: (s : string) -> console ()(" "literal: string
count= 1)
  print?b/print: ($949) -> console ()(bb: $949)
  printstd/core/console/string/print: (s : string) -> console ()(" "literal: string
count= 1)
  print?c/print: ($950) -> console ()(cc: $950)
  printstd/core/console/string/print: (s : string) -> console ()(" "literal: string
count= 1)
  print?d/print: ($951) -> console ()(dd: $951)

pub fun default/quadruple/printlnck/io/default/quadruple/println: forall<a,b,c,d> (a : a, b : b, c : c, d : d, @implicit/a/print : (a) -> console (), @implicit/b/print : (b) -> console (), @implicit/c/print : (c) -> console (), @implicit/d/print : (d) -> console ()) -> console ()(
  aa: $3521: aa: V, bb: $3522: bb: V, cc: $3523: cc: V, dd: $3524: dd: V,
  @implicit/a/print?a/print: ($3521) -> console (): aa: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V, @implicit/b/print?b/print: ($3522) -> console (): bb: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V, @implicit/c/print?c/print: ($3523) -> console (): cc: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V, @implicit/d/print?d/print: ($3524) -> console (): dd: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V
)result: -> console ()
  printck/io/default/quadruple/print: (a : $3521, b : $3522, c : $3523, d : $3524, @implicit/a/print : ($3521) -> console (), @implicit/b/print : ($3522) -> console (), @implicit/c/print : ($3523) -> console (), @implicit/d/print : ($3524) -> console ()) -> console ()
?a/print=?a/print
?b/print=?b/print
?c/print=?c/print
?d/print=?d/print(aa: $3521, bb: $3522, cc: $3523, dd: $3524)
  printstd/core/console/string/print: (s : string) -> console ()("\n"literal: string
count= 1)

pub fun default/quintuple/printck/io/default/quintuple/print: forall<a,b,c,d,a1> (a : a, b : b, c : c, d : d, e : a1, @implicit/a/print : (a) -> console (), @implicit/b/print : (b) -> console (), @implicit/c/print : (c) -> console (), @implicit/d/print : (d) -> console (), @implicit/e/print : (a1) -> console ()) -> console ()(
  aa: $1260: aa: V, bb: $1261: bb: V, cc: $1262: cc: V, dd: $1263: dd: V, ee: $1264: ee: V,
  @implicit/a/print?a/print: ($1260) -> console (): aa: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V, @implicit/b/print?b/print: ($1261) -> console (): bb: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V, @implicit/c/print?c/print: ($1262) -> console (): cc: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V, @implicit/d/print?d/print: ($1263) -> console (): dd: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V, @implicit/e/print?e/print: ($1264) -> console (): ee: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V
)result: -> console ()
  print?a/print: ($1260) -> console ()(aa: $1260)
  printstd/core/console/string/print: (s : string) -> console ()(" "literal: string
count= 1)
  print?b/print: ($1261) -> console ()(bb: $1261)
  printstd/core/console/string/print: (s : string) -> console ()(" "literal: string
count= 1)
  print?c/print: ($1262) -> console ()(cc: $1262)
  printstd/core/console/string/print: (s : string) -> console ()(" "literal: string
count= 1)
  print?d/print: ($1263) -> console ()(dd: $1263)
  printstd/core/console/string/print: (s : string) -> console ()(" "literal: string
count= 1)
  print?e/print: ($1264) -> console ()(ee: $1264)

pub fun default/quintuple/printlnck/io/default/quintuple/println: forall<a,b,c,d,a1> (a : a, b : b, c : c, d : d, e : a1, @implicit/a/print : (a) -> console (), @implicit/b/print : (b) -> console (), @implicit/c/print : (c) -> console (), @implicit/d/print : (d) -> console (), @implicit/e/print : (a1) -> console ()) -> console ()(
  aa: $4508: aa: V, bb: $4509: bb: V, cc: $4510: cc: V, dd: $4511: dd: V, ee: $4512: ee: V,
  @implicit/a/print?a/print: ($4508) -> console (): aa: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V, @implicit/b/print?b/print: ($4509) -> console (): bb: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V, @implicit/c/print?c/print: ($4510) -> console (): cc: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V, @implicit/d/print?d/print: ($4511) -> console (): dd: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V, @implicit/e/print?e/print: ($4512) -> console (): ee: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V
)result: -> console ()
  printck/io/default/quintuple/print: (a : $4508, b : $4509, c : $4510, d : $4511, e : $4512, @implicit/a/print : ($4508) -> console (), @implicit/b/print : ($4509) -> console (), @implicit/c/print : ($4510) -> console (), @implicit/d/print : ($4511) -> console (), @implicit/e/print : ($4512) -> console ()) -> console ()
?a/print=?a/print
?b/print=?b/print
?c/print=?c/print
?d/print=?d/print
?e/print=?e/print(aa: $4508, bb: $4509, cc: $4510, dd: $4511, ee: $4512)
  printstd/core/console/string/print: (s : string) -> console ()("\n"literal: string
count= 1)

// Print a character.
// Unlike the default print function, this function does not insert quotes.
pub fun char/printck/io/char/print: (c : char) -> console ()(cc: char: charstd/core/types/char: V)result: -> console ()
  cc: char.stringstd/core/string/char/string: (c : char) -> console string.printstd/core/console/string/print: (s : string) -> console ()

// Print a character with a newline.
// Unlike the default println function, this function does not insert quotes.
pub fun char/printlnck/io/char/println: (c : char) -> console ()(cc: char: charstd/core/types/char: V)result: -> console ()
  cc: char.printck/io/char/print: (c : char) -> console ()
  ""literal: string
count= 0.printlnstd/core/console/string/println: (s : string) -> console ()

pub fun list/printck/io/list/print: forall<a> (l : list<a>, sep : ? string, @implicit/print : (a) -> console ()) -> console ()(ll: list<$1884>: liststd/core/types/list: V -> V<aa: V>, sepsep: ? string: stringstd/core/types/string: V = " "literal: string
count= 1, @implicit/print?print: ($1884) -> console (): aa: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V)result: -> console ()
  var firstfirst: local-var<$1898,bool> := Truestd/core/types/True: bool
  ll: list<$1884>.foreachstd/core/list/foreach: (xs : list<$1884>, action : ($1884) -> <console,local<$1898>> ()) -> <console,local<$1898>> () fnfn: (x : $1884) -> <console,local<$1898>> ()(xx: $1884)
    if firstfirst: bool
?hdiv=iev@1937 then firstfirst: local-var<$1898,bool> :=std/core/types/local-set: (v : local-var<$1898,bool>, assigned : bool) -> <local<$1898>,console> () Falsestd/core/types/False: bool else sepsep: string.printstd/core/console/string/print: (s : string) -> <console,local<$1898>> ()
    xx: $1884.print?print: ($1884) -> <console,local<$1898>> ()

pub fun list/printlnck/io/list/println: forall<a> (l : list<a>, sep : ? string, @implicit/print : (a) -> console ()) -> console ()(ll: list<$5725>: liststd/core/types/list: V -> V<aa: V>, sepsep: ? string: stringstd/core/types/string: V = " "literal: string
count= 1, @implicit/print?print: ($5725) -> console (): aa: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V)result: -> console ()
  ll: list<$5725>.printck/io/list/print: (l : list<$5725>, sep : ? string, @implicit/print : ($5725) -> console ()) -> console ()
?print=?print(sepsep: string)
  ""literal: string
count= 0.printlnstd/core/console/string/println: (s : string) -> console ()

pub fun vector/printck/io/vector/print: forall<a> (v : vector<a>, sep : ? string, @implicit/print : (a) -> console ()) -> console ()(vv: vector<$2065>: vectorstd/core/types/vector: V -> V<aa: V>, sepsep: ? string: stringstd/core/types/string: V = " "literal: string
count= 1, @implicit/print?print: ($2065) -> console (): aa: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V)result: -> console ()
  var firstfirst: local-var<$2079,bool> := Truestd/core/types/True: bool
  vv: vector<$2065>.foreachstd/core/vector/foreach: (v : vector<$2065>, f : ($2065) -> <console,local<$2079>> ()) -> <console,local<$2079>> () fnfn: (x : $2065) -> <console,local<$2079>> ()(xx: $2065)
    if firstfirst: bool
?hdiv=iev@2118 then firstfirst: local-var<$2079,bool> :=std/core/types/local-set: (v : local-var<$2079,bool>, assigned : bool) -> <local<$2079>,console> () Falsestd/core/types/False: bool else sepsep: string.printstd/core/console/string/print: (s : string) -> <console,local<$2079>> ()
    xx: $2065.print?print: ($2065) -> <console,local<$2079>> ()

pub fun vector/printlnck/io/vector/println: forall<a> (v : vector<a>, sep : ? string, @implicit/print : (a) -> console ()) -> console ()(vv: vector<$6203>: vectorstd/core/types/vector: V -> V<aa: V>, sepsep: ? string: stringstd/core/types/string: V = " "literal: string
count= 1, @implicit/print?print: ($6203) -> console (): aa: V -> consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V)result: -> console ()
  vv: vector<$6203>.printck/io/vector/print: (v : vector<$6203>, sep : ? string, @implicit/print : ($6203) -> console ()) -> console ()
?print=?print(sepsep: string)
  ""literal: string
count= 0.printlnstd/core/console/string/println: (s : string) -> console ()

pub extern flushck/io/flush: () -> console ()(): consolestd/core/console/console: X (std/core/types/unit: V)std/core/types/unit: V
    c inline "(fflush(stdout))"