# : col · Cells

The `:` ("col") expressions are used to produce cells, which are pairs of values. E.g., `:-(p q)` produces the cell `[p q]`. All `:` runes reduce to `:-`.

## :- "colhep" <a href="#colhep" id="colhep"></a>

Construct a cell (2-tuple).

#### Syntax

Two arguments, fixed.

{% tabs %}
{% tab title="Tall form" %}

```hoon
:-  p
q
```

{% endtab %}

{% tab title="Wide form" %}

```hoon
:-(p q)
```

{% endtab %}

{% tab title="Irregular #1" %}

```hoon
[p q]
```

{% endtab %}

{% tab title="Irregular #2" %}

```hoon
p^q
```

{% endtab %}
{% endtabs %}

#### AST

```hoon
[%clhp p=hoon q=hoon]
```

#### Produces

The cell of `.p` and `.q`.

#### Discussion

Hoon expressions actually use the same "autocons" pattern as Nock formulas. If you're assembling expressions (which usually only the compiler does), `[a b]` is the same as `:-(a b)`.

#### Examples

```
> :-(1 2)
[1 2]

~zod:dojo> 1^2
[1 2]
```

***

## :\_ "colcab" <a href="#colcab" id="colcab"></a>

Construct a cell, inverted.

#### Syntax

Two arguments, fixed.

{% tabs %}
{% tab title="Tall form" %}

```hoon
:_  p
q
```

{% endtab %}

{% tab title="Wide form" %}

```hoon
:_(p q)
```

{% endtab %}

{% tab title="Irregular form" %}
None
{% endtab %}
{% endtabs %}

#### AST

```hoon
[%clcb p=hoon q=hoon]
```

#### Expands to

```hoon
:-(q p)
```

#### Examples

```
> :_(1 2)
[2 1]
```

***

## :+ "collus" <a href="#collus" id="collus"></a>

Construct a triple (3-tuple).

#### Syntax

Three arguments, fixed.

{% tabs %}
{% tab title="Tall form" %}

```hoon
:+  p
  q
r
```

{% endtab %}

{% tab title="Wide form" %}

```hoon
:+(p q r)
```

{% endtab %}

{% tab title="Irregular form" %}

```hoon
  [p q r]
```

{% endtab %}
{% endtabs %}

#### AST

```hoon
[%clls p=hoon q=hoon r=hoon]
```

#### Expands to:

```hoon
:-(p :-(q r))
```

#### Examples

```
> :+  1
    2
  3
[1 2 3]

> :+(%a ~ 'b')
[%a ~ 'b']
```

***

## :^ "colket" <a href="#colket" id="colket"></a>

Construct a quadruple (4-tuple).

#### Syntax

Four arguments, fixed.

{% tabs %}
{% tab title="Tall form" %}

```hoon
:^    p
    q
  r
s
```

{% endtab %}

{% tab title="Wide form" %}

```hoon
:^(p q r s)
```

{% endtab %}

{% tab title="Irregular form" %}

```hoon
  [p q r s]
```

{% endtab %}
{% endtabs %}

#### AST

```hoon
[%clkt p=hoon q=hoon r=hoon s=hoon]
```

#### Expands to

```hoon
:-(p :-(q :-(r s)))
```

#### Examples

```
> :^(1 2 3 4)
[1 2 3 4]

> :^    5
      6
    7
  8
[5 6 7 8]
```

***

## :\* "coltar" <a href="#coltar" id="coltar"></a>

Construct an n-tuple.

#### Syntax

Variable number of arguments.

{% tabs %}
{% tab title="Tall form" %}

```hoon
:*  p1
    p2
    p3
    pn
==
```

{% endtab %}

{% tab title="Wide form" %}

```hoon
:*(p1 p2 p3 pn)
```

{% endtab %}

{% tab title="Irregular form" %}

```hoon
[p1 p2 p3 pn]
```

{% endtab %}
{% endtabs %}

#### AST

```hoon
[%cltr p=(list hoon)]
```

#### Expands to

**Pseudocode**: *a*, *b*, *c*, ... as elements of `.p`:

```hoon
:-(a :-(b :-(c :-(... z)))))
```

#### Desugaring

```hoon
|-
?~  p
  !!
?~  t.p
  i.p
:-  i.p
$(p t.p)
```

#### Examples

```
> :*(5 3 4 1 4 9 0 ~ 'a')
[5 3 4 1 4 9 0 ~ 'a']

> [5 3 4 1 4 9 0 ~ 'a']
[5 3 4 1 4 9 0 ~ 'a']

> :*  5
      3
      4
      1
      4
      9
      0
      ~
      'a'
  ==
[5 3 4 1 4 9 0 ~ 'a']
```

***

## :\~ "colsig" <a href="#colsig" id="colsig"></a>

Construct a null-terminated list.

#### Syntax

Variable number of arguments.

{% tabs %}
{% tab title="Tall form" %}

```hoon
:~  p1
    p2
    p3
    pn
==
```

{% endtab %}

{% tab title="Wide form" %}

```hoon
:~(p1 p2 p3 pn)
```

{% endtab %}

{% tab title="Irregular form" %}

```hoon
~[p1 p2 p3 pn]
```

{% endtab %}
{% endtabs %}

#### AST

```hoon
[%clsg p=(list hoon)]
```

#### Expands to

**Pseudocode**: *a*, *b*, *c*, ... as elements of `.p`:

```hoon
:-(a :-(b :-(c :-(... :-(z ~)))))
```

#### Desugaring

```hoon
|-
?~  p
  ~
:-  i.p
$(p t.p)
```

#### Discussion

Note that this does not produce a `+list` type, it just produces a null-terminated n-tuple. To make it a proper `+list` it must be cast or molded.

#### Examples

```
> :~(5 3 4 2 1)
[5 3 4 2 1 ~]

> ~[5 3 4 2 1]
[5 3 4 2 1 ~]

> :~  5
      3
      4
      2
      1
  ==
[5 3 4 2 1 ~]
```

***

## :: "colcol" <a href="#colcol" id="colcol"></a>

Code comment.

#### Syntax

```hoon
::  any text you like!
```

#### Examples

```hoon
::
::  this is commented code
::
|=  a=@         ::  a gate
(add 2 a)       ::  that adds 2
                ::  to the input
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.urbit.org/hoon/rune/col.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.