erg_compiler 0.6.53

Centimetre: the Erg compiler
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

.DEFAULT_BUFFER_SIZE: {8192}

.BlockingIOError = BlockingIOError
.UnsupportedOperation: ClassType
.UnsupportedOperation <: OSError
.UnsupportedOperation <: ValueError

.IOBase!: ClassType
.IOBase! <: FileLike!
.IOBase!.
    close!: (self: RefMut(.IOBase!),) => NoneType
    closed: Bool
    fileno: (self: Ref(.IOBase!),) -> Nat
    flush!: (self: RefMut(.IOBase!),) => NoneType
    isatty: (self: Ref(.IOBase!),) -> Bool
    readable: (self: Ref(.IOBase!),) -> Bool
    readline!: (self: RefMut(.IOBase!), size := Nat) => Str
    readlines!: (self: RefMut(.IOBase!), hint := Nat) => [Str; _]
    seek!: (self: RefMut(.IOBase!), offset: Nat, whence := Nat) => Nat
    seekable: (self: Ref(.IOBase!),) -> Bool
    tell!: (self: RefMut(.IOBase!),) => Nat
    truncate!: (self: RefMut(.IOBase!), size := Nat) => Nat
    writable: (self: Ref(.IOBase!),) -> Bool
    writelines!: (self: RefMut(.IOBase!), lines: [Str; _]) => NoneType

.RawIOBase!: ClassType
.RawIOBase! <: .IOBase!
.RawIOBase!.
    read!: (self: RefMut(.RawIOBase!), size := Nat) => Bytes
    readall!: (self: RefMut(.RawIOBase!),) => Bytes
    readinto!: (self: RefMut(.RawIOBase!), b: Bytes) => Nat
    write!: (self: RefMut(.RawIOBase!), b: Bytes) => Nat

.BufferedIOBase!: ClassType
.BufferedIOBase! <: .IOBase!
.BufferedIOBase!.
    raw: .RawIOBase!
    detach!: (self: RefMut(.BufferedIOBase!),) => .RawIOBase!
    read!: (self: RefMut(.BufferedIOBase!), size := Nat) => Bytes
    read1!: (self: RefMut(.BufferedIOBase!), size := Nat) => Bytes
    readinto!: (self: RefMut(.BufferedIOBase!), b: Bytes) => Nat
    readinto1!: (self: RefMut(.BufferedIOBase!), b: Bytes) => Nat
    write!: (self: RefMut(.BufferedIOBase!), b: Bytes) => Nat

.FileIO!: ClassType
.FileIO! <: .RawIOBase!
.FileIO!.
    __call__: (path: PathLike, mode := Str, closefd := Bool, opener := NoneType) -> .FileIO!
    mode: Str
    name: Str

.BytesIO!: ClassType
.BytesIO! <: .BufferedIOBase!
.BytesIO!.
    __call__: (initial_bytes := Bytes) -> .BytesIO!
    getvalue: (self: Ref(.BytesIO!),) -> Bytes

.BufferedReader!: ClassType
.BufferedReader! <: .BufferedIOBase!
.BufferedReader!.
    __call__: (raw: .RawIOBase!, buffer_size := Nat) -> .BufferedReader!
    peek!: (self: RefMut(.BufferedReader!), size := Nat) => Bytes
    read!: (self: RefMut(.BufferedReader!), size := Nat) => Bytes
    read1!: (self: RefMut(.BufferedReader!), size := Nat) => Bytes

.BufferedWriter!: ClassType
.BufferedWriter! <: .BufferedIOBase!
.BufferedWriter!.
    __call__: (raw: .RawIOBase!, buffer_size := Nat) -> .BufferedWriter!
    flush!: (self: RefMut(.BufferedWriter!),) => NoneType
    write!: (self: RefMut(.BufferedWriter!), b: Bytes) => Nat

.BufferedRandom!: ClassType
.BufferedRandom! <: .BufferedReader!

.BufferedRWPair!: ClassType
.BufferedRWPair! <: .BufferedIOBase!

.TextIOBase!: ClassType
.TextIOBase! <: .IOBase!
.TextIOBase!.
    encoding: Str
    errors: Str
    newlines: Str or [Str; _] or NoneType
    buffer: .BufferedIOBase!
    detach!: (self: RefMut(.TextIOBase!),) => .BufferedIOBase!
    read!: (self: RefMut(.TextIOBase!), size := Nat) => Str
    readline!: (self: RefMut(.TextIOBase!), size := Nat) => Str
    seek!: (self: RefMut(.TextIOBase!), offset: Nat, whence := Nat) => Nat
    tell!: (self: RefMut(.TextIOBase!),) => Nat
    write!: (self: RefMut(.TextIOBase!), s: Str) => Nat

.TextIOWrapper!: ClassType
.TextIOWrapper! <: .TextIOBase!
.TextIOWrapper!.
    __call__: (buffer: .BufferedIOBase!, encoding := Str, errors := Str, newline := Str, line_buffering := Bool) -> .TextIOWrapper!
    line_buffering: Bool
    write_through: Bool
    reconfigure!: (self: RefMut(.TextIOWrapper!), encoding := Str, errors := Str, newline := Str) => NoneType

.StringIO!: ClassType
.StringIO! <: .TextIOBase!
.StringIO!.
    __call__: (initial_value := Str, newline := Str) -> .StringIO!
    getvalue: (self: Ref(.StringIO!),) -> Str

.open!: (file: PathLike, mode := Str, buffering := Nat, encoding := Str or NoneType) -> File!
.open_code!: (path: PathLike) -> File!
.text_encoding: (encoding: Str or NoneType, stacklevel := Nat) -> Str