eo-phi-normalizer-3.0.0: data/0.50.0/dependencies.md
# Dependencies
## [org/eolang/bytes.phi](./org/eolang/bytes.phi)
```console
{⟦
org() ↦ ⟦
eolang() ↦ ⟦
bytes(data) ↦ ⟦
φ ↦ ξ.data,
as-bytes ↦ ξ,
as-bool ↦ ξ.eq(Φ̇.bytes(⟦ Δ ⤍ 01- ⟧)),
as-number() ↦ ⟦
φ ↦ ξ.ρ.eq(Φ̇.nan.as-bytes).if(
Φ̇.nan,
ξ.ρ.eq(Φ̇.positive-infinity.as-bytes).if(
Φ̇.positive-infinity,
ξ.ρ.eq(Φ̇.negative-infinity.as-bytes).if(
Φ̇.negative-infinity,
ξ.ρ.size.eq(8).if(
Φ̇.number(ξ.ρ),
Φ̇.error(
Φ̇.txt.sprintf(
"Can't convert non 8 length bytes to a number, bytes are %x",
Φ̇.tuple(Φ̇.tuple.empty, ξ.ρ)
)
)
)
)
)
)
⟧,
eq(b) ↦ ⟦
λ ⤍ Lorg_eolang_bytes_eq
⟧,
size() ↦ ⟦
λ ⤍ Lorg_eolang_bytes_size
⟧,
slice(start, len) ↦ ⟦
λ ⤍ Lorg_eolang_bytes_slice
⟧,
as-i64() ↦ ⟦
φ ↦ ξ.ρ.size.eq(8).if(
Φ̇.i64(ξ.ρ),
Φ̇.error(
Φ̇.txt.sprintf(
"Can't convert non 8 length bytes to i64, bytes are %x",
Φ̇.tuple(Φ̇.tuple.empty, ξ.ρ)
)
)
)
⟧,
as-i32() ↦ ⟦
φ ↦ ξ.ρ.size.eq(4).if(
Φ̇.i32(ξ.ρ),
Φ̇.error(
Φ̇.txt.sprintf(
"Can't convert non 4 length bytes to i32, bytes are %x",
Φ̇.tuple(Φ̇.tuple.empty, ξ.ρ)
)
)
)
⟧,
as-i16() ↦ ⟦
φ ↦ ξ.ρ.size.eq(2).if(
Φ̇.i16(ξ.ρ),
Φ̇.error(
Φ̇.txt.sprintf(
"Can't convert non 2 length bytes to i16, bytes are %x",
Φ̇.tuple(Φ̇.tuple.empty, ξ.ρ)
)
)
)
⟧,
and(b) ↦ ⟦
λ ⤍ Lorg_eolang_bytes_and
⟧,
or(b) ↦ ⟦
λ ⤍ Lorg_eolang_bytes_or
⟧,
xor(b) ↦ ⟦
λ ⤍ Lorg_eolang_bytes_xor
⟧,
not() ↦ ⟦
λ ⤍ Lorg_eolang_bytes_not
⟧,
left(x) ↦ ⟦
φ ↦ ξ.ρ.right(ξ.x.neg)
⟧,
right(x) ↦ ⟦
λ ⤍ Lorg_eolang_bytes_right
⟧,
concat(b) ↦ ⟦
λ ⤍ Lorg_eolang_bytes_concat
⟧
⟧,
λ ⤍ Package
⟧,
λ ⤍ Package
⟧
⟧}
```
## [org/eolang/dataized.phi](./org/eolang/dataized.phi)
```console
{⟦
org() ↦ ⟦
eolang() ↦ ⟦
dataized(target) ↦ ⟦
φ ↦ Φ̇.try(
ξ.target,
⟦
ex ↦ ∅,
φ ↦ Φ̇.error(ξ.ex)
⟧,
Φ̇.bytes(⟦ Δ ⤍ 01- ⟧)
)
⟧,
λ ⤍ Package
⟧,
λ ⤍ Package
⟧
⟧}
```
## [org/eolang/error.phi](./org/eolang/error.phi)
```console
{⟦
org() ↦ ⟦
eolang() ↦ ⟦
error(message) ↦ ⟦
λ ⤍ Lorg_eolang_error
⟧,
λ ⤍ Package
⟧,
λ ⤍ Package
⟧
⟧}
```
## [org/eolang/false.phi](./org/eolang/false.phi)
```console
{⟦
org() ↦ ⟦
eolang() ↦ ⟦
false() ↦ ⟦
φ ↦ Φ̇.bytes(⟦ Δ ⤍ 00- ⟧),
not ↦ Φ̇.true,
if(left, right) ↦ ⟦
φ ↦ ξ.right
⟧,
and(x) ↦ ⟦
φ ↦ ξ.ρ
⟧,
or(x) ↦ ⟦
φ ↦ Φ̇.bytes(⟦ Δ ⤍ 01- ⟧).eq(ξ.x)
⟧
⟧,
λ ⤍ Package
⟧,
λ ⤍ Package
⟧
⟧}
```
## [org/eolang/i16.phi](./org/eolang/i16.phi)
```console
{⟦
org() ↦ ⟦
eolang() ↦ ⟦
i16(as-bytes) ↦ ⟦
φ ↦ ξ.as-bytes,
as-i16 ↦ ξ,
neg ↦ ξ.times(-1.as-i64.as-i32.as-i16),
as-i64 ↦ ξ.as-i32.as-i64,
as-number ↦ ξ.as-i64.as-number,
as-i32() ↦ ⟦
λ ⤍ Lorg_eolang_i16_as_i32
⟧,
lt(x) ↦ ⟦
φ ↦ ξ.ρ.as-i32.lt(ξ.x.as-i16.as-i32)
⟧,
lte(x) ↦ ⟦
φ ↦ ξ.ρ.as-i32.lte(ξ.x.as-i16.as-i32)
⟧,
gt(x) ↦ ⟦
φ ↦ ξ.ρ.as-i32.gt(ξ.x.as-i16.as-i32)
⟧,
gte(x) ↦ ⟦
φ ↦ ξ.ρ.as-i32.gte(ξ.x.as-i16.as-i32)
⟧,
times(x) ↦ ⟦
bts ↦ ξ.ρ.as-i32.times(ξ.x.as-i16.as-i32).as-bytes,
left ↦ ξ.bts.slice(0, 2),
right ↦ ξ.bts.slice(2, 2),
φ ↦ ξ.left.eq(Φ̇.bytes(⟦ Δ ⤍ 00-00 ⟧)).or(
ξ.left.eq(Φ̇.bytes(⟦ Δ ⤍ FF-FF ⟧))
).if(ξ.ρ.ρ.i16(ξ.right), ξ.ρ.ρ.i16(ξ.left).plus(ξ.ρ.ρ.i16(ξ.right)))
⟧,
plus(x) ↦ ⟦
bts ↦ ξ.ρ.as-i32.plus(ξ.x.as-i16.as-i32).as-bytes,
left ↦ ξ.bts.slice(0, 2),
right ↦ ξ.bts.slice(2, 2),
φ ↦ ξ.left.eq(Φ̇.bytes(⟦ Δ ⤍ 00-00 ⟧)).or(
ξ.left.eq(Φ̇.bytes(⟦ Δ ⤍ FF-FF ⟧))
).if(ξ.ρ.ρ.i16(ξ.right), ξ.ρ.ρ.i16(ξ.left).plus(ξ.ρ.ρ.i16(ξ.right)))
⟧,
minus(x) ↦ ⟦
φ ↦ ξ.ρ.plus(ξ.x.as-i16.neg)
⟧,
div(x) ↦ ⟦
x-as-i16 ↦ ξ.x.as-i16,
bts ↦ ξ.ρ.as-i32.div(ξ.x-as-i16.as-i32).as-bytes,
left ↦ ξ.bts.slice(0, 2),
right ↦ ξ.bts.slice(2, 2),
zero ↦ Φ̇.bytes(⟦ Δ ⤍ 00-00 ⟧),
φ ↦ ξ.x-as-i16.eq(ξ.zero).if(
Φ̇.error(
Φ̇.txt.sprintf(
"Can't divide %d by i16 zero",
Φ̇.tuple(Φ̇.tuple.empty, ξ.ρ.as-i32.as-i64.as-number)
)
),
ξ.left.eq(ξ.zero).or(ξ.left.eq(Φ̇.bytes(⟦ Δ ⤍ FF-FF ⟧))).if(
ξ.ρ.ρ.i16(ξ.right), ξ.ρ.ρ.i16(ξ.left).plus(ξ.ρ.ρ.i16(ξ.right))
)
)
⟧
⟧,
λ ⤍ Package
⟧,
λ ⤍ Package
⟧
⟧}
```
## [org/eolang/i32.phi](./org/eolang/i32.phi)
```console
{⟦
org() ↦ ⟦
eolang() ↦ ⟦
i32(as-bytes) ↦ ⟦
φ ↦ ξ.as-bytes,
as-i32 ↦ ξ,
neg ↦ ξ.times(-1.as-i64.as-i32),
as-number ↦ ξ.as-i64.as-number,
as-i64() ↦ ⟦
λ ⤍ Lorg_eolang_i32_as_i64
⟧,
as-i16() ↦ ⟦
left ↦ ξ.ρ.as-bytes.slice(0, 2).as-bytes,
φ ↦ ξ.left.eq(Φ̇.bytes(⟦ Δ ⤍ 00-00 ⟧)).or(
ξ.left.eq(Φ̇.bytes(⟦ Δ ⤍ FF-FF ⟧))
).if(
Φ̇.i16(ξ.ρ.as-bytes.slice(2, 2)),
Φ̇.error(
Φ̇.txt.sprintf(
"Can't convert i32 number %d to i16 because it's out of i16 bounds",
Φ̇.tuple(Φ̇.tuple.empty, ξ.ρ.as-i64.as-number)
)
)
)
⟧,
lt(x) ↦ ⟦
φ ↦ ξ.ρ.as-i64.lt(ξ.x.as-i32.as-i64)
⟧,
lte(x) ↦ ⟦
φ ↦ ξ.ρ.as-i64.lte(ξ.x.as-i32.as-i64)
⟧,
gt(x) ↦ ⟦
φ ↦ ξ.ρ.as-i64.gt(ξ.x.as-i32.as-i64)
⟧,
gte(x) ↦ ⟦
φ ↦ ξ.ρ.as-i64.gte(ξ.x.as-i32.as-i64)
⟧,
times(x) ↦ ⟦
bts ↦ ξ.ρ.as-i64.times(ξ.x.as-i32.as-i64).as-bytes,
left ↦ ξ.bts.slice(0, 4),
right ↦ ξ.bts.slice(4, 4),
φ ↦ ξ.left.eq(Φ̇.bytes(⟦ Δ ⤍ 00-00-00-00 ⟧)).or(
ξ.left.eq(Φ̇.bytes(⟦ Δ ⤍ FF-FF-FF-FF ⟧))
).if(ξ.ρ.ρ.i32(ξ.right), ξ.ρ.ρ.i32(ξ.left).plus(ξ.ρ.ρ.i32(ξ.right)))
⟧,
plus(x) ↦ ⟦
bts ↦ ξ.ρ.as-i64.plus(ξ.x.as-i32.as-i64).as-bytes,
left ↦ ξ.bts.slice(0, 4),
right ↦ ξ.bts.slice(4, 4),
φ ↦ ξ.left.eq(Φ̇.bytes(⟦ Δ ⤍ 00-00-00-00 ⟧)).or(
ξ.left.eq(Φ̇.bytes(⟦ Δ ⤍ FF-FF-FF-FF ⟧))
).if(ξ.ρ.ρ.i32(ξ.right), ξ.ρ.ρ.i32(ξ.left).plus(ξ.ρ.ρ.i32(ξ.right)))
⟧,
minus(x) ↦ ⟦
φ ↦ ξ.ρ.plus(ξ.x.as-i32.neg)
⟧,
div(x) ↦ ⟦
x-as-i32 ↦ ξ.x.as-i32,
bts ↦ ξ.ρ.as-i64.div(ξ.x-as-i32.as-i64).as-bytes,
left ↦ ξ.bts.slice(0, 4),
right ↦ ξ.bts.slice(4, 4),
zero ↦ Φ̇.bytes(⟦ Δ ⤍ 00-00-00-00 ⟧),
φ ↦ ξ.x-as-i32.eq(ξ.zero).if(
Φ̇.error(
Φ̇.txt.sprintf(
"Can't divide %d by i32 zero", Φ̇.tuple(Φ̇.tuple.empty, ξ.ρ.as-i64.as-number)
)
),
ξ.left.eq(ξ.zero).or(ξ.left.eq(Φ̇.bytes(⟦ Δ ⤍ FF-FF-FF-FF ⟧))).if(
ξ.ρ.ρ.i32(ξ.right), ξ.ρ.ρ.i32(ξ.left).plus(ξ.ρ.ρ.i32(ξ.right))
)
)
⟧
⟧,
λ ⤍ Package
⟧,
λ ⤍ Package
⟧
⟧}
```
## [org/eolang/i64.phi](./org/eolang/i64.phi)
```console
{⟦
org() ↦ ⟦
eolang() ↦ ⟦
i64(as-bytes) ↦ ⟦
φ ↦ ξ.as-bytes,
as-i64 ↦ ξ,
neg ↦ ξ.times(-1.as-i64),
as-i16 ↦ ξ.as-i32.as-i16,
as-i32() ↦ ⟦
left ↦ ξ.ρ.as-bytes.slice(0, 4).as-bytes,
φ ↦ ξ.left.eq(Φ̇.bytes(⟦ Δ ⤍ 00-00-00-00 ⟧)).or(
ξ.left.eq(Φ̇.bytes(⟦ Δ ⤍ FF-FF-FF-FF ⟧))
).if(
Φ̇.i32(ξ.ρ.as-bytes.slice(4, 4)),
Φ̇.error(
Φ̇.txt.sprintf(
"Can't convert i64 number %d to i32 because it's out of i32 bounds",
Φ̇.tuple(Φ̇.tuple.empty, ξ.ρ.as-number)
)
)
)
⟧,
as-number() ↦ ⟦
λ ⤍ Lorg_eolang_i64_as_number
⟧,
lt(x) ↦ ⟦
value ↦ Φ̇.dataized(ξ.x).as-bytes,
φ ↦ 0.as-i64.gt(ξ.ρ.minus(ξ.ρ.ρ.i64(ξ.value)))
⟧,
lte(x) ↦ ⟦
value ↦ Φ̇.dataized(ξ.x).as-bytes,
φ ↦ ξ.ρ.lt(ξ.value).or(ξ.ρ.eq(ξ.value))
⟧,
gt(x) ↦ ⟦
λ ⤍ Lorg_eolang_i64_gt
⟧,
gte(x) ↦ ⟦
value ↦ Φ̇.dataized(ξ.x).as-bytes,
φ ↦ ξ.ρ.gt(ξ.value).or(ξ.ρ.eq(ξ.value))
⟧,
times(x) ↦ ⟦
λ ⤍ Lorg_eolang_i64_times
⟧,
plus(x) ↦ ⟦
λ ⤍ Lorg_eolang_i64_plus
⟧,
minus(x) ↦ ⟦
value ↦ Φ̇.dataized(ξ.x).as-bytes,
φ ↦ ξ.ρ.plus(ξ.ρ.ρ.i64(ξ.value).neg)
⟧,
div(x) ↦ ⟦
λ ⤍ Lorg_eolang_i64_div
⟧
⟧,
λ ⤍ Package
⟧,
λ ⤍ Package
⟧
⟧}
```
## [org/eolang/io/dead-input.phi](./org/eolang/io/dead-input.phi)
```console
{⟦
org() ↦ ⟦
eolang() ↦ ⟦
io() ↦ ⟦
dead-input() ↦ ⟦
read(size) ↦ ⟦
φ ↦ ξ.input-block,
input-block() ↦ ⟦
φ ↦ Φ̇.bytes(⟦ Δ ⤍ -- ⟧),
read(size) ↦ ⟦
φ ↦ ξ.ρ.ρ.input-block
⟧
⟧
⟧
⟧,
λ ⤍ Package
⟧,
λ ⤍ Package
⟧,
λ ⤍ Package
⟧
⟧}
```
## [org/eolang/io/dead-output.phi](./org/eolang/io/dead-output.phi)
```console
{⟦
org() ↦ ⟦
eolang() ↦ ⟦
io() ↦ ⟦
dead-output() ↦ ⟦
write(buffer) ↦ ⟦
φ ↦ ξ.output-block,
output-block() ↦ ⟦
φ ↦ Φ̇.true,
write(buffer) ↦ ⟦
φ ↦ ξ.ρ.ρ.output-block
⟧
⟧
⟧
⟧,
λ ⤍ Package
⟧,
λ ⤍ Package
⟧,
λ ⤍ Package
⟧
⟧}
```
## [org/eolang/nan.phi](./org/eolang/nan.phi)
```console
{⟦
org() ↦ ⟦
eolang() ↦ ⟦
nan() ↦ ⟦
φ ↦ Φ̇.number(Φ̇.bytes(⟦ Δ ⤍ 7F-F8-00-00-00-00-00-00 ⟧)),
floor ↦ ξ,
neg ↦ ξ,
is-nan ↦ Φ̇.true,
is-finite ↦ Φ̇.false,
is-integer ↦ Φ̇.false,
as-i64 ↦ Φ̇.error("Can't convert NaN to i64"),
eq(x) ↦ ⟦
φ ↦ Φ̇.false
⟧,
lt(x) ↦ ⟦
φ ↦ Φ̇.false
⟧,
lte(x) ↦ ⟦
φ ↦ Φ̇.false
⟧,
gt(x) ↦ ⟦
φ ↦ Φ̇.false
⟧,
gte(x) ↦ ⟦
φ ↦ Φ̇.false
⟧,
times(x) ↦ ⟦
φ ↦ ξ.ρ
⟧,
plus(x) ↦ ⟦
φ ↦ ξ.ρ
⟧,
minus(x) ↦ ⟦
φ ↦ ξ.ρ
⟧,
div(x) ↦ ⟦
φ ↦ ξ.ρ
⟧
⟧,
λ ⤍ Package
⟧,
λ ⤍ Package
⟧
⟧}
```
## [org/eolang/negative-infinity.phi](./org/eolang/negative-infinity.phi)
```console
{⟦
org() ↦ ⟦
eolang() ↦ ⟦
negative-infinity() ↦ ⟦
φ ↦ Φ̇.number(Φ̇.bytes(⟦ Δ ⤍ FF-F0-00-00-00-00-00-00 ⟧)),
floor ↦ ξ,
neg ↦ Φ̇.positive-infinity,
is-nan ↦ Φ̇.false,
is-finite ↦ Φ̇.false,
is-integer ↦ Φ̇.false,
as-i64 ↦ Φ̇.error("Can't convert negative infinity to i64"),
eq(x) ↦ ⟦
φ ↦ ξ.ρ.as-bytes.eq(ξ.x.as-bytes)
⟧,
lt(x) ↦ ⟦
value ↦ Φ̇.dataized(ξ.x).as-bytes,
φ ↦ Φ̇.number(ξ.value).is-nan.or(ξ.ρ.eq(ξ.value)).not
⟧,
lte(x) ↦ ⟦
value ↦ Φ̇.dataized(ξ.x).as-bytes,
φ ↦ Φ̇.number(ξ.value).is-nan.not
⟧,
gt(x) ↦ ⟦
φ ↦ Φ̇.false
⟧,
gte(x) ↦ ⟦
φ ↦ ξ.ρ.eq(ξ.x)
⟧,
times(x) ↦ ⟦
value ↦ Φ̇.dataized(ξ.x).as-bytes,
num ↦ Φ̇.number(ξ.value),
φ ↦ ξ.num.is-nan.or(ξ.num.eq(0)).if(
Φ̇.nan, ξ.num.gt(0).if(ξ.ρ, Φ̇.positive-infinity)
)
⟧,
plus(x) ↦ ⟦
value ↦ Φ̇.dataized(ξ.x).as-bytes,
φ ↦ Φ̇.number(ξ.value).is-nan.or(ξ.value.eq(Φ̇.positive-infinity)).if(
Φ̇.nan, ξ.ρ
)
⟧,
minus(x) ↦ ⟦
value ↦ Φ̇.dataized(ξ.x).as-bytes,
φ ↦ Φ̇.number(ξ.value).is-nan.or(ξ.value.eq(ξ.ρ)).if(Φ̇.nan, ξ.ρ)
⟧,
div(x) ↦ ⟦
value ↦ Φ̇.dataized(ξ.x).as-bytes,
num ↦ Φ̇.number(ξ.value),
φ ↦ ξ.num.is-nan.or(ξ.num.is-finite.not).if(
Φ̇.nan,
ξ.value.eq(-0.as-bytes).or(0.gt(ξ.value)).if(
Φ̇.positive-infinity, ξ.ρ
)
)
⟧
⟧,
λ ⤍ Package
⟧,
λ ⤍ Package
⟧
⟧}
```
## [org/eolang/number.phi](./org/eolang/number.phi)
```console
{⟦
org() ↦ ⟦
eolang() ↦ ⟦
number(as-bytes) ↦ ⟦
φ ↦ ξ.as-bytes,
as-number ↦ ξ,
neg ↦ ξ.times(-1),
as-i32 ↦ ξ.as-i64.as-i32,
as-i16 ↦ ξ.as-i32.as-i16,
is-nan ↦ ξ.as-bytes.eq(Φ̇.nan.as-bytes),
as-i64() ↦ ⟦
λ ⤍ Lorg_eolang_number_as_i64
⟧,
eq(x) ↦ ⟦
x-as-bytes ↦ Φ̇.dataized(ξ.x).as-bytes,
self-as-bytes ↦ ξ.ρ.as-bytes,
pos-zero-as-bytes ↦ 0.as-bytes,
neg-zero-as-bytes ↦ -0.as-bytes,
φ ↦ ξ.ρ.is-nan.or(Φ̇.number(ξ.x-as-bytes).is-nan).if(
Φ̇.false,
ξ.x-as-bytes.eq(ξ.pos-zero-as-bytes).or(
ξ.x-as-bytes.eq(ξ.neg-zero-as-bytes)
).and(
ξ.self-as-bytes.eq(ξ.pos-zero-as-bytes).or(
ξ.self-as-bytes.eq(ξ.neg-zero-as-bytes)
)
).or(ξ.self-as-bytes.eq(ξ.x-as-bytes))
)
⟧,
lt(x) ↦ ⟦
value ↦ Φ̇.dataized(ξ.x).as-bytes,
φ ↦ 0.gt(ξ.ρ.minus(Φ̇.number(ξ.value)))
⟧,
lte(x) ↦ ⟦
value ↦ Φ̇.dataized(ξ.x).as-bytes,
φ ↦ ξ.ρ.lt(ξ.value).or(ξ.ρ.eq(ξ.value))
⟧,
gt(x) ↦ ⟦
λ ⤍ Lorg_eolang_number_gt
⟧,
gte(x) ↦ ⟦
value ↦ Φ̇.dataized(ξ.x).as-bytes,
φ ↦ ξ.ρ.gt(ξ.value).or(ξ.ρ.eq(ξ.value))
⟧,
times(x) ↦ ⟦
λ ⤍ Lorg_eolang_number_times
⟧,
plus(x) ↦ ⟦
λ ⤍ Lorg_eolang_number_plus
⟧,
minus(x) ↦ ⟦
value ↦ Φ̇.dataized(ξ.x).as-bytes,
φ ↦ ξ.ρ.plus(Φ̇.number(ξ.value).neg)
⟧,
div(x) ↦ ⟦
λ ⤍ Lorg_eolang_number_div
⟧,
floor() ↦ ⟦
λ ⤍ Lorg_eolang_number_floor
⟧,
is-integer() ↦ ⟦
φ ↦ ξ.ρ.is-finite.and(ξ.ρ.eq(ξ.ρ.floor))
⟧,
is-finite() ↦ ⟦
φ ↦ ξ.ρ.is-nan.not.and(
ξ.ρ.eq(Φ̇.positive-infinity).or(ξ.ρ.eq(Φ̇.negative-infinity)).not
)
⟧
⟧,
λ ⤍ Package
⟧,
λ ⤍ Package
⟧
⟧}
```
## [org/eolang/positive-infinity.phi](./org/eolang/positive-infinity.phi)
```console
{⟦
org() ↦ ⟦
eolang() ↦ ⟦
positive-infinity() ↦ ⟦
φ ↦ Φ̇.number(Φ̇.bytes(⟦ Δ ⤍ 7F-F0-00-00-00-00-00-00 ⟧)),
floor ↦ ξ,
neg ↦ Φ̇.negative-infinity,
is-nan ↦ Φ̇.false,
is-finite ↦ Φ̇.false,
is-integer ↦ Φ̇.false,
as-i64 ↦ Φ̇.error("Can't convert positive infinity to i64"),
eq(x) ↦ ⟦
φ ↦ ξ.ρ.as-bytes.eq(ξ.x.as-bytes)
⟧,
lt(x) ↦ ⟦
φ ↦ Φ̇.false
⟧,
lte(x) ↦ ⟦
φ ↦ ξ.ρ.eq(ξ.x)
⟧,
gt(x) ↦ ⟦
value ↦ Φ̇.dataized(ξ.x).as-bytes,
φ ↦ Φ̇.number(ξ.value).is-nan.or(ξ.ρ.eq(ξ.value)).not
⟧,
gte(x) ↦ ⟦
value ↦ Φ̇.dataized(ξ.x).as-bytes,
φ ↦ Φ̇.number(ξ.value).is-nan.not
⟧,
times(x) ↦ ⟦
value ↦ Φ̇.dataized(ξ.x).as-bytes,
num ↦ Φ̇.number(ξ.value),
φ ↦ ξ.num.is-nan.or(ξ.num.eq(0)).if(
Φ̇.nan, ξ.num.gt(0).if(ξ.ρ, Φ̇.negative-infinity)
)
⟧,
plus(x) ↦ ⟦
value ↦ Φ̇.dataized(ξ.x).as-bytes,
φ ↦ Φ̇.number(ξ.value).is-nan.or(ξ.value.eq(Φ̇.negative-infinity)).if(
Φ̇.nan, ξ.ρ
)
⟧,
minus(x) ↦ ⟦
value ↦ Φ̇.dataized(ξ.x).as-bytes,
φ ↦ Φ̇.number(ξ.value).is-nan.or(ξ.value.eq(ξ.ρ)).if(Φ̇.nan, ξ.ρ)
⟧,
div(x) ↦ ⟦
value ↦ Φ̇.dataized(ξ.x).as-bytes,
num ↦ Φ̇.number(ξ.value),
φ ↦ ξ.num.is-nan.or(ξ.num.is-finite.not).if(
Φ̇.nan,
ξ.value.eq(-0.as-bytes).or(0.gt(ξ.value)).if(
Φ̇.negative-infinity, ξ.ρ
)
)
⟧
⟧,
λ ⤍ Package
⟧,
λ ⤍ Package
⟧
⟧}
```
## [org/eolang/seq.phi](./org/eolang/seq.phi)
```console
{⟦
org() ↦ ⟦
eolang() ↦ ⟦
seq(steps) ↦ ⟦
φ ↦ ξ.steps.length.eq(0).if(Φ̇.true, ξ.loop(0)),
max-len ↦ Φ̇.dataized(ξ.steps.length.minus(1)).as-bytes,
loop(index) ↦ ⟦
φ ↦ ξ.index.lt(ξ.ρ.max-len).and(
Φ̇.dataized(ξ.ρ.steps.at(ξ.index)).as-bool.or(Φ̇.true)
).if(ξ.ρ.loop(ξ.index.plus(1)), ξ.ρ.steps.at(ξ.index))
⟧
⟧,
λ ⤍ Package
⟧,
λ ⤍ Package
⟧
⟧}
```
## [org/eolang/string.phi](./org/eolang/string.phi)
```console
{⟦
org() ↦ ⟦
eolang() ↦ ⟦
string(as-bytes) ↦ ⟦
φ ↦ ξ.as-bytes,
length() ↦ ⟦
size ↦ ξ.ρ.as-bytes.size,
pattern-one ↦ Φ̇.bytes(⟦ Δ ⤍ 80- ⟧),
pattern-two ↦ Φ̇.bytes(⟦ Δ ⤍ E0- ⟧),
pattern-three ↦ Φ̇.bytes(⟦ Δ ⤍ F0- ⟧),
pattern-four ↦ Φ̇.bytes(⟦ Δ ⤍ F8- ⟧),
result-one ↦ Φ̇.bytes(⟦ Δ ⤍ 00- ⟧),
result-two ↦ Φ̇.bytes(⟦ Δ ⤍ C0- ⟧),
result-three ↦ ξ.pattern-two,
result-four ↦ ξ.pattern-three,
φ ↦ ξ.size.eq(0).if(0, ξ.rec-length(0, 0)),
increase-length(index, char-size, len) ↦ ⟦
φ ↦ ξ.index.plus(ξ.char-size).gt(ξ.ρ.size).if(
Φ̇.error(
Φ̇.txt.sprintf(
"Expected %d byte character at %d index, but there are not enough bytes for it: %x",
Φ̇.tuple(
Φ̇.tuple(Φ̇.tuple(Φ̇.tuple.empty, ξ.char-size), ξ.index), ξ.ρ.ρ.as-bytes
)
)
),
ξ.ρ.rec-length(ξ.index.plus(ξ.char-size), ξ.len.plus(1))
)
⟧,
rec-length(index, accum) ↦ ⟦
byte ↦ ξ.ρ.ρ.as-bytes.slice(ξ.index, 1),
φ ↦ ξ.index.eq(ξ.ρ.size).if(
ξ.accum,
ξ.byte.and(ξ.ρ.pattern-one).eq(ξ.ρ.result-one).if(
ξ.ρ.increase-length(ξ.index, 1, ξ.accum),
ξ.byte.and(ξ.ρ.pattern-two).eq(ξ.ρ.result-two).if(
ξ.ρ.increase-length(ξ.index, 2, ξ.accum),
ξ.byte.and(ξ.ρ.pattern-three).eq(ξ.ρ.result-three).if(
ξ.ρ.increase-length(ξ.index, 3, ξ.accum),
ξ.byte.and(ξ.ρ.pattern-four).eq(ξ.ρ.result-four).if(
ξ.ρ.increase-length(ξ.index, 4, ξ.accum),
Φ̇.error(
Φ̇.txt.sprintf(
"Unknown byte format (%x), can't recognize character",
Φ̇.tuple(Φ̇.tuple.empty, ξ.byte)
)
)
)
)
)
)
)
⟧
⟧,
slice(start, len) ↦ ⟦
start-bytes ↦ Φ̇.dataized(ξ.start).as-bytes,
len-bytes ↦ Φ̇.dataized(ξ.len).as-bytes,
num-start ↦ Φ̇.number(ξ.start-bytes),
num-len ↦ Φ̇.number(ξ.len-bytes),
size ↦ ξ.ρ.as-bytes.size,
end ↦ ξ.num-start.plus(ξ.num-len),
pattern-one ↦ Φ̇.bytes(⟦ Δ ⤍ 80- ⟧),
pattern-two ↦ Φ̇.bytes(⟦ Δ ⤍ E0- ⟧),
pattern-three ↦ Φ̇.bytes(⟦ Δ ⤍ F0- ⟧),
pattern-four ↦ Φ̇.bytes(⟦ Δ ⤍ F8- ⟧),
result-one ↦ Φ̇.bytes(⟦ Δ ⤍ 00- ⟧),
result-two ↦ Φ̇.bytes(⟦ Δ ⤍ C0- ⟧),
result-three ↦ ξ.pattern-two,
result-four ↦ ξ.pattern-three,
bts-start ↦ Φ̇.dataized(
ξ.rec-index(
0,
0,
ξ.num-start,
Φ̇.txt.sprintf(
"Start index (%d) is out of string bounds",
Φ̇.tuple(Φ̇.tuple.empty, ξ.num-start)
)
)
).as-bytes,
bts-length ↦ ξ.rec-index(
Φ̇.number(ξ.bts-start),
0,
ξ.num-len,
Φ̇.txt.sprintf(
"Start index + length to slice (%d) is out of string bounds",
Φ̇.tuple(Φ̇.tuple.empty, ξ.num-start.plus(ξ.num-len))
)
).minus(ξ.bts-start),
φ ↦ ξ.num-start.lt(0).if(
Φ̇.error(
Φ̇.txt.sprintf(
"Start index must be >= 0, but was %d", Φ̇.tuple(Φ̇.tuple.empty, ξ.num-start)
)
),
ξ.num-len.lt(0).if(
Φ̇.error(
Φ̇.txt.sprintf(
"Length to slice must be >= 0, but was %d", Φ̇.tuple(Φ̇.tuple.empty, ξ.num-len)
)
),
ξ.num-len.eq(0).if(
"", Φ̇.string(ξ.ρ.as-bytes.slice(ξ.bts-start, ξ.bts-length))
)
)
),
increase(index, char-size, accum, result, cause) ↦ ⟦
φ ↦ ξ.index.plus(ξ.char-size).gt(ξ.ρ.size).if(
Φ̇.error(
Φ̇.txt.sprintf(
"Expected %d byte character at %d index, but there are not enough bytes for it: %x",
Φ̇.tuple(
Φ̇.tuple(Φ̇.tuple(Φ̇.tuple.empty, ξ.char-size), ξ.index), ξ.ρ.ρ.as-bytes
)
)
),
ξ.ρ.rec-index(
ξ.index.plus(ξ.char-size), ξ.accum.plus(1), ξ.result, ξ.cause
)
)
⟧,
rec-index(index, accum, result, cause) ↦ ⟦
byte ↦ ξ.ρ.ρ.as-bytes.slice(ξ.index, 1),
φ ↦ ξ.accum.eq(ξ.result).if(
ξ.index,
ξ.index.eq(ξ.ρ.size).if(
Φ̇.error(ξ.cause),
ξ.byte.and(ξ.ρ.pattern-one).eq(ξ.ρ.result-one).if(
ξ.ρ.increase(ξ.index, 1, ξ.accum, ξ.result, ξ.cause),
ξ.byte.and(ξ.ρ.pattern-two).eq(ξ.ρ.result-two).if(
ξ.ρ.increase(ξ.index, 2, ξ.accum, ξ.result, ξ.cause),
ξ.byte.and(ξ.ρ.pattern-three).eq(ξ.ρ.result-three).if(
ξ.ρ.increase(ξ.index, 3, ξ.accum, ξ.result, ξ.cause),
ξ.byte.and(ξ.ρ.pattern-four).eq(ξ.ρ.result-four).if(
ξ.ρ.increase(ξ.index, 4, ξ.accum, ξ.result, ξ.cause),
Φ̇.error(
Φ̇.txt.sprintf(
"Unknown byte format (%x), can't recognize character",
Φ̇.tuple(Φ̇.tuple.empty, ξ.byte)
)
)
)
)
)
)
)
)
⟧
⟧
⟧,
λ ⤍ Package
⟧,
λ ⤍ Package
⟧
⟧}
```
## [org/eolang/true.phi](./org/eolang/true.phi)
```console
{⟦
org() ↦ ⟦
eolang() ↦ ⟦
true() ↦ ⟦
φ ↦ Φ̇.bytes(⟦ Δ ⤍ 01- ⟧),
not ↦ Φ̇.false,
if(left, right) ↦ ⟦
φ ↦ ξ.left
⟧,
and(x) ↦ ⟦
φ ↦ Φ̇.bytes(⟦ Δ ⤍ 01- ⟧).eq(ξ.x)
⟧,
or(x) ↦ ⟦
φ ↦ ξ.ρ
⟧
⟧,
λ ⤍ Package
⟧,
λ ⤍ Package
⟧
⟧}
```
## [org/eolang/try.phi](./org/eolang/try.phi)
```console
{⟦
org() ↦ ⟦
eolang() ↦ ⟦
try(main, catch, finally) ↦ ⟦
λ ⤍ Lorg_eolang_try
⟧,
λ ⤍ Package
⟧,
λ ⤍ Package
⟧
⟧}
```
## [org/eolang/tuple.phi](./org/eolang/tuple.phi)
```console
{⟦
org() ↦ ⟦
eolang() ↦ ⟦
tuple(head, tail) ↦ ⟦
empty() ↦ ⟦
length ↦ 0,
at(i) ↦ ⟦
φ ↦ Φ̇.error("Can't get an object from the empty tuple")
⟧,
with(x) ↦ ⟦
φ ↦ ξ.ρ.ρ.ρ.tuple(ξ.ρ, ξ.x)
⟧
⟧,
length() ↦ ⟦
len ↦ Φ̇.dataized(ξ.ρ.head.length.plus(1)).as-bytes,
φ ↦ Φ̇.number(ξ.len)
⟧,
at(i) ↦ ⟦
len ↦ ξ.ρ.length,
idx ↦ Φ̇.dataized(ξ.i).as-bytes,
index ↦ Φ̇.dataized(0.gt(ξ.idx).if(ξ.len.plus(ξ.idx), ξ.idx)).as-bytes,
φ ↦ 0.gt(ξ.index).or(ξ.len.lte(ξ.index)).if(
Φ̇.error("Given index is out of tuple bounds"), ξ.at-fast(ξ.ρ, ξ.len)
),
at-fast(tup, len) ↦ ⟦
φ ↦ ξ.len.plus(-1).gt(ξ.ρ.index).if(
ξ.ρ.at-fast(ξ.tup.head, ξ.len.plus(-1)), ξ.tup.tail
)
⟧
⟧,
with(x) ↦ ⟦
φ ↦ ξ.ρ.ρ.tuple(ξ.ρ, ξ.x)
⟧
⟧,
λ ⤍ Package
⟧,
λ ⤍ Package
⟧
⟧}
```
## [org/eolang/txt/sprintf.phi](./org/eolang/txt/sprintf.phi)
```console
{⟦
org() ↦ ⟦
eolang() ↦ ⟦
txt() ↦ ⟦
sprintf(format, args) ↦ ⟦
λ ⤍ Lorg_eolang_txt_sprintf
⟧,
λ ⤍ Package
⟧,
λ ⤍ Package
⟧,
λ ⤍ Package
⟧
⟧}
```
## [org/eolang/while.phi](./org/eolang/while.phi)
```console
{⟦
org() ↦ ⟦
eolang() ↦ ⟦
while(condition, body) ↦ ⟦
φ ↦ ξ.condition(0).as-bool.if(ξ.loop(0), Φ̇.false),
loop(index) ↦ ⟦
current ↦ ξ.ρ.body(ξ.index),
φ ↦ ξ.ρ.condition(ξ.index.plus(1)).as-bool.if(
Φ̇.seq(
Φ̇.tuple(
Φ̇.tuple(Φ̇.tuple.empty, ξ.current), ξ.ρ.loop(ξ.index.plus(1))
)
),
ξ.current
)
⟧
⟧,
λ ⤍ Package
⟧,
λ ⤍ Package
⟧
⟧}
```