# What members type (/automations/arguments)



An argument is a detail a member types after the trigger. It turns a fixed reply into a real command.

Without arguments, `!suggest` can only post the same message every time. With one argument, `!suggest add more emojis` posts **their** idea.

<Callout type="info">
  Arguments appear automatically for a **command** trigger. On the other trigger types, click **Let members type details after the trigger** in the **When** box.
</Callout>

## A first example [#a-first-example]

Say you want `!suggest <idea>`.

<Steps>
  <Step>
    ### Add an argument [#add-an-argument]

    In the **When** box, click **Add an argument**.
  </Step>

  <Step>
    ### Name it [#name-it]

    Set **Name** to `idea`. This is never seen by members. It is how you write it into your reply, as `{args.idea}`.
  </Step>

  <Step>
    ### Make it required [#make-it-required]

    Turn on **Members Must Provide It**, so a bare `!suggest` gets told what to type instead of posting an empty suggestion.
  </Step>

  <Step>
    ### Let it take the whole sentence [#let-it-take-the-whole-sentence]

    Turn on **Takes the Rest of the Message**. Without this, `idea` would only capture the first word.
  </Step>

  <Step>
    ### Use it in the reply [#use-it-in-the-reply]

    Write your reply as `**New idea from {member.mention}**` and `{args.idea}` underneath.
  </Step>
</Steps>

A member types `!suggest add more emojis` and Tickety posts their idea with their name on it.

## Using an argument [#using-an-argument]

Every argument you declare becomes a placeholder you can drop anywhere in the response: the message, an embed, a button label, a poll question, a thread name.

| Placeholder            | What it gives you                                    |
| ---------------------- | ---------------------------------------------------- |
| `{args.idea}`          | What the member typed for that argument              |
| `{args.raw}`           | Everything they typed after the trigger, untouched   |
| `{args.who.mention}`   | A ping, for user, role and channel arguments         |
| `{args.options.count}` | How many items are in a list argument                |
| `{args.options.0}`     | The first item of a list, `.1` the second, and so on |

<Callout type="warn">
  An argument a member left out resolves to nothing, so the rest of your message still reads fine. But a placeholder you spelled wrong, like `{args.ideas}`, is posted to Discord exactly as you typed it. If you see raw `{args.something}` in a message, that name does not exist.
</Callout>

## Types [#types]

| Type          | What a member types           | You get                                                                       |
| ------------- | ----------------------------- | ----------------------------------------------------------------------------- |
| **Text**      | anything                      | the text                                                                      |
| **Number**    | `12`                          | a number, kept inside your min and max                                        |
| **Choice**    | one of your options           | the option exactly as you wrote it, matched no matter what capitals they used |
| **List**      | `red - blue - green`          | a list you can turn into buttons or poll answers                              |
| **User**      | a ping or an ID               | the member, ready to ping with `.mention`                                     |
| **Role**      | a ping or an ID               | the role                                                                      |
| **Channel**   | a `#channel` or an ID         | the channel                                                                   |
| **Yes or no** | `yes`, `y`, `true`, `1`, `on` | `true`, or `false` for anything else                                          |

Each argument can also have:

* **Members Must Provide It**: without it, the automation answers with the usage line instead of posting.
* **Takes the Rest of the Message**: this argument swallows everything left. Only the last argument can do this.
* **A default**: used when the member leaves it out, so the argument still works without being required.

## How Tickety reads a message [#how-tickety-reads-a-message]

Arguments are filled left to right, one word each, except:

* **`"quoted text"` stays together.** Single quotes work too.
* **A list argument takes everything that is left**, split on its separator.
* **The argument right before a list takes everything up to the first separator.**

That last rule is what makes commands read the way people actually type them:

```
!poll who are you - im him - im you
```

| Argument          | Value              |
| ----------------- | ------------------ |
| `question` (text) | `who are you`      |
| `options` (list)  | `im him`, `im you` |

The question is not just `who`, because the dash is where the member said the question ends.

Quotes override that, for when the first option should start earlier:

```
!poll "Best day?" Mon - Tue - Wed
```

| Argument   | Value               |
| ---------- | ------------------- |
| `question` | `Best day?`         |
| `options`  | `Mon`, `Tue`, `Wed` |

## Separators [#separators]

A list argument is split on its **separator**, which is a dash by default because it is the easiest character to type on a phone.

A dash only splits when there is a space next to it, so ordinary hyphens survive:

```
!poll is it well-known - yes - no
```

gives the question `is it well-known` and the options `yes` and `no`.

You can change the separator to anything you like, for example `|` or `,`. Characters that never appear inside words split without needing spaces.

## When something is missing [#when-something-is-missing]

If a member leaves out a required argument, you choose what happens under **When Something Is Missing**:

* **Show how to use it** (default): Tickety replies with a usage line, in the channel they typed in.
* **Do nothing**: silence.

The usage line is written for you from your arguments, and shown live in the builder:

```
Usage: !poll <question> <options>
```

Required arguments show as `<name>`, optional ones as `[name]`. You can replace it with your own wording, placeholders included.

## Building buttons out of a list [#building-buttons-out-of-a-list]

A **list** argument can become the buttons or poll answers themselves. That is how one automation serves every poll anyone will ever run.

In a button group or a poll, set **Build the options from an argument** to your list argument. Whatever the member typed becomes the options.

See [the poll command recipe](/automations/recipes#a-poll-command) for the full build.

## Things that do not work [#things-that-do-not-work]

The placeholder system is simple on purpose. These do not resolve, and will post as raw text:

| Not supported               | Use instead                                                           |
| --------------------------- | --------------------------------------------------------------------- |
| `{args.options[0]}`         | `{args.options.0}`                                                    |
| `{args.options.length}`     | `{args.options.count}`                                                |
| Looping over a list         | `{args.options}` prints the whole list, or point a button group at it |
| `{args.Name}` with capitals | argument names are always lowercase                                   |