コマンドはdo記法の形をとることもある。例えば次のように書くことができる。

proc x -> do
        y <- f -< x+1
        g -< 2*y
        let z = x+y
        t <- h -< x*z
        returnA -< t+z

これは通常のdo記法と大体同じように読むことができる。ただし、モナドな式の代わりにコマンドが使われている。最初の行では、x+1の値がアローfに入力として送られ、出力がyに対して照合される。次の行では、出力は捨てられている。returnAというアローは、Control.Arrowモジュールで、arr idとして定義されている。上の例は次のものの略記として扱われる。

arr (\ x -> (x, x)) >>>
        first (arr (\ x -> x+1) >>> f) >>>
        arr (\ (y, x) -> (y, (x, y))) >>>
        first (arr (\ y -> 2*y) >>> g) >>>
        arr snd >>>
        arr (\ (x, y) -> let z = x+y in ((x, z), z)) >>>
        first (arr (\ (x, z) -> x*z) >>> h) >>>
        arr (\ (t, z) -> t+z) >>>
        returnA

それ以降使われない変数は射影で捨てられていることに注意。これにControl.Arrowで定義されている書き換え規則(7.21. 書き換え規則 を見よ)を使って単純化を施すと、以下のように簡約される。

arr (\ x -> (x+1, x)) >>>
        first f >>>
        arr (\ (y, x) -> (2*y, (x, y))) >>>
        first g >>>
        arr (\ (_, (x, y)) -> let z = x+y in (x*z, z)) >>>
        first h >>>
        arr (\ (t, z) -> t+z)

手で書くなら最初からこう書いたであろう。アロー記法を使えば、GHCがあなたの代わりにこれらの変数のタプルたちを管理してくれる。

なお、上の変換では、let束縛された変数(たとえばz)が単相的でなければならないように見えるが、実際の変換で生成されるのはcoreなので、変数は多相的であり得る。

相互再帰的な束縛を使うこともできる。これには、recという新しいキーワードを使う。以下のようになる。

counter :: ArrowCircuit a => a Bool Int
counter = proc reset -> do
        rec     output <- returnA -< if reset then 0 else next
                next <- delay 0 -< output+1
        returnA -< output

このような形式は、変換すると、loopコンビネータを使ったものになるので、その場合のアローはArrowLoopクラスに属していなければならない。

前の例では、アローへの入力を構築するために条件式を使った。場合によっては、以下のように、条件によって異なるコマンドを実行したいことがある。

proc (x,y) ->
        if f x y
        then g -< x+1
        else h -< y+2

これは次のように変換される。

arr (\ (x,y) -> if f x y then Left x else Right y) >>>
        (arr (\x -> x+1) >>> g) ||| (arr (\y -> y+2) >>> h)

変換結果で|||が使われているので、この場合のアローはArrowChoiceクラスに属していなければならない。

以下のようなcaseコマンドもある。

case input of
    [] -> f -< ()
    [x] -> g -< x+1
    x1:x2:xs -> do
        y <- h -< (x1, x2)
        ys <- k -< xs
        returnA -< y:ys

構文はcase式と同じであるが、選択肢の本体が式でなくコマンドである点が異なる。変換はifで行われるものに似ている。

既に見たように、アロー記法には、逐次実行、値再帰、および条件分岐について、式のものを手本とした構文要素が提供されている。しかし、適切なコンビネータ(これはHaskellで普通に定義できる)があれば、それを、既存のコマンドから新しいコマンドをつくり出すのに使うこともできる。基本的な考え方としては、コマンドを、環境から値へのアローとみなすのである。環境は、コマンド中の自由な局所変数に値を割り当てる。これにより、アローからアローをつくり出すコンビネータは、コマンドからコマンドを構築するのにも使える。例えば、ArrowPlusクラスには次のコンビネータがある。

ArrowPlus a => (<+>) :: a b c -> a b c -> a b c

よって、これを使ってコマンドを組み立てることができる。

expr' = proc x -> do
                returnA -< x
        <+> do
                symbol Plus -< ()
                y <- term -< ()
                expr' -< x + y
        <+> do
                symbol Minus -< ()
                y <- term -< ()
                expr' -< x - y

(最初の行のdoは、最初の<+> ...が、直前の行の式の一部だとみなされるのを防ぐために必要である)。これは以下のものと同等である。

