# Basic Types

## Bool – logical values

Bool is a logical data type that can be either `True` or `False`.

## Int – fixed-precision integers

Int can contain integers, both negative and positive whole numbers (e.g. `-50`, `50`) up to a certain size which is limited by a fixed amount of memory, hence the term fixed-precision. GHC can hold values in the range of `(-2^63)` to `(2^63 - 1)` for Int types - going outside those ranges will yield unexpected results.

## Integer – arbitrary-precision integers

Integer is the same as Int except it does not have a limit to the values it can hold. Performance-wise, it is better to use Int if we know our values will not go out of range, as most computers have built-in hardware for dealing with fixed-precision integers.

## Float – single-precision floating-point numbers

Float can contain decimal numbers (e.g. `-1.5`, `6.23`, `50.0`) up to a certain precision which is limited by a fixed amount of memory. The term floating-point comes from this memory limitation, which limits the number of digits (precision) that can come after the decimal point based on the size of the number.

## Double – double-precision floating-point numbers

Double is the same type as float, containing decimal numbers but with double the memory assigned for storage for increased precision.

## Char – single character

Char is a type for characters – it can hold any Unicode character including control characters such as `'\n'` (a new line character) or `'\t'` (tab stop character). Char type values must be enclosed in single quotes `''`.

## String – strings of characters

Strings simply hold a string of characters – they are in fact a type `[Char]` (a list of Char type values) in Haskell. Strings must be enclosed in double-quotes `""`, e.g. `"Haskell is great"`.

Last updated