# Types

## Axioms

The syntax described only applies within this document.

- All defined things below are values, all values have a type, all types have a
  definition which is itself a value.

- A type definition is displayed as a value wrapped in angle brackets, like
  `<int>`.

- A type definition with no value, `<>`, is the empty type

- A type definition may have more than one type, as in `<int,string>`, to
  indicate that a value with that type is actually a combination of each
  type in sequence (i.e. a tuple)

    - Tuples can be wrapped in parenthesis to indicate sub-groupings. I.e.
      `<string,(int,int)>` is a tuple of 2 sub-types, the first being a
      `<string>` and the second being a tuple of 2 `<ints>`.

- Any type definition can be used in place of `<any>`.

- `1` is an example of a value of type `<int>`.

- The type of value `<int>` is `<typedef,int>`.
- 
- Any `lowercaseAlphaNumeric` string is an atom value, of type `<atom>`.

- `V<someType>` is a placeholder for a value of type `<someType>`. It is used
  when matching a pattern.

- `(declareType, V<any>)` is understood to declare a type definition. A type
  definition can then be used as `<typedef>`.

- `(declareFunction, V<atom>, <any>, <any>)` is a tuple understood to declare a
  function, named after the atom, where the type definitions of the input and
  output are also given.

## Type declarations.

```
(declareType, atom)
(declareType, bool)
(declareType, int)

// general purpose functions for working with all types.
(declareFunction, concat, <any, any>,  <any>)
(declareFunction, slice, <any,int,int>, <any>)
(declareFunction, len, <any>, <int>)
(declareFunction, eq, <any,any>, <bool>)

// functions for working with integers
(declareFunction, plus, <int,int>, <int>)
(declareFunction, mult, <int,int>, <int>)
(declareFunction, minus, <int,int>, <int>)
// these two may return false if divide by zero
(declareFunction, div, <int,int>, <int,bool>)
(declareFunction, mod, <int,int>, <int,bool>)

// a general iterator
(declareType, (iter,any))
(declareFunction, next, <iter,any>, <(iter,any),any,bool>)

// TODO structurally, what's the difference between `<int,int>` and
// `<iter,any>`? the latter's first element isn't a valid typedef on its own,
// but other than that there seems to be no difference?

//(declareCompound, graph, T)
//(declareFunction, addEdge, (tup,(graph,T),T,T), (tup,graph,T))
//(declareFunction, rmEdge, (tup,(graph,T),T,T), (tup,graph,T))
//// the order of elements returned by parents/children is the same as the order
//// the edges between the nodes were added.
//(declareFunction, parents, (tup,(graph,T),T), (tup,(iter,T)))
//(declareFunction, children, (tup,(graph,T),T), (tup,(iter,T)))
//(declareFunction, has, (tup,(graph,T),T), bool)
//```