Question: [Underload](http://esolangs.org/wiki/Underload) is a stack-based semi-functional tarpit created by [ais523](https://codegolf.stackexchange.com/users/62131/ais523). I've recently been trying to golf in it, as it's a surprisingly elegant language.

What tips do you have for golfing in Underload? (One tip per answer)

Answer: 
"Dirty" Decrement
-----------------

The functionally-pure way to decrement a Church numeral is to use the lambda calculus predecessor function:

```
\n.n(\p.\z.z($(pT))(pT))(\z.z0[whatever you define the predecessor of 0 to be])

```

Where 0 = \x.\y.y, T = \x.\y.x, and $ is the successor.

Rewritten in Underload, this is 28 bytes:

```
(!())~(!())~(!:(:)~*(*)*~)~^!

```

This is alright, but we can exploit some of Underload's useful properties, namely that `:!` and `()*` do are no-ops. This means that, for a number `n`, `:ⁿ!!()()*ⁿ` (where `cⁿ` is `c` repeated `n` times) yields n-1. For example doing this for the Church numeral 3 yields this:

```
:::!!()()***

```

Removing no-op pairs, we get:

```
:*

```

Which is 2.

So this is the new and shorter predecessor operation:

```
:(:)~^(!!()())*~(*)~^*

```

This is 7 bytes shorter.
Put Unneeded Stack Values into the Program Space
================================================

Underload actually has two stacks—the stack of strings, and the stack of commands that make up the source code. Underload's `^` instruction lets us move strings from the former stack to the latter. By doing this, we can save a lot of unnecessary stack manipulation.

For example, say we have `(a)(b)(c)` on the main stack and we'd like to concatenate the bottom two elements, ignoring `(c)`, to get `(ab)(c)`. The naïve way to do this is to rotate the stack to get `(c)(a)(b)` and then concantenate and swap back:

```
a~a~*~a*^*~

```

This is bad. Using `a~a~*~a*^` to rotate the stack like this is extremely costly, and should be avoided when possible. By putting `(c)` into the program space instead, this can be made four bytes shorter:

```
a(*)~*^

```

The idea is to take the instructions you'd like to execute and then add an instruction to push `(c)` back at the end, and then evaluate the result. This means that we don't have to worry about `(c)` until it's pushed back after we've finished.