diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,10 @@
+1.2.0
+------------
+* Support of `ArrowReader`.
+* Added await fail handling.
+* Improved performance by church-encoded free monads.
+* Arrow stack of newest GHC support for some utilities.
+
 1.1.1
 ------------
 * Eliminated banana brackets to support newest GHC.
diff --git a/machinecell.cabal b/machinecell.cabal
--- a/machinecell.cabal
+++ b/machinecell.cabal
@@ -1,5 +1,5 @@
 name:                machinecell
-version:             1.1.1
+version:             1.2.0
 synopsis:            Arrow based stream transducers
 license:             BSD3
 license-file:        LICENSE
@@ -21,10 +21,10 @@
 	AFRP-like utilities are also available.
 
 library
-  exposed-modules:     Control.Arrow.Machine, Control.Arrow.Machine.Event, Control.Arrow.Machine.Plan, Control.Arrow.Machine.Types, Control.Arrow.Machine.Utils, Control.Arrow.Machine.Running, Control.Arrow.Machine.ArrowUtil
-  other-modules:         Control.Arrow.Machine.Event.Internal
+  exposed-modules:     Control.Arrow.Machine, Control.Arrow.Machine.Event, Control.Arrow.Machine.Plan, Control.Arrow.Machine.Types, Control.Arrow.Machine.Utils, Control.Arrow.Machine.Running, Control.Arrow.Machine.ArrowUtil, Control.Arrow.Machine.Exception, Control.Arrow.Machine.Core
+  other-modules:         Control.Arrow.Machine.Event.Internal, Control.Arrow.Machine.Plan.Internal
   other-extensions:    FlexibleInstances, Arrows, RankNTypes, TypeSynonymInstances, MultiParamTypeClasses, GADTs, FlexibleContexts, NoMonomorphismRestriction, RecursiveDo
-  build-depends:       base >=4.0 && < 5.0, mtl >=2.0, free >=3.0 && < 5.0, profunctors >=3.0
+  build-depends:       base >=4.0 && < 5.0, mtl >=2.0, free >=3.0 && < 5.0, profunctors >=3.0, arrows >= 0.4
   hs-source-dirs:      src
   default-language:    Haskell2010
 
@@ -44,4 +44,4 @@
 source-repository this
   type:		git
   location:	https://github.com/as-capabl/machinecell.git
-  tag:		release-1.1.1
+  tag:		release-1.2.0
diff --git a/src/Control/Arrow/Machine.hs b/src/Control/Arrow/Machine.hs
--- a/src/Control/Arrow/Machine.hs
+++ b/src/Control/Arrow/Machine.hs
@@ -11,6 +11,7 @@
         module Control.Arrow.Machine.Event, 
         module Control.Arrow.Machine.Utils,
         module Control.Arrow.Machine.Plan,
+        module Control.Arrow.Machine.Exception,
         module Control.Arrow.Machine.Running,
         module Control.Arrow.Machine.ArrowUtil,
 
@@ -23,6 +24,7 @@
 import Control.Arrow.Machine.Event
 import Control.Arrow.Machine.Utils
 import Control.Arrow.Machine.Plan
+import Control.Arrow.Machine.Exception
 import Control.Arrow.Machine.Running
 import Control.Arrow.Machine.ArrowUtil
 
diff --git a/src/Control/Arrow/Machine/ArrowUtil.hs b/src/Control/Arrow/Machine/ArrowUtil.hs
--- a/src/Control/Arrow/Machine/ArrowUtil.hs
+++ b/src/Control/Arrow/Machine/ArrowUtil.hs
@@ -1,18 +1,58 @@
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE Arrows #-}
 
+
+-- | Arrow utilities not related to machinecell library.
 module
     Control.Arrow.Machine.ArrowUtil (
+        -- * Arrow construction helper
         kleisli,
         kleisli0,
         kleisli2,
         kleisli3,
         kleisli4,
-        kleisli5
+        kleisli5,
+
+        reading,
+
+        -- * To absorve arrow stack signature difference bettween ghc 7.8 and older.
+        AS,
+        toAS,
+        fromAS,
+
+        elimR
     )
 where
 
 import Control.Arrow
