func PickASide<T>(Pair<T, T> pair, bool choose_left) -> T {

    if (choose_left) {

        return pair.left;

    } else {

        return pair.right;

    }

}

```

## Component Definition

A component definition is the definition of a Reo connector. Currently there are two variants. The meaning of these variants will be introduced in a later section. A component is defined much in the same way as a function, except that it doesn't have a return type. Is is defined as:

```

CompVariant = KwPrim | KwComp

DeclComp = CompVariant Ident PolyVars? "("

        (FuncArgDef ",")* FuncArgDef?

    ")"

    StmtBlock

```

We'll delay examples of components until we've introduced the concept of connectors in this document.

## Combining all Declarations

A module is the combination of any of the above declarations. So we may specify the possible contents of a module as:

```

Module = (

        DeclPragma | 

        DeclImport | 

        DeclEnum | 

        DeclUnion | 

        DeclStruct |

        DeclFunc |

        DeclComp

    )*

```

The `TypeRef` for a component call should resolve to either a builtin component, or a user-defined component. Component calls, like function calls, must following the rules for polymorphic arguments and the arguments to the components themselves. Furthermore component "call" expressions may only be placed with a `StmtNew` as parent. That is to say: one doesn't really call components, instead one instantiates them.

## Builtin Procedures

Several functions are builtin procedures in the language. We'll shortly provide their meaning and their syntax here. Some of these functions cannot be expressed in PDL itself, so some ad-hoc syntax is used instead.

### Get(...)

The `get` function receives a value from an input port. This function may only be called in primitive components and may only be called within sync-blocks. If no value is present then the execution halts until a value becomes available. Upon receiving a value the execution forks in two. One branch will remain waiting for any potentially other messages, the other branch will actually obtain the sent message and continue execution.

If a `get` function is called in a branch that has previously assumed that nothing will ever be sent through the port provided as argument, then that branch is considered inconsistent and will be removed. If a `get` function is called in a branch that has not decided on the firing state of a port then it will be forced to fire without forking of execution.

The get function would be written in PDL as:

```

func get<T>(in<T> input_port) -> T { /* ... */ }

```

### Put(...)

The `put` function may put a value into an output port. This function may only be called in primitive components and may only be called within sync-blocks. 

If a `put` function is called in a branch that has previously assumed that nothing will ever be sent through the port provided as argument, then that branch is considered inconsistent and will be removed. If a `put` function is called in a branch that has not decided on the firing state of a port then it will be forced to fire without forking of execution.

```

```

**note**: Whether the `put` statement blocks until a corresponding `get` has been performed has not yet been decided. 

### Fires(...)

The `fires` function will check if a port has previously been assumed to fire or not fire. If such a decision has not yet been reached then the execution forks. One branch assumes that the port will fire and the other branch assumes it will not. Otherwise this function returns the firing state of the port: true if it fires, false if it does not.

This function may only be called in primitive components and may only occur inside sync-blocks.

The `fires` function would be written in PDL, if the language would support function overloading, as:

```

func fires<T>(in<T> input_port) -> bool { /* ... */ }

func fires<T>(out<T> output_port) -> bool { /* ... */ }

```

### Create(...)

The `create` function creates a value of the type `msg`. Its argument is the length of the `msg` type. It would be written in PDL as:

```

func create(u32 length) -> msg { /* ... */ }

```

```

func length<T>(T[] v) -> u32 { /* ... */ }

func length(string v) -> u32 { /* ... */ }

func length(msg v) -> u32 { /* ... */ }

```

**note**: As stated above, the `msg` type will likely be removed. The `string` implementation is tentative, so might be changed as well.

### Assert(...)

The `assert` function is used to prune execution branches within components. It works much like an assert would in another language: the assert statement excepts an expression as argument that resolves to a boolean value. If the boolean value is `true` then execution continues. If the boolean value is `false` then the execution branch is removed.

The `assert` function may only appear in components (primitive or composite) and may only be called in sync-blocks. It would be written in PDL, if it would support the C-like "void" type, as:

```

func assert(bool test) -> void { /* ... */ }

```

**note**: Perhaps the name of this function will change in the future.

## Statement Rules

### Synchronous Blocks

### Use of Builtin Procedures