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 mutable. So you don't need to use String Builder to compensate for the inefficiency of immutable strings as in some other languages, string concatenations are less of a performance concern.

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.

It also supports the <, <=, >, and >= operators for comparing strings. But it is not case-sensitive, case-insensitive or like that. This operators just compares 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.`

Nil ​

Zero value for pointers and function data typed defines.

nil

any ​

It can be hold any data type and nil. Only supports equals (==) and not equals (!=) operators.

x == nil: true if any is nil, not checks whether data is nil
x == y: true if x and y is nil
x == y: true if x and y has same data type and returns true of equals operator of data type for two value

Supports casting to any type. You can get type-safe value of any with casting. For example:

let my_any: any = 10
let x = (int)(my_any)

any type protects itself against mutability if necessary. For example, you have slice value holds by any-typed variable. And your variable is immutable. So, if you cast your value to slice for assign to mutable variable, you will get error. Because of slice is mutable type, so it's breaking immutability.