+import Control.Arrow.Operations (readState)
+import Control.Arrow.Transformer.Reader
+import Control.Monad.Reader (ReaderT, runReaderT)
 
+#if __GLASGOW_HASKELL__ >= 708
 
+type AS e = (e, ())
+
+toAS :: e -> AS e
+toAS e = (e, ())
+
+fromAS :: AS e -> e
+fromAS = fst
+
+#else
+
+type AS e = e
+
+toAS :: e -> AS e
+toAS = id
+
+fromAS :: AS e -> e
+fromAS = id
+
+#endif
+
+
 kleisli :: Monad m => (a->m b) -> Kleisli m a b
 kleisli = Kleisli
 
@@ -32,3 +72,18 @@
 kleisli5 fmx = Kleisli $ \(x1, x2, x3, x4, x5) -> fmx x1 x2 x3 x4 x5
 
 
+reading :: 
+    (Monad m, Arrow a) => 
+    (forall p q. (p->m q)->a p q) -> 
+    (b -> ReaderT r m c) -> ReaderArrow r a b c
+reading f mr = proc x ->
+  do
+    r <- readState -< ()
+    liftReader (f $ \(x, r) -> runReaderT (mr x) r) -< (x, r)
+
+-- |Alternate for `elimReader` that can be used with both ghc 7.8 and older.
+elimR ::
+    ArrowAddReader r a a' =>
+    a (AS e) b -> a' (e, AS r) b
+elimR f =
+    second (arr $ fromAS) >>> elimReader (arr toAS >>> f)
diff --git a/src/Control/Arrow/Machine/Core.hs b/src/Control/Arrow/Machine/Core.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/Arrow/Machine/Core.hs
@@ -0,0 +1,40 @@
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE Arrows #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE TypeSynonymInstances #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE GADTs #-}
+
+
+{-|
+Extracted stuff to be used unqualified from ../Machine.hs.
+-}
+module
+    Control.Arrow.Machine.Core
+      (
+        -- * Modules
+        module Control.Arrow.Machine.Event, 
+--        module Control.Arrow.Machine.Utils,
+        module Control.Arrow.Machine.Plan,
+--        module Control.Arrow.Machine.Exception,
+        module Control.Arrow.Machine.Running,
+--        module Control.Arrow.Machine.ArrowUtil,
+
+        -- * The transducer arrow
+        ProcessA(), 
+        fit,
+       )
+where
+
+import Control.Arrow.Machine.Event
+-- import Control.Arrow.Machine.Utils
+import Control.Arrow.Machine.Plan
+-- import Control.Arrow.Machine.Exception
+import Control.Arrow.Machine.Running
+import qualified Control.Arrow.Machine.Running as Running
+-- import Control.Arrow.Machine.ArrowUtil
+
+import Control.Arrow.Machine.Types
+import Control.Arrow
+
+
diff --git a/src/Control/Arrow/Machine/Event.hs b/src/Control/Arrow/Machine/Event.hs
--- a/src/Control/Arrow/Machine/Event.hs
+++ b/src/Control/Arrow/Machine/Event.hs
@@ -14,6 +14,9 @@
         evMaybe,
         fromEvent,
         evMap,
+
+        -- * Deprecated
+        -- | To be renamed.
         split,
         join,
         split2,
