# Function

---

```text
INVOCATION : UNKNOWN | SYNC | ASYNC

STATELESS : INCOMPLETE | NATIVE | NATIVE_INLINE | PROCESS | GENERATOR | REGEX_GENERATOR

STATEFUL : TASK | ITERATOR | CLOSURE | BOUND | REGEX

FLAGS : INVOCATION | STATELESS | STATEFUL

Function[[FLAGS]; Body; RETURN_TYPE; Collection[VAR_LIST; TYPE.SYMBOL]]
```

## Type Body Object Definitions

```c
typedef struct {
    kpl_ptr body, return_type, var_list;
} kpl_type_body_function;
```

# Alias

```text
Fn[Generic.T; Collection[VAR_TREE_LIST; TYPE.SYMBOL]] `alias Function[[FLAGS]; STATE; List; Generic.T; Collection[VAR_TREE_LIST; TYPE.SYMBOL]]
```

# Inline Definition

```text
([x; y] x + y) // Fn[Any; Any.x; Any.y]
([I64.x; y] x + y) // Fn[Any; I64.x; Any.y]
```

# Function Classes

## Unknown

Placeholder before evaluation

## Incomplete

A function with an incomplete type, type checking occurs at invocation

## Native

Native C code that can be called async

## Native Inline

Native C code that cannot be called async

## Task

A queue-able function in a process or iterator

## Process

A list of tasks with state

## Generator

A function for creating an iterator

## Regex Generator

A function for creating Regular Expression matcher

## Iterator

A task creator with state, cannot take arguments, can be called until done

## Closure

A task creator with state that can take arguments

## Bound

A function with some arguments already set

## Regex

Invoked regular expression matcher

# Returning

## \`return

## Transient Union Return Chaining

# Iterating

## \`yield

Yielding wraps the value in the transient union `Next`

Return `Void` to stop iteration

```text
fn : ([n] @ 1 < n {[x] `yield 2 * x; n +: 1 } )
it : fn `sync 10
// invoking
@ it {[v] `log v } // 2 4 6 8 10 12 14 16 18 20
// same as above
@ {
    # `sync it {
        .value {[v] `log v }
        .done { `break }
    }
}
```

## Range `..`

# Calling

## \`async

Asynchronous call

```text
task : `async fn
value : `await task
```

## \`sync

Synchronous call

If the callee is a process, an inline await with async is used

```text
fn `sync args // can be turned into `await fn `async args
```

# Binding

## \`bind