Data Types ​

Jule is designed strongly typed. Therefore, the data-types of all values must be specified during compilation. In this section we will look at the builtin types offered by the compiler.

Primitive Types ​

Integer Literals ​

Decimal ​

12345

Binary ​

0b0001010101

Octal ​

0455

0o455

Hexadecimal ​

0xDFF90

Floating-Point Literals ​

3.14

32.60

032.60

3.

.3

0.3

1E2

.12345E+6

1.e+0

0x1p-2

0x2.p10

0x1.Fp+0

0X.8p-0

0x1fffp-16

Underscore & Numeric Literals ​

You can use underscore to separate digits. This might be helpful for big numbers.
There are some conditions:

• Literal cannot starts with underscore
• Precision of floating-point literals are cannot starts with underscore
• Format specifier of floating-point literals are cannot separated with underscore from following digits

Example to underscored literals:

10_000_000

0.5_000e+100

.12_345E+6

0b1100_1100_0110_1010

Byte and Rune Literals ​

A byte or rune literal is represented by a single character between single quotes. Since it is typically a string element, it supports the same escape sequences. Literal can be evaluated in two ways, these are byte literal and rune literal. If your character is small enough to be a byte (0 <= b <= 255) it is treated as a byte, otherwise it is treated as a rune.

For example:

'a' // byte

'ç' // rune

String ​

Jule strings are UTF-8 encoded byte-by-byte, and support Unicode. They are also immutable, means you can't modify them. For literals, strings will not heap allocated. Strings only performs heap allocation for runtime concats and other runtime stuffs. If string performs a heap allocation, it will use smart pointer to track allocation.

Strings support the + operator for concatenation, It's that easy to concatenate two strings. Additionally, using the == and != operators, you can easily determine whether two strings are the same or not.

In most cases, any concatenation will result as heap allocation which is might be expensive. For higly-repeated concatenations use string builder utilities instead.

It also supports the <, <=, >, and >= operators for comparing strings. But it is not case-sensitive, case-insensitive or like that. This operators just compares bytes/runes of strings.

String Literals ​

"String literal of Jule."

String literals have a escape sequences.

Raw String Literals ​

Raw strings do not contain escape sequences and are not required to be defined in a single line. They are represents with `.

`Raw String literal of Jule.`

`Raw String literal of Jule
with
new
    lines.`

Boolean ​

Jule defines two constant values for booleans.

For logical true:

true

For logical false:

false

Maps ​

See the Maps section for more information.

any ​

See the Any section for more information.

Nil ​

Zero value for pointers and function data typed defines.

nil