argamak/space

Types

D0

A type without dimensions.

pub type D0 {
  D0
}

Constructors

```
D0
```

D1

</>

A type with one dimension.

pub type D1 {
  D1
}

Constructors

```
D1
```

D2

</>

A type with two dimensions.

pub type D2 {
  D2
}

Constructors

```
D2
```

D3

</>

A type with three dimensions.

pub type D3 {
  D3
}

Constructors

```
D3
```

D4

</>

A type with four dimensions.

pub type D4 {
  D4
}

Constructors

```
D4
```

D5

</>

A type with five dimensions.

pub type D5 {
  D5
}

Constructors

```
D5
```

D6

</>

A type with six dimensions.

pub type D6 {
  D6
}

Constructors

```
D6
```

Space

</>

An n-dimensional Space with axis–shape tuple elements, one per dimension.

pub opaque type Space(dn, axis)

SpaceError

</>

An error returned when attempting to create an invalid Space.

pub type SpaceError {
  SpaceError(error: String, element: String)
}

Constructors

SpaceError(error: String, element: String)

SpaceErrors

</>

A SpaceError list.

pub type SpaceErrors =
  List(SpaceError)

Functions

axes

</>

pub fn axes(of space: Space(a, b)) -> List(b)

Returns the axes of a given Space.

Examples

> assert Ok(space) = d0()
> axes(space)
[]

> type Axis { A B C }
> assert Ok(space) = d1(#(A, -1))
> axes(space)
[A]

> assert Ok(space) = d3(#(A, 2), #(B, 2), #(C, -1))
> axes(space)
[A, B, C]

d0

</>

pub fn d0() -> Result(Space(D0, a), List(SpaceError))

Results in a dimensionless Space.

Examples

> assert Ok(space) = d0()
> elements(space)
[]

d1

</>

pub fn d1(a: #(a, Int)) -> Result(Space(D1, a), List(SpaceError))

Results in a 1-dimensional Space on success, or SpaceErrors on failure.

Examples

> type Axis { A }
> assert Ok(space) = d1(#(A, -1))
> elements(space)
[#(A, -1)]

d2

</>

pub fn d2(a: #(a, Int), b: #(a, Int)) -> Result(
  Space(D2, a),
  List(SpaceError),
)

Results in a 2-dimensional Space on success, or SpaceErrors on failure.

Examples

> type Axis { A B }
> assert Ok(space) = d2(#(A, 2), #(B, 2))
> elements(space)
[#(A, 2), #(B, 2)]

d3

</>

pub fn d3(a: #(a, Int), b: #(a, Int), c: #(a, Int)) -> Result(
  Space(D3, a),
  List(SpaceError),
)

Results in a 3-dimensional Space on success, or SpaceErrors on failure.

Examples

> type Axis { A B C }
> assert Ok(space) = d3(#(A, 2), #(B, 2), #(C, -1))
> elements(space)
[#(A, 2), #(B, 2), #(C, -1)]

d4

</>

pub fn d4(a: #(a, Int), b: #(a, Int), c: #(a, Int), d: #(a, Int)) -> Result(
  Space(D4, a),
  List(SpaceError),
)

Results in a 4-dimensional Space on success, or SpaceErrors on failure.

Examples

> type Axis { A B C D }
> assert Ok(space) = d4(#(A, 2), #(B, 2), #(C, -1), #(D, 1))
> elements(space)
[#(A, 2), #(B, 2), #(C, -1), #(D, 1)]

d5

</>

pub fn d5(a: #(a, Int), b: #(a, Int), c: #(a, Int), d: #(a, Int), e: #(
    a,
    Int,
  )) -> Result(Space(D5, a), List(SpaceError))

Results in a 5-dimensional Space on success, or SpaceErrors on failure.

Examples

> type Axis { A B C D E }
> assert Ok(space) = d5(#(A, 5), #(B, 4), #(C, 3), #(D, 2), #(E, 1))
> elements(space)
[#(A, 5), #(B, 4), #(C, 3), #(D, 2), #(E, 1)]

d6

</>

pub fn d6(a: #(a, Int), b: #(a, Int), c: #(a, Int), d: #(a, Int), e: #(
    a,
    Int,
  ), f: #(a, Int)) -> Result(Space(D6, a), List(SpaceError))

Results in a 6-dimensional Space on success, or SpaceErrors on failure.

Examples

> type Axis { A B C D E F }
> assert Ok(space) =
>   d6(#(A, 9), #(B, 9), #(C, 9), #(D, 9), #(E, 9), #(F, 9))
> elements(space)
[#(A, 9), #(B, 9), #(C, 9), #(D, 9), #(E, 9), #(F, 9)]

degree

</>

pub fn degree(of space: Space(a, b)) -> a

Returns the degree of a given Space.

Examples

> assert Ok(space) = d0()
> degree(space)
D0

> type Axis { A B C }
> assert Ok(space) = d1(#(A, -1))
> degree(space)
D1

> assert Ok(space) = d3(#(A, 2), #(B, 2), #(C, -1))
> degree(space)
D3

elements

</>

pub fn elements(of space: Space(a, b)) -> List(#(b, Int))

Returns the elements of a given Space.

Examples

> assert Ok(space) = d0()
> elements(space)
[]

> type Axis { A B C }
> assert Ok(space) = d1(#(A, -1))
> elements(space)
[#(A, -1)]

> assert Ok(space) = d3(#(A, 2), #(B, 2), #(C, -1))
> elements(space)
[#(A, 2), #(B, 2), #(C, -1)]

map_elements

</>

pub fn map_elements(of space: Space(a, b), with fun: fn(#(b, Int)) ->
    #(c, Int)) -> Result(Space(a, c), List(SpaceError))

Results in a new Space with the same number of dimensions as the given Space on success, or SpaceErrors on failure.

Applies the given function to each element of the Space.

Examples

> type Axis { A B C }
> assert Ok(space) = d0()
> assert Ok(space) = map_elements(of: space, with: fn(_) { #(C, 3) })
> elements(space)
[]

> assert Ok(space) = d1(#(A, -1))
> assert Ok(space) = map_elements(of: space, with: fn(_) { #(C, 3) })
> elements(space)
[#(C, 3)]

> assert Ok(space) = d3(#(A, -1), #(B, 2), #(C, 2))
> assert Ok(space) = map_elements(of: space, with: fn(element) {
>   let #(axis, size) = element
>   case size == -1 {
>     True -> #(axis, 4)
>     False -> element
>   }
> })
> elements(space)
[#(A, 4), #(B, 2), #(C, 2)]

shape

</>

pub fn shape(of space: Space(a, b)) -> List(Int)

Returns the shape of a given Space.

Examples

> assert Ok(space) = d0()
> shape(space)
[]

> type Axis { A B C }
> assert Ok(space) = d1(#(A, -1))
> shape(space)
[-1]

> assert Ok(space) = d3(#(A, 2), #(B, 2), #(C, -1))
> shape(space)
[2, 2, -1]

to_string

</>

pub fn to_string(space: Space(a, b)) -> String

Converts a Space into a String.

Examples

> assert Ok(space) = d0()
> to_string(space)
"D0"

> type Axis { A B C }
> assert Ok(space) = d1(#(A, -1))
> to_string(space)
"D1 #(A, -1)"

> assert Ok(space) = d3(#(A, 2), #(B, 2), #(C, -1))
> to_string(space)
"D3 #(A, 2), #(B, 2), #(C, -1)"