expr' = (proc x -> returnA -< x)
        <+> (proc x -> do
                symbol Plus -< ()
                y <- term -< ()
                expr' -< x + y)
        <+> (proc x -> do
                symbol Minus -< ()
                y <- term -< ()
                expr' -< x - y)

ここでは、実は<+>を以下の特殊化された型で使っている。

ArrowPlus a => (<+>) :: a (e,()) c -> a (e,()) c -> a (e,()) c

この演算子がe(そのコマンドへの環境入力。必然的にそのサブコマンドへの環境入力にもなる)について多相的であって、少なくとも正格なkについては以下の自然性を満たす、ということが本質的に重要である。

arr (first k) >>> (f <+> g) = (arr (first k) >>> f) <+> (arr (first k) >>> g)

(seqを使っていないなら自動的にこうなるはずである)。これにより、サブコマンドが見る環境がコマンド全体の環境と同じだということ、および変換において環境のうちの不要な部分を捨てても安全だということが保証される。(入力の対の第二要素は、次の節で述べるように、無名の入力値を持つことができる。)また、この演算子は、現在のアロー抽象の中で定義された変数を使っていてはならない。

次のように自分で演算子を定義し、同様の方法で使うこともできる。

untilA :: ArrowChoice a => a (e,s) () -> a (e,s) Bool -> a (e,s) ()
untilA body cond = proc x ->
        b <- cond -< x
        if b then returnA -< ()
        else do
                body -< x
                untilA body cond -< x

もちろん、この中置記法の構文は二項演算子についてしかうまく働かない。特別な括弧を使った、より一般的な構文が存在する。

proc x -> do
        y <- f -< x+1
        (|untilA (increment -< x+y) (within 0.5 -< x)|)

演算子によっては、サブコマンドに追加の引数を渡す必要がある。例えば、例外を扱えるアローにおいて、例外ハンドラを付加する演算子では、発生した例外をハンドラに渡したいと思うだろう。このような演算子は次のような型を持っていると考えられる。

handleA :: ... => a (e,s) c -> a (e,(Ex,s)) c -> a (e,s) c

ここで、Exは扱われる例外の型である。このとき、次のようなコマンドを書くことで、これをアロー記法中で使うことができる。

body `handleA` \ ex -> handler

意図は、コマンドbodyが例外を発生させたら、変数exがその例外の値に束縛され、コマンドhandler(通常exを参照する)に進入する、というものである。この構文は関数のラムダに似ているが、ここで扱われているのはコマンドであって、やっていることが異なる。コマンドが表すアローの入力は、コマンド中の自由な局所変数の値に加えて、無名の値のスタックから成る。ここまでの例ではこのスタックについては何も仮定しなかった。handleAの第二引数では、ハンドラに与えられたスタックに例外の値を追加している。コマンド用のラムダはこの値に名前を与えているに過ぎない。

より具体的にいうと、コマンドへの入力は、環境とスタックの対からなる。スタック中のそれぞれの値は、スタックの残りの部分との対になっており、空スタックは()である。handleAのような、サブコマンドに追加の入力を渡す演算子をこの記法で使えるようにするには、それらの追加入力の値をこのようにしてスタックに置けば良い。 さらに正確に言うと、演算子のそれぞれの引数(および結果)の型は以下の形をしているべきである。

a (e, (t1, ... (tn, ())...)) t

ここで、eは(環境を表す)多相変数であり、tiはスタック中の値の型であり、t1が「先頭」である。多相変数eはa、ti、tに現れてはならない。一方、関係するアローが同じである必要はない。適切な演算子の例をもう少し示す。

bracketA :: ... => a (e,s) b -> a (e,(b,s)) c -> a (e,(c,s)) d -> a (e,s) d
runReader :: ... => a (e,s) c -> a' (e,(State,s)) c
runState :: ... => a (e,s) c -> a' (e,(State,s)) (c,State)

後ろ二者で作られたコマンドが必要とする追加の引数は、そのコマンドを通常の式に適用することで与えることができる。次のように。

proc x -> do
        s <- ...
        (|runReader (do { ... })|) s

これは、runReaderを使って作られたコマンドの入力のスタックにsを加えている。

コマンド版のラムダ抽象と適用は式におけるそれに似ている。特に、β規則とη規則がコマンドの同等性を記述する。これらの三つの機能(演算子、ラムダ抽象、適用)がこの記法の核である。他のものは全てこれらを使って(不格好になるだろうが)構築することができる。例えば、次のように定義することによってdo記法をシミュレートできる。

bind :: Arrow a => a (e,s) b -> a (e,(b,s)) c -> a (e,s) c
u `bind` f = returnA &&& u >>> f

bind_ :: Arrow a => a (e,s) b -> a (e,s) c -> a (e,s) c
u `bind_` f = u `bind` (arr fst >>> f)

次のように定義することでifをシミュレートできる。

cond :: ArrowChoice a => a (e,s) b -> a (e,s) b -> a (e,(Bool,s)) b
cond f g = arr (\ (e,(b,s)) -> if b then Left (e,s) else Right (e,s)) >>> f ||| g

アロー記法を直接実装しているのはGHCだけであるが、アロー記法をHaskell 98に変換することで別のHaskellシステムでも使える前処理器(arrows web pageから入手可能)もある。それでも、アローを使ったプログラムをGHCで検査したいと思うかもしれない。前処理器の出力から型エラーを追跡するのは簡単ではないからである。モジュールを、GHCとこの前処理器の両方で使えるようにする場合、いくつか余分な制約が科せられる。