primitive types

docs/src/SUMMARY.md

@@ -2,13 +2,17 @@
 
 [Introduction](./README.md)
 
-- [Getting Started]()
+- [Getting Started](./starting/index.md)
   - [Installation](./starting/installation.md)
   - [Hello, world!](./starting/hello-world.md)
 
 - [Vine Language Features]()
   - [The Usual](./features/usual.md)
-  - [Types]()
+  - [Types](./features/types/index.md)
+    - [Primitive Types](./features/types/primitives.md)
+    - [Standard Types]()
+    - [Structs]()
+    - [Enums]()
   - [Methods]()
   - [IO](./features/io.md)
   - [Patterns](./features/patterns.md)
@@ -30,9 +34,3 @@
   - [Ivy's Interaction System](./ivy/interaction-system.md)
   - [Statistics](./ivy/statistics.md)
   - [Extrinsics]()
-
----
-
-[Notes](./notes.md)
-
-[Scratch](./scratch.md)

docs/src/features/types/enums.md

@@ -0,0 +1 @@
+# Enums

docs/src/features/types/index.md

@@ -0,0 +1,12 @@
+# Types
+
+Vine is statically typed. Every expression has a type, like `Bool` or
+`List[N32]`. Type parameters are written in square brackets.
+
+Types fall in to several categories:
+
+- [primitive types](./primitives.md) are fundamental types defined by the
+  compiler
+- [standard types](./primitives.md) are commonly-used types defined by the
+  standard library
+- [structs](./structs.md) and [enums](./enums.md) are user-defined types

docs/src/features/types/primitives.md

@@ -0,0 +1,56 @@
+# Primitive Types
+
+## `N32`
+
+The type `N32` describes natural numbers[^nats], represented with 32 bits of
+precision.
+
+`N32` values can be written as literals in decimal (`46`), hex (`0x2e`), or
+binary (`0b101110`). Digits can be separated with underscores (`1_000_000`).
+
+`N32`s support the usual arithmetic and bitwise operators (`4 * 11 + 2`,
+`5 << 3 | 6`)
+
+## `F32`
+
+The type `F32` describes 32-bit floating-point numbers (following IEEE 754).
+
+`F32` values can be written as literals (`4.6e1`). The decimal point is
+required.
+
+`F32`s support the usual arithmetic operators (`3.6 * 12.3 + 1.72`).
+
+## `Char`
+
+The type `Char` describes Unicode code points. `Char`s are primarily used within
+`List`s to form `String`s.
+
+`Char` values can be written as literals using single quotes (`'.'`).
+
+`Char`s support adding an `N32`, resulting in another `Char` (`'a' + 4`), as
+well as subtracting another `Char`, resulting in an `N32` (`'G' - 'A'`).
+
+## `Bool`
+
+The type `Bool` describes booleans.
+
+The two `Bool` values can be written as literals (`true`, `false`).
+
+`Bool`s support the usual short-circuiting logical operators (`&&`, `||`, `!`)
+and non-short-circuiting ("bitwise") operators (`&`, `|`, `^`).
+
+Expressions that evaluate to booleans are called [conditions](./conditions.md).
+
+## `IO`
+
+`IO` is a special primitive type used to interact with the outside world. Values
+of this type cannot be explicitly constructed; instead, an `IO` handle is passed
+in to `main` at the start of the program. See the section on [IO](../io.md) for
+more detail.
+
+---
+
+[^nats]: Natural numbers are non-negative integers. In other programming
+    languages, they are often referred to as "unsigned integers". Seeing as
+    positive integers do have a sign (namely, a positive sign), the only truly
+    unsigned integer is zero.

docs/src/features/types/standard.md

@@ -0,0 +1 @@
+# Standard

docs/src/features/types/structs.md

@@ -0,0 +1 @@
+# Structs

docs/src/starting/index.md

@@ -1 +1,5 @@
 # Getting Started
+
+## [Installation](./installation.md)
+
+## [Hello, world!](./hello-world.md)