# 9 Deep-guard Concurrent Constraint Combinators: `Combinator`

This chapter describes deep-guard concurrent constraint combinators such as conditional and disjunction. Most combinators implemented by the module `Combinator` are available by convenient syntax and are described in Chapter 12 of ``Tutorial of Oz''.

`'not'`

  > `{Combinator.'not'` `+P``}`

  implements deep-negation where the nullary procedure `P` gives the statement to negate.

  Is supported by special syntax. The statement

  > `not` `S` `end`

  expands to

  > `{Combinator.'not' proc {$}` `S` `end}`

`'reify'`

  > `{Combinator.'reify'` `+P``` `$D``}`

  implements deep-reification where the nullary procedure `P` gives the statement to reify.

`'cond'`

  > `{Combinator.'cond'` `+T``` `+P``}`

  implements parallel concurrent conditional.

`'or'`

  > `{Combinator.'or'` `+T``}`

  implements disjunction. `T` is a tuple of either nullary or unary procedures. The special syntax statement

  > `or` `S1``
  > []` `S2``
  > []` `S3` `then` `S4``
  > end
  > `

  corresponds to the following

  > `local
  > proc {C1}` `S1` `end
  > proc {C2}` `S2` `end
  > fun {C3}` `S3` `proc {$}` `S4` `end end
  > in
  > {Combinator.'or' C1#C2#C3}
  > end
  > `

`'choice'`

  > `{Combinator.'choice'` `+T``}`

  implements choice point construction.

`'dis'`

  > `{Combinator.'dis'` `+T``}`

  implements andorra-style disjunction.