In this tutorial we go back to the escrow example, and show how we can use the embedding of Marlowe in Haskell to make more readable, modular and reusable descriptions of Marlowe contracts.

## A simple escrow contract, revisited.¶ Recall that we developed this Marlowe contract in our earlier tutorial.

While we presented it there as a “monolothic” contract, we can use Haskell definitions to make it more readable. To start with, we can separate the initial commitment from the inner working part of the contract:

```contract :: Contract
contract = When [Case (Deposit "alice" "alice" ada price) inner]
10
Close

inner :: Contract
inner =
When [ Case aliceChoice
(When [ Case bobChoice
(If (aliceChosen `ValueEQ` bobChosen)
agreement
arbitrate) ]
60
arbitrate)
]
40
Close
```

Many of the terms here are themselves defined within Haskell. Principally, we have the two contracts that deal with what happens when there is `agreement` between Alice and Bob, and if not, how Carol should `arbitrate` between them:

```agreement :: Contract
agreement =
If
(aliceChosen `ValueEQ` (Constant 0))
(Pay "alice" (Party "bob") ada price Close)
Close

arbitrate :: Contract
arbitrate =
When  [ Case carolClose Close,
Case carolPay (Pay "alice" (Party "bob") ada price Close) ]
100
Close
```

Within these contracts we are also using simple abbreviations such as

```price :: Value
price = Constant 450
```

which indicates the price of the cat, and so the value of the money under escrow.

We can also describe the choices made by Alice and Bob, noting that we’re also asked for a default value `defValue` just in case the choices have not been made.

```aliceChosen, bobChosen :: Value

aliceChosen = ChoiceValue (ChoiceId choiceName "alice")
bobChosen   = ChoiceValue (ChoiceId choiceName "bob")

defValue = Constant 42

choiceName :: ChoiceName
choiceName = "choice"
```

In describing choices we can give sensible names to the numeric values:

```pay,refund,both :: [Bound]

pay    = [Bound 0 0]
refund = [Bound 1 1]
both   = [Bound 0 1]
```

and define new functions (or “templates”) for ourselves. In this case we define

```choice :: Party -> [Bound] -> Action

choice party bounds =
Choice (ChoiceId choiceName party) bounds
```

as a way of making the expression of choices somewhat simpler and more readable:

```alicePay, aliceRefund, aliceChoice :: Action
alicePay    = choice "alice" pay
aliceRefund = choice "alice" refund
aliceChoice = choice "alice" both
```

Given all these definitions, we are able to write the contract at the start of this section in a way that makes its intention clear. Writing in ``pure’’ Marlowe, or by expanding out these definitions, we would have this contract instead:

```When [
(Case
(Deposit
(Constant 450))
(When [
(Case
(Choice
(ChoiceId "choice" "alice") [
(Bound 0 1)])
(When [
(Case
(Choice
(ChoiceId "choice" "bob") [
(Bound 0 1)])
(If
(ValueEQ
(ChoiceValue
(ChoiceId "choice" "alice"))
(ChoiceValue
(ChoiceId "choice" "bob")))
(If
(ValueEQ
(ChoiceValue
(ChoiceId "choice" "alice"))
(Constant 0))
(Pay
"alice"
(Constant 450) Close) Close)
(When [
(Case
(Choice
(ChoiceId "choice" "carol") [
(Bound 1 1)]) Close)
,
(Case
(Choice
(ChoiceId "choice" "carol") [
(Bound 0 0)])
(Pay
"alice"
(Constant 450) Close))] 100 Close)))] 60
(When [
(Case
(Choice
(ChoiceId "choice" "carol") [
(Bound 1 1)]) Close)
,
(Case
(Choice
(ChoiceId "choice" "carol") [
(Bound 0 0)])
(Pay
"alice"