# FunctionExpression

A TypeScript function expression.

* jsx

  ```tsx
  import { FunctionExpression } from "@alloy-js/typescript";


  <FunctionExpression
    async
    parameters={ParameterDescriptor[] | string[]}
    parametersChildren={Children}
    returnType={Children}
    typeParameters={TypeParameterDescriptor[] | string[]}
    typeParametersChildren={Children}
  >
    {children}
  </FunctionExpression>
  ```

* stc

  ```ts
  import { FunctionExpression } from "@alloy-js/typescript/stc";


  FunctionExpression({
    async: boolean,
    parameters: ParameterDescriptor[] | string[],
    parametersChildren: Children,
    returnType: Children,
    typeParameters: TypeParameterDescriptor[] | string[],
    typeParametersChildren: Children,
  }).children(children)
  ```

## Props

|                        |                                                                                         |                                                                                                                                                                                                                                       |
| ---------------------- | --------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| async                  | optional boolean                                                                        |                                                                                                                                                                                                                                       |
| children               | optional[Children](../../../core/types/children/)                                       |                                                                                                                                                                                                                                       |
| parameters             | optional[ParameterDescriptor](../../types/parameterdescriptor/)\[] \| string\[]         | The parameters to the function. Can be an array of strings for parameters which don’t have a type or a default value. Otherwise, it’s an array of [ParameterDescriptor](../../types/parameterdescriptor/)s.                           |
| parametersChildren     | optional[Children](../../../core/types/children/)                                       | Raw content to be used as the parameter list.                                                                                                                                                                                         |
| returnType             | optional[Children](../../../core/types/children/)                                       | The return type of the function.                                                                                                                                                                                                      |
| typeParameters         | optional[TypeParameterDescriptor](../../types/typeparameterdescriptor/)\[] \| string\[] | The type parameters for the function. Can be an array of strings for type parameters which don’t have any constraints or a default type, otherwise it’s an array of [TypeParameterDescriptor](../../types/typeparameterdescriptor/)s. |
| typeParametersChildren | optional[Children](../../../core/types/children/)                                       | Raw content to be used as the type parameter list.                                                                                                                                                                                    |

## Remarks

Providing parameters and type parameters can be accomplished in one of three ways:

1. As an array of [ParameterDescriptor](../../types/parameterdescriptor/)s or [TypeParameterDescriptor](../../types/typeparameterdescriptor/)s. 2. As raw content via the `parametersChildren` or `typeParametersChildren` props. 3. As a child of this component via the \[unresolved link] or \[unresolved link] components.

## Example

```tsx
<FunctionExpression async parameters={[{ name: "a", type: "number" }, { name: "b", type: "number" }]}>
  return a + b;
<FunctionExpression>
```

renders to

```ts
async function (a, b) { return a + b; }
```