---

By default, there can be only the functions of the Prelude module used, that is what the displayed Prelude> text says in the prompt after the interpreter has been launched.

With the :s +t command, the interpreter will display the type for each evaluated expression. The :s +t expression is an abbreviation of “set type on”.

---

The bounds given above apply to GHC on 32-bit processors.

When the Double type is employed, it implies rounding errors:

Test>

0.10000000000000009 :: Double

Other number types:

Ratio Integer	(= Rational) Quotient of two Integer values
Ratio Int	Quotient of two Int values
Fixed E6	(= Micro) Fraction with 6 decimals
Fixed E12	(= Pico) Fraction with 12 decimals
Complex Float	Complex number (Pair of Floats)
Complex Double	Complex number (Pair of Doubles)

(+) :: Int      -> Int      -> Int
(+) :: Integer  -> Integer  -> Integer
(+) :: Rational -> Rational -> Rational
(+) :: Double   -> Double   -> Double

---

Num is a type class.

There is a Num type class instance for the Int type.

Lowercase names in the types are type variables. Types containing type variables may be specialized, that is the type variables may be replaced with other types by certain constraints.

Type of an n-parameter function:

t₁ -> t₂ -> … -> t_N -> t_N+1.

• t~1, t₂, …, t_N are types of the parameters.
• t_N+1 is type of the result.

---

There are three types of raising to a power depending on whether the power is a non-negative integer, integer, or floating-point value.

---

An expression is correct by type if the specialized type of all function arguments matches the types required by the respective functions.

During specialization, the type variables are replaced by an arbitrary type.

For example, specializations of a -> a: Char -> Char, [b] -> [b], …

There is a sub-class relation between type classes:

That offers an opportunity for a different kind of type specialization. For example, the Fractional a property implies Num a.
Hence the Num may be replaced by Fractional during the specialization.

That is, the specialized type of

Test>

is

Test>

---

Interpretation of precedence is as usual: 1 + 2 * 4 written with parentheses is 1 + (2 * 4).

The associativity is only relevant if there operators on the same level of precedence are next to each other. Hence 1/2/4 should be written as (1/2)/4 with parentheses added, while 3^3^3 should be written as 3^(3^3).

<interactive>:1:1: error:
    Precedence parsing error
        cannot mix ‘+’ [infixl 6] and prefix `-' [infixl 6] in the same infix expression

---

Negation can be distinguished from subtraction as follows. If the - symbol follows an expression then it refers to a subtraction otherwise that is a negation. There is no negative number literal, e.g. the -13 expression is the negation of 13 thus negative numbers must be protected by parentheses.

---

The function and the operator are syntactical categories. Function names consist of letters and they start with a lowercase letter, while operators consist of graphical characters.

Graphical characters are the !?.#$%@&*+-~^/|\<=> ASCII characters and the symbols from non-ASCII characters.

It is allowed to use parentheses as arbitrary expression may be put in parentheses if that does not change the order to evaluation, e.g. sin(pi).

Note that sin cos 1 is an invalid expression, because it says that sin is two-parameter function that is passed the cos and 1 arguments.

---

Function names may be used in infix notation by putting them in `` symbols. Operator names may be used in prefix notation by putting in parentheses.

The infix div and mod functions have the same precedence as the * and / operators.