Fuzion • Tutorial • Integer Types

Integer Types

Fuzion knows signed and unsigned integer types in different sizes: u8, u16, u32, u64, u128 for unsigned values, i8, i16, i32, i64, i128 for signed values. Furthermore, int and uint can represent signed and unsigned integers of arbitrary size.

32-bit integers

Here is a small example calculating fibonacci numbers using 32-bit integers:

fib(n i32) =>
{
  for a u32 := 0, b
      b u32 := 1, next
      next := a + b
      i in 1..n
  else
    {
      a
    }
}

for i in 0.. do
  {
    say("fib($i) = " + fib(i))
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
fib(n i32) =>
{
  for a u32 := 0, b
      b u32 := 1, next
      next := a + b
      i in 1..n
  else
    {
      a
    }
}
for i in 0.. do
  {
    say("fib($i) = " + fib(i))
  }
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Due to the range limitations of type u32, this produces an error for n > 45.

64-bit integers

The possible range of values can be doubled using 64-bit integers:

fib(n i32) =>
{
  for a u64 := 0, b
      b u64 := 1, next
      next := a + b
      i in 1..n
  else
    {
      a
    }
}

for i in 0.. do
  {
    say("fib($i) = " + fib(i))
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
fib(n i32) =>
{
  for a u64 := 0, b
      b u64 := 1, next
      next := a + b
      i in 1..n
  else
    {
      a
    }
}
for i in 0.. do
  {
    say("fib($i) = " + fib(i))
  }
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Here, this produces an error for n > 91.

128-bit integers

Again, 128-bit integers double the number of fibonacci numbers we can generate, but this example only prints every 50th:

fib(n i32) =>
{
  for a u128 := 0.as_u128, b
      b u128 := 1.as_u128, next
      next := a + b
      i in 1..n
  else
    {
      a
    }
}

for i in 0.. : 50 do
  {
    say("fib($i) = " + fib(i))
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
fib(n i32) =>
{
  for a u128 := 0.as_u128, b
      b u128 := 1.as_u128, next
      next := a + b
      i in 1..n
  else
    {
      a
    }
}
for i in 0.. : 50 do
  {
    say("fib($i) = " + fib(i))
  }
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Large integers

Type int provides integers of an arbitrary size, but at the cost of reduced efficiency and higher memory demand:

fib(n int) =>
{
  for a := int 0, b
      b := int 1, next
      next := a + b
      i in (int 1)..n
  else
    {
      a
    }
}

i := int 200
say("fib $i = {fib(i)}")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
fib(n int) =>
{
  for a := int 0, b
      b := int 1, next
      next := a + b
      i in (int 1)..n
  else
    {
      a
    }
}
i := int 200
say("fib $i = {fib(i)}")
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Integer as generic type

The abstract type integer can be used to build a generic function that works with integers of arbitrary sizes. The compiler will specialize this code for the actual type that it is used with:

# fuzion.debugLevel=0   // allow wrap-around

fib(n T : integer) =>
{
  for a := T.zero, b
      b := T.one, next
      next := a + b
      // i in T.one..n    -- NYI: no .. in integer yet
      i := T.one, i + T.one
  while i <= n
    {
    }
  else
    {
      a
    }
}

show(n i32) unit =>
{
  say("fib u32($n) = {fib(n.as_u32 )}, " +
      "fib u64($n) = {fib(n.as_u64 )}, " +
      "fib u128($n) = {fib(n.as_u128)}, " +
      "fib int($n) = {fib(n.as_int )}. " +
      ""
      )
}

show(2)
show(3)
show(4)
show(48)
show(49)
show(50)
show(93)
show(94)
show(186)
show(187)

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
# fuzion.debugLevel=0   // allow wrap-around
fib(n T : integer) =>
{
  for a := T.zero, b
      b := T.one, next
      next := a + b
      // i in T.one..n    -- NYI: no .. in integer yet
      i := T.one, i + T.one
  while i <= n
    {
    }
  else
    {
      a
    }
}
show(n i32) unit =>
{
  say("fib u32($n) = {fib(n.as_u32 )}, " +
      "fib u64($n) = {fib(n.as_u64 )}, " +
      "fib u128($n) = {fib(n.as_u128)}, " +
      "fib int($n) = {fib(n.as_int )}. " +
      ""
      )
}
show(2)
show(3)
show(4)
show(48)
show(49)
show(50)
show(93)
show(94)
show(186)
show(187)
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

last changed: 2024-06-28

next: Floating-Point Types