```Basic type structure and notation for types

The Miranda programming language  is  strongly  typed  -  that  is  each
expression  and each variable has a type that can be deduced by a static
analysis of the program text.

Primitive types
num bool char

Values of type `num' include both integer and  floating  point  numbers,
e.g.
23     0   -17   1.26e11
They  are  stored  using  different internal representations, but can be
freely mixed in calculations, and  are  both  of  type  `num'  for  type
checking  purposes.   There  is  automatic  conversion  from  integer to
floating point when required (but not in the opposite  direction  -  use
`entier', see standard environment).  Floating point numbers are held to
double precision, integers to unbounded precision.

The values of type `bool' are the two truth values:
True    False

The values of type `char' are ascii characters, e.g.
'a'    '%'    '\t'

List types
[t] is the type of lists whose elements are of type `t'

Thus [num] is the type of lists of numbers such as [1,2,3,4,5]

[[num]] is the type of lists of lists of numbers, such as [[1,2],[3,4]]

[char] are lists of characters  -  this  is  also  the  type  of  string
constants, so e.g. ['h','e','l','l','o'] and "hello" are interchangeable
objects of this type.

Tuple types
(t1,...,tn) is the type of a tuple with elements of type `t1' to `tn'

Example - the value (1,True,"red") is of type (num,bool,[char])

The type of the empty tuple, `()', is also  written  `()'.

Notice  that  tuples  are  distinguished from lists by being enclosed in

There is no concept of a 1-tuple, in Miranda, so the use of  parentheses
to  enclose  subexpressions,  as  in say a*(b+c), does not conflict with
their use for tuple formation.

Function types
t1->t2 is the type of a function with argument  type  `t1'  and  result
type `t2'

The '->' is right associative, so e.g.  `num->num->num' is the type of a
curried function of two numeric arguments.

In addition to the built-in types described above,  user  defined  types
may  be  introduced - these are of three kinds, synonym types, algebraic
types and abstract types - see separate manual entry for each.

Implicit typing
In Miranda the types of identifiers do NOT normally need to be declared
explicitly  - the compiler is able to infer the type of identifiers from
their defining equations.  For example if you write
plural x = x ++ "s"

the compiler will DEDUCE that `plural' is of type [char]->[char].  It is
however permitted to include explicit type declarations in the script if
desired, e.g.  you could write (anywhere in the same script)
plural :: [char]->[char]

and the compiler will check  this  for  consistency  with  the  defining
equation  (the symbol `::' means `is of type').  More generally the type
declared may be an instance (see below)  of  the  type  implied  by  the
definition  -  in this case the effect of the declaration is to restrict
the type of the identifier to be less general than  it  would  otherwise
have been.

Note  that  only  top-level  identifiers  may  be  the  subject  of type
declarations, and that the type of an identifier may be declared at most
once in a given script.

Polymorphism
The  final  feature  of  the type system is that it permits polymorphic
types.  There is an alphabet of generic type variables, written
*    **    ***    etc.

each of which stands for an arbitrary type.  We give a simple example  -
the identity function, which may be defined
id x = x

is attributed the type `*->*'.  This means that `id' has  many  types  -
`num->num', `char->char', `[[bool]]->[[bool]]' and so on - each of these
is an instance of its most general type, `*->*'.

Another simple example  of  polymorphism  is  the  function  `map'  (see
standard  environment)  which  applies  a function to every element of a
list.  For example `map integer [1,1.5,2]'  is  [True,False,True].   The
type of map is
map :: (*->**) -> [*] -> [**]

The most polymorphic possible object is `undef',  the  identifier  which
stands  for  the  undefined,  or  error  value  (undef is defined in the
standard environment).  Since every type has  an  undefined  value,  the
correct type specification for undef is
undef :: *

Many of the functions in the standard environment have polymorphic types
- the text of the standard environment (see separate  manual  entry)  is
therefore a useful source of examples.

```