# Literal Values for Basic Types¶

Most of Chapel’s basic types support a corresponding literal format for specifying their values at the default bit-width. Values of other bit-widths are obtained via type conversions (casts or coercions).

## Boolean Values¶

The `bool` type supports `true` and `false` as its two literal values:

examples/users-guide/base/boolValues.chpl
```var myBool: bool;
myBool = true;
myBool = false;
```

## Integral Values¶

Literal values for `int` types are typically written as a sequence of decimal digits:

examples/users-guide/base/intValues.chpl
```var myInt: int;
myInt = 123;
```

However, they can also be expressed as binary, octal, or hexadecimal values via the `0b`/`0B`, `0o`/`0O`, and `0x`/`0X` prefixes, respectively:

```myInt = 0b1001;
myInt = 0o177;
myInt = 0x1ff;
```

where these values correspond to decimal values:

```9
127
511
```

It’s worth noting that in Chapel, there are no negative integer literal values, simply applications of the unary negation operator (`-`) to positive integer literals.

The `uint` type does not have its own literal format. However, integer literals that do not fit in an `int(64)` yet do fit within a `uint(64)` are considered to be unsigned integer values. Thus, in the following declarations, the first variable is inferred to be of type `int` while the second is inferred to be of type `uint`:

examples/users-guide/base/inferredIntValues.chpl
```var myMedInt = 2000000000;
var myLargeInt = 10000000000000000000;
```

To represent a smaller integral value as a `uint`, type conversions (casts or coercions) must be used.

## Floating Point Values¶

The `real` type supports literal values via either decimal or exponential formats:

examples/users-guide/base/floatValues.chpl
```var myReal: real;
myReal = 1.23;
myReal = 1.2e3;
```

where these literals correspond to the values:

```1.23
1200.0
```

In the decimal form, a `.` must be used to distinguish the value from an integral literal. Note that `10.` is not a valid floating point literal value in Chapel due to a syntactic ambiguity with making a method call on an integral value. For this reason, `10.0` must be used instead.

Note that in the exponential form, the base decimal value can be an integer value and/or capital `E` may be used to set off the exponent. Thus, the values in the following four assignments are all equivalent:

```myReal = 123.0e2;
myReal = 123e2;
myReal = 123.0E2;
myReal = 123E2;
```

Floating point values may also be specified using a hexadecimal format using the `0x` prefix. In such cases, `p` is used to indicate the exponent (avoiding ambiguity with the hexadecimal digit `e`) and indicates a power of 2 rather than 10:

```myReal = 0x1p-1;
myReal = 0x1.8;
```

Thus, these expressions correspond to the floating point values:

```0.5
1.5
```

Literal values for the `imag` type are identical to those for `int` and `real`, yet with an `i` suffix. Thus, the following assignments demonstrate imaginary literals:

```var myImag: imag;
myImag = 1.23i;
myImag = 1.2e3i;
myImag = 123i;
myImag = 0x0.4p-1i;
```

Note that whether using the `int` or `real` form, imaginary values are stored using a floating point representation. Thus, these expressions correspond to the values:

```1.23i
1200.0i
123.0i
0.125i
```

Note that the standalone expression `i` does not refer to the mathematical value i, but rather to a Chapel symbol (e.g., variable, procedure, etc.) named i. To get the mathematical value, use an expression like `1i` or `1.0i`.

The `complex` type does not support a native format for literal values. Instead, complex values are typically expressed by adding or subtracting `real` and `imag` values. For example:

```var myComplex: complex;
myComplex = 1.2 + 3.4i;
```

## String Literals¶

Literal `string` values can be expressed using either single or double quotes. For example, the following represent legal string values:

```var myString: string;
myString = "hello";
myString = 'hi';
```

One impact of this is that the other type of quotes can be used within a string literal without additional effort:

```myString = "he said, 'hi there!'";
```

Subsequent sections will cover strings in more detail.