+For Monads (Composables), on the other hand, you can perform more radical transformations of that sort. For example, `join (map (\x. dup x x) [3,2,0,1])` would give us `[3,3,3,2,2,1]` (for a suitable definition of `dup`).
+
+<!--
+Some global transformations that we work with in semantics, like Veltman's test functions, can't directly be expressed in terms of the primitive Monad operations? For example, there's no `j` such that `xs >>= j == mzero` if `xs` anywhere contains the value `1`.
+-->
+
+
+## Interdefinitions and Subsidiary notions##
+
+We said above that various of these box type operations can be defined in terms of others. Here is a list of various ways in which they're related. We try to stick to the consistent typing conventions that:
+
+<pre>
+f : α -> β; g and h have types of the same form
+ also sometimes these will have types of the form α -> β -> γ
+ note that α and β are permitted to be, but needn't be, boxed types
+j : α -> <u>β</u>; k and l have types of the same form
+u : <u>α</u>; v and xs and ys have types of the same form
+
+w : <span class="box2">α</span>
+</pre>
+
+But we may sometimes slip.
+
+Here are some ways the different notions are related:
+
+<pre>
+j >=> k ≡= \a. (j a >>= k)
+u >>= k == (id >=> k) u; or ((\(). u) >=> k) ()
+u >>= k == join (map k u)
+join w == w >>= id
+map2 f xs ys == xs >>= (\x. ys >>= (\y. mid (f x y)))
+map2 f xs ys == (map f xs) m$ ys, using m$ as an infix operator
+fs m$ xs == fs >>= (\f. map f xs)
+m$ == map2 id
+map f xs == mid f m$ xs
+map f u == u >>= mid ○ f
+</pre>
+
+
+Here are some other monadic notion that you may sometimes encounter:
+
+* <code>mzero</code> is a value of type <code><u>α</u></code> that is exemplified by `Nothing` for the box type `Maybe α` and by `[]` for the box type `List α`. It has the behavior that `anything m$ mzero == mzero == mzero m$ anything == mzero >>= anything`. In Haskell, this notion is called `Control.Applicative.empty` or `Control.Monad.mzero`.
+
+* Haskell has a notion `>>` definable as `\u v. map (const id) u m$ v`, or as `\u v. u >>= const v`. This is often useful, and `u >> v` won't in general be identical to just `v`. For example, using the box type `List α`, `[1,2,3] >> [4,5] == [4,5,4,5,4,5]`. But in the special case of `mzero`, it is a consequence of what we said above that `anything >> mzero == mzero`. Haskell also calls `>>` `Control.Applicative.*>`.
+
+* Haskell has a correlative notion `Control.Applicative.<*`, definable as `\u v. map const u m$ v`. For example, `[1,2,3] <* [4,5] == [1,1,2,2,3,3]`. You might expect Haskell to call `<*` `<<`, but they don't. They used to use `<<` for `flip (>>)` instead, but now they seem not to use `<<` anymore.
+
+* <code>mapconst</code> is definable as `map ○ const`. For example `mapconst 4 [1,2,3] == [4,4,4]`. Haskell calls `mapconst` `<$` in `Data.Functor` and `Control.Applicative`. They also use `$>` for `flip mapconst`, and `Control.Monad.void` for `mapconst ()`.
+
+
+
+## Examples ##