# gizlang:inspect

a value as a person reads it, as Node's util.inspect writes it: `{ a: 1, b: "x" }`, `[ 1, 2 ]`, `undefined`. Each type has `writeShown(self, out: mut bytes)`: the compiler writes a record's and a union's (checker derivedMethod), as it writes their writeJson. A test's failure shows its values with it (gizlang:test).

```gizlang
import * as Inspect from "gizlang:inspect";
```

## Functions

### `inspect`

```gizlang
function inspect<T>(value: T): string
```

VALUE on one line: `{ a: 1, b: [ 2, 3 ] }`.

### `lines`

```gizlang
function lines(text: string): string
```

The one-line TEXT of inspect laid out one item a line, each indented by its depth and ending with a comma, as a diff
compares two values:

    {
      a: 1,
      b: [
        2,
      ],
    }

Effects: fail.

### `open`

```gizlang
function open(out: mut bytes): void
```

`{`, before the fields.

Effects: fail.

### `close`

```gizlang
function close(out: mut bytes): void
```

`}` after the fields: ` }`, or `{}` with none.

Effects: fail.

### `fieldName`

```gizlang
function fieldName(out: mut bytes, name: string): void
```

`NAME: `, after `, ` unless it is the first field.

Effects: fail.

### `field`

```gizlang
function field<T>(out: mut bytes, name: string, value: T): void
```

The field NAME of VALUE.

### `optionalField`

```gizlang
function optionalField<T>(out: mut bytes, name: string, value: Option<T>): void
```

The field NAME of VALUE, `undefined` when it is: Node shows it.

### `kindField`

```gizlang
function kindField(out: mut bytes, name: string): void
```

A union case's `kind: "NAME"`.

Effects: fail.

### `writeValue`

```gizlang
function writeValue<T>(out: mut bytes, value: T): void
```

VALUE as itself: the case of an untagged union.

## Methods

### `i64.writeShown`

```gizlang
function i64.writeShown(self: i64, out: mut bytes): void
```

Effects: fail.

### `i32.writeShown`

```gizlang
function i32.writeShown(self: i32, out: mut bytes): void
```

Effects: fail.

### `i16.writeShown`

```gizlang
function i16.writeShown(self: i16, out: mut bytes): void
```

Effects: fail.

### `i8.writeShown`

```gizlang
function i8.writeShown(self: i8, out: mut bytes): void
```

Effects: fail.

### `u64.writeShown`

```gizlang
function u64.writeShown(self: u64, out: mut bytes): void
```

Effects: fail.

### `u32.writeShown`

```gizlang
function u32.writeShown(self: u32, out: mut bytes): void
```

Effects: fail.

### `u16.writeShown`

```gizlang
function u16.writeShown(self: u16, out: mut bytes): void
```

Effects: fail.

### `u8.writeShown`

```gizlang
function u8.writeShown(self: u8, out: mut bytes): void
```

Effects: fail.

### `f64.writeShown`

```gizlang
function f64.writeShown(self: f64, out: mut bytes): void
```

A number as JavaScript writes it: `1`, `0.1`, `NaN`, `-Infinity`.

Effects: fail.

### `f32.writeShown`

```gizlang
function f32.writeShown(self: f32, out: mut bytes): void
```

Effects: fail.

### `bool.writeShown`

```gizlang
function bool.writeShown(self: bool, out: mut bytes): void
```

Effects: fail.

### `string.writeShown`

```gizlang
function string.writeShown(self: string, out: mut bytes): void
```

A string quoted and escaped: `"a\nb"`.

Effects: fail.

### `bytes.writeShown`

```gizlang
function bytes.writeShown(self: bytes, out: mut bytes): void
```

Bytes as Node shows a Uint8Array: `Uint8Array(2) [ 1, 2 ]`.

Effects: fail.

### `Vec.writeShown`

```gizlang
function Vec.writeShown<T>(self: Vec<T>, out: mut bytes): void
```

### `Ref.writeShown`

```gizlang
function Ref.writeShown<T>(self: Ref<T>, out: mut bytes): void
```

A Ref (an instance of a class too) as its value, as vitest shows an object.

### `Option.writeShown`

```gizlang
function Option.writeShown<T>(self: Option<T>, out: mut bytes): void
```

### `Map.writeShown`

```gizlang
function Map.writeShown<K extends Key, V>(self: Map<K, V>, out: mut bytes): void
```

`Map(2) { "a" => 1, "b" => 2 }`.

### `Set.writeShown`

```gizlang
function Set.writeShown<T extends Key>(self: Set<T>, out: mut bytes): void
```

`Set(2) { 1, 2 }`.