diff --git a/src/Control/Arrow/Machine/Exception.hs b/src/Control/Arrow/Machine/Exception.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/Arrow/Machine/Exception.hs
@@ -0,0 +1,98 @@
+
+
+module
+    Control.Arrow.Machine.Exception
+      (
+        catch,
+        handle,
+        bracket,
+        bracket_,
+        bracketOnError,
+        finally,
+        onException
+       )
+where
+
+import qualified Control.Monad.Trans.Free as F
+import qualified Control.Monad.Trans.Free.Church as F
+
+import Data.Functor ((<$>))
+
+import Control.Arrow.Machine.Types
+import Control.Arrow.Machine.Event
+import Control.Arrow.Machine.Event.Internal (Event(..))
+
+import Control.Arrow.Machine.Plan.Internal
+import Control.Arrow.Machine.Plan
+
+import Debug.Trace
+
+
+catch :: Monad m =>
+    PlanT i o m a -> PlanT i o m a -> PlanT i o m a
+
+catch pl cont = 
+    F.toFT $ catch' (F.fromFT pl) (F.fromFT cont)
+
+catch' (F.FreeT mf) cont@(F.FreeT mcont) = 
+    F.FreeT $ mf >>= go
+  where
+    go (F.Pure a) = return $ F.Pure a
+    go (F.Free StopPF) = mcont
+    go (F.Free (AwaitPF f ff)) = 
+        return $ F.Free $ 
+        AwaitPF (\i -> f i `catch'` cont) (ff `catch'` cont)
+    go (F.Free fft) = 
+        return $ F.Free $ (`catch'` cont) <$> fft
+
+handle :: Monad m =>
+    PlanT i o m a -> PlanT i o m a -> PlanT i o m a
+
+handle = flip catch
+
+
+bracket :: Monad m =>
+    PlanT i o m a -> (a -> PlanT i o m b)-> (a -> PlanT i o m c) -> PlanT i o m c
+bracket before after thing =
+  do
+    a <- before
+    r <- thing a `catch` (after a >> stop)
+    _ <- after a
+    return r
+
+
+bracket_ :: Monad m =>
+    PlanT i o m a -> PlanT i o m b-> PlanT i o m c -> PlanT i o m c
+bracket_ before after thing =
+  do
+    before
+    r <- thing `catch` (after >> stop)
+    _ <- after
+    return r
+
+
+bracketOnError :: Monad m =>
+    PlanT i o m a -> (a -> PlanT i o m b)-> (a -> PlanT i o m c) -> PlanT i o m c
+bracketOnError before after thing =
+  do
+    a <- before
+    r <- thing a `catch` (after a >> stop)
+    return r
+
+
+finally :: Monad m =>
+    PlanT i o m a -> PlanT i o m b-> PlanT i o m a
+finally thing after =
+  do
+    r <- thing `catch` (after >> stop)
+    _ <- after
+    return r
+
+
+onException :: Monad m =>
+    PlanT i o m a -> PlanT i o m b-> PlanT i o m a
+onException thing after =
+  do
+    thing `catch` (after >> stop)
+    
+
diff --git a/src/Control/Arrow/Machine/Plan.hs b/src/Control/Arrow/Machine/Plan.hs
--- a/src/Control/Arrow/Machine/Plan.hs
+++ b/src/Control/Arrow/Machine/Plan.hs
@@ -3,7 +3,6 @@
 {-# LANGUAGE GADTs #-}
 {-# LANGUAGE TypeSynonymInstances #-}
 {-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE OverlappingInstances #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
 
 {-|
@@ -33,6 +32,7 @@
 
 import qualified Control.Category as Cat
 import qualified Control.Monad.Trans.Free as F
+import qualified Control.Monad.Trans.Free.Church as F
 
 import Data.Monoid (mappend)
 import Data.Functor ((<$>))
@@ -45,48 +45,24 @@
 import Control.Arrow.Machine.Event
 import Control.Arrow.Machine.Event.Internal (Event(..))
 
+import Control.Arrow.Machine.Plan.Internal
+
 stopped :: 
     (ArrowApply a, Occasional c) => ProcessA a b c
 stopped = arr (const end)
 
 
 
-data PlanF i o a where
-  AwaitPF :: (i->a) -> PlanF i o a
-  YieldPF :: o -> a -> PlanF i o a
-  StopPF :: a -> PlanF i o a
 
-instance (Functor (PlanF i o)) where
-  fmap g (AwaitPF f) = AwaitPF (g . f)
-  fmap g (YieldPF x r) = YieldPF x (g r)
-  fmap g (StopPF r) = StopPF (g r)
 
-
-type PlanT i o m a = F.FreeT (PlanF i o) m a
-type Plan i o a = forall m. Monad m => PlanT i o m a
-
-instance 
-    Monad m => MonadPlus (F.FreeT (PlanF i o) m)
-  where
-    mzero = stop >> return undefined
-    (F.FreeT mf) `mplus` cont@(F.FreeT mcont) = 
-        F.FreeT $ mf >>= go
-      where
-        go (F.Pure a) = mcont >>= return
-        go (F.Free (StopPF ft)) = mcont >>= return
-        go (F.Free fft) = return $ F.Free $ (`mplus` cont) <$> fft
-
 yield :: o -> Plan i o ()
 yield x = F.liftF $ YieldPF x ()
 
-await_ :: Monad m => (i->PlanT i o m a) -> PlanT i o m a
-await_ f = F.FreeT $ return $ F.Free $ AwaitPF f
-
 await :: Plan i o i
-await = await_ return
+await = F.FT $ \pure free -> free (AwaitPF pure (free StopPF))
 
-stop :: Plan i o ()
-stop = F.liftF $ StopPF ()
+stop :: Plan i o a
+stop = F.liftF $ StopPF
 
 
 
@@ -98,16 +74,60 @@
               PlanT i o m r -> 
               ProcessA a (Event i) (Event o)
 
-constructT fit pl = ProcessA $ proc (ph, evx) ->
+constructT fit pl = ProcessA $ fit' $ F.runFT pl pure free
+  where
+    fit' ma = proc arg -> do { (evx, pa) <- fit ma -< (); modFit evx pa -<< arg }
+    
+    modFit :: ArrowApply a => Event c -> StepType a b (Event c) -> StepType a b (Event c)
+    modFit (Event x) stp = retArrow Feed (Event x) (ProcessA stp)
+    modFit _ stp = stp
+
+    retArrow ph' evx cont = arr $ \(ph, _) -> 
+        case ph of
+          Suspend -> 
+              (ph `mappend` Suspend, NoEvent, ProcessA $ retArrow ph' evx cont)
+          _ -> 
+              (ph `mappend` ph', evx, cont)
+
+    pure _ = return $ (End, retArrow Suspend End stopped)
+
+    free (AwaitPF f ff) =
+      do
+        return $ (NoEvent, arr (uncurry (awaitIt f ff)) >>> proc pc -> pc -<< ())
+
+    free (YieldPF y fc) = return $ (Event y, fit' fc)
+
+    free StopPF = return $ (End, retArrow Suspend End stopped)
+
+
+    awaitIt f _ Feed (Event x) = proc _ ->
+      do
+        (evy, stp) <- fit (f x) -< ()
+        returnA -< (Feed, evy, ProcessA stp)
+
+    awaitIt _ ff Feed End = proc _ ->
+      do
+        (evy, stp) <- fit ff -< ()
+        returnA -< (Feed, evy, ProcessA stp)
+
+    awaitIt _ ff Sweep End = proc _ ->
+      do
+        (evy, stp) <- fit ff -< ()
+        returnA -< (if isOccasion evy then Feed else Suspend, evy, ProcessA stp)
+
+    awaitIt f ff ph evx = proc _ ->
+        returnA -< (ph `mappend` Suspend, NoEvent, 
+                    ProcessA $ arr (uncurry (awaitIt f ff)) >>> proc pc -> pc -<< ())
+
+{-
+ProcessA $ proc (ph, evx) ->
   do
     probe ph pl -<< evx
     
-
   where
-
-    feedTo f = proc x ->
+    runAndYield fx = proc _ ->
       do
-        ff2 <- fit (F.runFreeT (f x)) -<< ()
+        ff2 <- fit (F.runFreeT fx) -<< ()
         oneYieldPF fit Feed ff2 -<< ()
 
     probe Suspend pl = proc _ ->
@@ -118,11 +138,16 @@
         pfr <- fit (F.runFreeT pl) -< ()
         go ph pfr -<< evx
 
-    go Feed (F.Free (AwaitPF f)) = arr (\evx -> ((), evx)) >>>
-        hEv' (arr snd >>> feedTo f) (arr $ const (Feed, NoEvent, constructT fit (await_ f))) (arr $ const (Feed, End, stopped))
+    go Feed (F.Free (AwaitPF f ff)) = arr (\evx -> ((), evx)) >>>
+        hEv' (proc (_, x) -> runAndYield (f x) -<< ()) 
+             (arr $ const (Feed, NoEvent, constructT fit (await_ f))) 
+             (proc _ -> runAndYield ff -<< ())
 
     go ph pfr = proc evx ->
-        oneYieldPF fit ph pfr -< ()
+      do
+        let action = case (evx, pfr) of {(End, F.Free (AwaitPF _ ff)) -> ff; _ -> F.FreeT $ return pfr}
+        pfr' <- fit (F.runFreeT action) -<< ()
+        oneYieldPF fit ph pfr' -<< ()
 
 
 oneYieldPF :: (Monad m, ArrowApply a) => 
@@ -139,7 +164,7 @@
 oneYieldPF f ph (F.Free (YieldPF x cont)) = proc _ ->
     returnA -< (Feed, Event x, constructT f cont)
 
-oneYieldPF f ph (F.Free (StopPF cont)) = proc _ ->
+oneYieldPF f ph (F.Free StopPF) = proc _ ->
     returnA -< (ph `mappend` Suspend, End, stopped)
 
 oneYieldPF f ph (F.Free pf) = proc _ ->
@@ -149,7 +174,7 @@
 
 oneYieldPF f ph (F.Pure x) = proc _ ->
     returnA -< (ph `mappend` Suspend, End, stopped)
-
+-}
 
 repeatedlyT :: (Monad m, ArrowApply a) => 
               (forall b. m b -> a () b) ->
diff --git a/src/Control/Arrow/Machine/Plan/Internal.hs b/src/Control/Arrow/Machine/Plan/Internal.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/Arrow/Machine/Plan/Internal.hs
@@ -0,0 +1,23 @@
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE GADTs #-}
+
+module
+    Control.Arrow.Machine.Plan.Internal
+where
+
+import qualified Control.Monad.Trans.Free as F
+import qualified Control.Monad.Trans.Free.Church as F
+
+data PlanF i o a where
+  AwaitPF :: (i->a) -> a -> PlanF i o a
+  YieldPF :: o -> a -> PlanF i o a
+  StopPF :: PlanF i o a
+
+instance (Functor (PlanF i o)) where
+  fmap g (AwaitPF f ff) = AwaitPF (g . f) (g ff)
+  fmap g (YieldPF x r) = YieldPF x (g r)
+  fmap g StopPF = StopPF
+
+
+type PlanT i o m a = F.FT (PlanF i o) m a
+type Plan i o a = forall m. Monad m => PlanT i o m a
diff --git a/src/Control/Arrow/Machine/Types.hs b/src/Control/Arrow/Machine/Types.hs
--- a/src/Control/Arrow/Machine/Types.hs
+++ b/src/Control/Arrow/Machine/Types.hs
@@ -1,6 +1,10 @@
 {-# LANGUAGE Arrows #-}
 {-# LANGUAGE RankNTypes #-}
 {-# LANGUAGE GADTs #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE UndecidableInstances #-}
+
 module
     Control.Arrow.Machine.Types
     -- This file includes internals. Export definitions is at ../Machine.hs
@@ -9,6 +13,8 @@
 import qualified Control.Category as Cat
 import Data.Monoid (Monoid(..))
 import Data.Profunctor (Profunctor, dimap)
+import Control.Arrow.Operations (ArrowReader(..))
+import Control.Arrow.Transformer.Reader (ReaderArrow, runReader, ArrowAddReader(..))
 import Control.Arrow
 
 
@@ -183,3 +189,37 @@
             returnA -< ((ph', y, loop pa'), d')
 
 
+instance
+    (ArrowApply a, ArrowReader r a) => 
+    ArrowReader r (ProcessA a)
+  where
+    readState = ProcessA $ proc (ph, dm) ->
+      do
+        r <- readState -< dm
+        returnA -< (ph `mappend` Suspend, r, readState)
+
+    newReader pa = ProcessA $ proc (ph, (e, r)) ->
+      do
+        (ph', y, pa') <- newReader (step pa) -< ((ph, e), r)
+        returnA -< (ph', y, newReader pa')
+
+instance
+    (ArrowApply a, ArrowApply a', ArrowAddReader r a a') =>
+    ArrowAddReader r (ProcessA a) (ProcessA a')
+  where
+    liftReader pa = ProcessA $ proc (ph, x) ->
+      do
+        (ph', y, pa') <- (| liftReader (step pa -< (ph, x)) |)
+        returnA -< (ph', y, liftReader pa)
+
+    elimReader pra = 
+        ProcessA $ arr pre >>> elimReader (step pra) >>> arr post
+      where
+        pre (ph, (x, r)) = ((ph, x), r)
+        post (ph, x, pra') = (ph, x, elimReader pra')
+{-
+    elimReader pra = ProcessA $ proc (ph, (x, r)) ->
+      do
+        (ph', y, pra') <- (| elimReader (step pra -< (ph, x)) |) r
+        returnA -< (ph', y, elimReader pra')
+-}
diff --git a/src/Control/Arrow/Machine/Utils.hs b/src/Control/Arrow/Machine/Utils.hs
--- a/src/Control/Arrow/Machine/Utils.hs
+++ b/src/Control/Arrow/Machine/Utils.hs
@@ -3,7 +3,7 @@
 {-# LANGUAGE RankNTypes #-}
 {-# LANGUAGE TypeSynonymInstances #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE GADTs #-}
+
 module
     Control.Arrow.Machine.Utils
       (
@@ -57,28 +57,32 @@
 import Control.Monad (liftM, forever)
 import Control.Monad.Trans
 import Control.Arrow
+import Control.Arrow.Transformer.Reader (ReaderArrow, runReader)
 import Control.Applicative
 import Debug.Trace
 
 import Control.Arrow.Machine.Types
 import Control.Arrow.Machine.Event
 import Control.Arrow.Machine.Event.Internal (Event(..))
+import Control.Arrow.Machine.ArrowUtil
 
 import qualified Control.Arrow.Machine.Plan as Pl
-
+import Control.Arrow.Machine.Exception
 
 
 
 delay ::
     (ArrowApply a, Occasional b) => ProcessA a b b
+
 delay = join >>> delayImpl >>> split
   where
     delayImpl = Pl.repeatedly $
       do
-        x <- Pl.await
+        mx <- liftM Just Pl.await `catch` return Nothing
         Pl.yield noEvent
-        Pl.yield x
+        maybe Pl.stop Pl.yield mx
 
+
 hold :: 
     ArrowApply a => b -> ProcessA a (Event b) b
 {-
@@ -120,28 +124,27 @@
 
 passRecent :: 
     (ArrowApply a, Occasional o) =>
-    ProcessA a e (Event b) ->
-    ProcessA a (e, b) o ->
-    ProcessA a e o
+    ProcessA a (AS e) (Event b) ->
+    ProcessA a (e, AS b) o ->
+    ProcessA a (AS e) o
 
-passRecent af ag = proc e ->
+passRecent af ag = proc ase ->
   do
-    evx <- af -< e
+    evx <- af -< ase
     mvx <- hold Nothing -< Just <$> evx
     case mvx of
-      Just x -> ag -< (e, x)
+      Just x -> ag -< (fromAS ase, toAS x)
       _ -> returnA -< noEvent
 
--- No use for banana brackets since ghc 7.8.1
 withRecent :: 
     (ArrowApply a, Occasional o) =>
-    ProcessA a (e, b) o ->
-    ProcessA a (e, Event b) o
-withRecent af = proc (e, evx) ->
+    ProcessA a (e, AS b) o ->
+    ProcessA a (e, AS (Event b)) o
+withRecent af = proc (e, asevx) ->
   do
-    mvx <- hold Nothing -< Just <$> evx
+    mvx <- hold Nothing -< Just <$> fromAS asevx
     case mvx of
-      Just x -> af -< (e, x)
+      Just x -> af -< (e, toAS x)
       _ -> returnA -< noEvent
 
 
@@ -151,15 +154,15 @@
 -- So be careful to make an infinite loop.
 feedback1 ::
     (ArrowApply a, Occasional d) =>
-    ProcessA a (e, d) (c, d) ->
-    ProcessA a e c
-feedback1 pa = ProcessA $ proc (ph, e) ->
+    ProcessA a (e, AS d) (c, d) ->
+    ProcessA a (AS e) c
+feedback1 pa = ProcessA $ proc (ph, ase) ->
   do
-    (ph', (y, d), pa') <- step pa -< (ph, (e, noEvent))
+    (ph', (y, d), pa') <- step pa -< (ph, (fromAS ase, toAS noEvent))
     returnA -< (ph', y, cont ph' d pa')
   where
     cont phPrev d paC 
-        | isOccasion d = ProcessA $ proc (ph, e) ->
+        | isOccasion d = ProcessA $ proc (ph, ase) ->
           do
             let 
               (dIn, dOut, phPv2, phCur) = 
@@ -169,13 +172,13 @@
                   else
                     (d, id, id, ph `mappend` Feed)
 
-            (ph', (y, d'), pa') <- step paC -< (phCur, (e, dIn))
+            (ph', (y, d'), pa') <- step paC -< (phCur, (fromAS ase, toAS dIn))
             returnA -< (ph', y, cont (phPv2 ph') (dOut d') pa')
 
-        | isEnd d && phPrev == Feed = ProcessA $ proc (ph, e) ->
+        | isEnd d && phPrev == Feed = ProcessA $ proc (ph, ase) ->
           do
-            (ph', (y, _), pa') <- step pa -< (ph, (e, end))
-            returnA -< (ph', y, proc x -> arr fst <<< pa' -< (x, end))
+            (ph', (y, _), pa') <- step paC -< (ph, (fromAS ase, toAS end))
+            returnA -< (ph', y, proc asx -> arr fst <<< pa' -< (fromAS asx, toAS end))
 
         | otherwise = feedback1 paC
 
@@ -184,14 +187,14 @@
 -- rather than banana brackets.
 feedback ::
     (ArrowApply a, Occasional d) =>
-    ProcessA a (e, d) b ->
-    ProcessA a (e, b) (c, d) ->
-    ProcessA a e c
+    ProcessA a (e, AS d) b ->
+    ProcessA a (e, AS b) (c, d) ->
+    ProcessA a (AS e) c
 feedback pa pb = 
-    feedback1 $ proc (e, x) -> 
+    feedback1 $ proc (ase, x) -> 
       do 
-        y <- pa -< (e, x)
-        pb -< (e, y)
+        y <- pa -< (ase, x)
+        pb -< (ase, toAS y)
 
 
 --
@@ -389,7 +392,6 @@
         (col c)
 
 rpSwitchB = rpSwitch broadcast
-
 
 --
 -- other utility arrow
diff --git a/test/spec.hs b/test/spec.hs
--- a/test/spec.hs
+++ b/test/spec.hs
@@ -324,7 +324,19 @@
             result = run (repeatedly pl) l
         result `shouldBe` [2, 3, 5, 6, 10, 11, 20, 21, 100, 101]
 
+    it "can handle the end with catch." $
+      do
+        let pl2 =
+              do
+                x <- await `catch` (yield 1 >> stop)
+                yield x
+                y <- await 
+                yield y
 
+        run (construct pl2) [] `shouldBe` [1]
+        run (construct pl2) [3] `shouldBe` [3]
+        run (construct pl2) [3, 2] `shouldBe` [3, 2]
+
 utility =
   do
     describe "delay" $
@@ -438,8 +450,6 @@
       do
         it "acts like local variable with hold." $
           do
-            pendingWith "Arrow statement with argument broken."
-{-
             let 
                 pa = proc evx ->
                   do
@@ -448,19 +458,16 @@
                       do
                         returnA -< ((+y) <$> evx, (y+1) <$ evx)
             run pa [1, 2, 3] `shouldBe` [11, 13, 15]
--}
+
         it "correctly handles stream end." $
           do
-            pendingWith "Arrow statement with argument broken."
-{-
             let 
                 pa = proc x -> 
-                    (\x -> returnA -< x)
+                    (\asx -> returnA -< asx)
                   `feedback` 
-                    (\y -> returnA -< (y::Event Int, x))
+                    (\asy -> returnA -< (asy::Event Int, x))
                 comp = mkProc (PgPush PgStop) >>> pa
             stateProc comp [0, 0] `shouldBe` ([], [0])
--}
 
         it "correctly handles stream end.(2)" $
           do