Resolving dependencies...
Downloading arrowapply-utils-0.1...
Configuring arrowapply-utils-0.1...
Building arrowapply-utils-0.1...
Preprocessing library arrowapply-utils-0.1...
[1 of 1] Compiling Control.Arrow.ApplyUtils ( Control/Arrow/ApplyUtils.hs, dist/build/Control/Arrow/ApplyUtils.o )

Control/Arrow/ApplyUtils.hs:33:3:
    Overlapping instances for Monad (a ()) arising from a do statement
    Matching instances:
      instance ArrowApply a => Monad (a ())
        -- Defined at Control/Arrow/ApplyUtils.hs:13:10
      instance Monad ((->) r) -- Defined in ‘GHC.Base’
      instance Monad (GHC.ST.ST s) -- Defined in ‘GHC.ST’
      instance Monad (base:Control.Monad.ST.Lazy.Imp.ST s)
        -- Defined in ‘base:Control.Monad.ST.Lazy.Imp’
      instance Monad (Either e) -- Defined in ‘Data.Either’
    (The choice depends on the instantiation of ‘a’
     To pick the first instance above, use IncoherentInstances
     when compiling the other instance declarations)
    In a stmt of a 'do' block: p1 <- unmonadicA a1 v
    In the expression:
      do { p1 <- unmonadicA a1 v;
           p2 <- unmonadicA a2 v;
           return (f p1 p2) }
    In the second argument of ‘($)’, namely
      ‘\ v
         -> do { p1 <- unmonadicA a1 v;
                 p2 <- unmonadicA a2 v;
                 .... }’

Control/Arrow/ApplyUtils.hs:40:3:
    Overlapping instances for Monad (a ()) arising from a do statement
    Matching instances:
      instance ArrowApply a => Monad (a ())
        -- Defined at Control/Arrow/ApplyUtils.hs:13:10
      instance Monad ((->) r) -- Defined in ‘GHC.Base’
      instance Monad (GHC.ST.ST s) -- Defined in ‘GHC.ST’
      instance Monad (base:Control.Monad.ST.Lazy.Imp.ST s)
        -- Defined in ‘base:Control.Monad.ST.Lazy.Imp’
      instance Monad (Either e) -- Defined in ‘Data.Either’
    (The choice depends on the instantiation of ‘a’
     To pick the first instance above, use IncoherentInstances
     when compiling the other instance declarations)
    In a stmt of a 'do' block: p1 <- unmonadicA a1 v
    In the expression:
      do { p1 <- unmonadicA a1 v;
           p2 <- unmonadicA a2 v;
           p3 <- unmonadicA a3 v;
           return (f p1 p2 p3) }
    In the second argument of ‘($)’, namely
      ‘\ v
         -> do { p1 <- unmonadicA a1 v;
                 p2 <- unmonadicA a2 v;
                 .... }’

Control/Arrow/ApplyUtils.hs:48:3:
    Overlapping instances for Monad (a ()) arising from a do statement
    Matching instances:
      instance ArrowApply a => Monad (a ())
        -- Defined at Control/Arrow/ApplyUtils.hs:13:10
      instance Monad ((->) r) -- Defined in ‘GHC.Base’
      instance Monad (GHC.ST.ST s) -- Defined in ‘GHC.ST’
      instance Monad (base:Control.Monad.ST.Lazy.Imp.ST s)
        -- Defined in ‘base:Control.Monad.ST.Lazy.Imp’
      instance Monad (Either e) -- Defined in ‘Data.Either’
    (The choice depends on the instantiation of ‘a’
     To pick the first instance above, use IncoherentInstances
     when compiling the other instance declarations)
    In a stmt of a 'do' block: p1 <- unmonadicA a1 v
    In the expression:
      do { p1 <- unmonadicA a1 v;
           p2 <- unmonadicA a2 v;
           p3 <- unmonadicA a3 v;
           p4 <- unmonadicA a4 v;
           .... }
    In the second argument of ‘($)’, namely
      ‘\ v
         -> do { p1 <- unmonadicA a1 v;
                 p2 <- unmonadicA a2 v;
                 .... }’

Control/Arrow/ApplyUtils.hs:57:3:
    Overlapping instances for Monad (a ()) arising from a do statement
    Matching instances:
      instance ArrowApply a => Monad (a ())
        -- Defined at Control/Arrow/ApplyUtils.hs:13:10
      instance Monad ((->) r) -- Defined in ‘GHC.Base’
      instance Monad (GHC.ST.ST s) -- Defined in ‘GHC.ST’
      instance Monad (base:Control.Monad.ST.Lazy.Imp.ST s)
        -- Defined in ‘base:Control.Monad.ST.Lazy.Imp’
      instance Monad (Either e) -- Defined in ‘Data.Either’
    (The choice depends on the instantiation of ‘a’
     To pick the first instance above, use IncoherentInstances
     when compiling the other instance declarations)
    In a stmt of a 'do' block: p1 <- unmonadicA a1 v
    In the expression:
      do { p1 <- unmonadicA a1 v;
           p2 <- unmonadicA a2 v;
           p3 <- unmonadicA a3 v;
           p4 <- unmonadicA a4 v;
           .... }
    In the second argument of ‘($)’, namely
      ‘\ v
         -> do { p1 <- unmonadicA a1 v;
                 p2 <- unmonadicA a2 v;
                 .... }’

Control/Arrow/ApplyUtils.hs:67:3:
    Overlapping instances for Monad (a ()) arising from a do statement
    Matching instances:
      instance ArrowApply a => Monad (a ())
        -- Defined at Control/Arrow/ApplyUtils.hs:13:10
      instance Monad ((->) r) -- Defined in ‘GHC.Base’
      instance Monad (GHC.ST.ST s) -- Defined in ‘GHC.ST’
      instance Monad (base:Control.Monad.ST.Lazy.Imp.ST s)
        -- Defined in ‘base:Control.Monad.ST.Lazy.Imp’
      instance Monad (Either e) -- Defined in ‘Data.Either’
    (The choice depends on the instantiation of ‘a’
     To pick the first instance above, use IncoherentInstances
     when compiling the other instance declarations)
    In a stmt of a 'do' block: p1 <- unmonadicA a1 v
    In the expression:
      do { p1 <- unmonadicA a1 v;
           p2 <- unmonadicA a2 v;
           p3 <- unmonadicA a3 v;
           p4 <- unmonadicA a4 v;
           .... }
    In the second argument of ‘($)’, namely
      ‘\ v
         -> do { p1 <- unmonadicA a1 v;
                 p2 <- unmonadicA a2 v;
                 .... }’

Control/Arrow/ApplyUtils.hs:78:3:
    Overlapping instances for Monad (a ()) arising from a do statement
    Matching instances:
      instance ArrowApply a => Monad (a ())
        -- Defined at Control/Arrow/ApplyUtils.hs:13:10
      instance Monad ((->) r) -- Defined in ‘GHC.Base’
      instance Monad (GHC.ST.ST s) -- Defined in ‘GHC.ST’
      instance Monad (base:Control.Monad.ST.Lazy.Imp.ST s)
        -- Defined in ‘base:Control.Monad.ST.Lazy.Imp’
      instance Monad (Either e) -- Defined in ‘Data.Either’
    (The choice depends on the instantiation of ‘a’
     To pick the first instance above, use IncoherentInstances
     when compiling the other instance declarations)
    In a stmt of a 'do' block: p1 <- unmonadicA a1 v
    In the expression:
      do { p1 <- unmonadicA a1 v;
           p2 <- unmonadicA a2 v;
           p3 <- unmonadicA a3 v;
           p4 <- unmonadicA a4 v;
           .... }
    In the second argument of ‘($)’, namely
      ‘\ v
         -> do { p1 <- unmonadicA a1 v;
                 p2 <- unmonadicA a2 v;
                 .... }’

Control/Arrow/ApplyUtils.hs:90:3:
    Overlapping instances for Monad (a ()) arising from a do statement
    Matching instances:
      instance ArrowApply a => Monad (a ())
        -- Defined at Control/Arrow/ApplyUtils.hs:13:10
      instance Monad ((->) r) -- Defined in ‘GHC.Base’
      instance Monad (GHC.ST.ST s) -- Defined in ‘GHC.ST’
      instance Monad (base:Control.Monad.ST.Lazy.Imp.ST s)
        -- Defined in ‘base:Control.Monad.ST.Lazy.Imp’
      instance Monad (Either e) -- Defined in ‘Data.Either’
    (The choice depends on the instantiation of ‘a’
     To pick the first instance above, use IncoherentInstances
     when compiling the other instance declarations)
    In a stmt of a 'do' block: p1 <- unmonadicA a1 v
    In the expression:
      do { p1 <- unmonadicA a1 v;
           p2 <- unmonadicA a2 v;
           p3 <- unmonadicA a3 v;
           p4 <- unmonadicA a4 v;
           .... }
    In the second argument of ‘($)’, namely
      ‘\ v
         -> do { p1 <- unmonadicA a1 v;
                 p2 <- unmonadicA a2 v;
                 .... }’

Control/Arrow/ApplyUtils.hs:103:3:
    Overlapping instances for Monad (a ()) arising from a do statement
    Matching instances:
      instance ArrowApply a => Monad (a ())
        -- Defined at Control/Arrow/ApplyUtils.hs:13:10
      instance Monad ((->) r) -- Defined in ‘GHC.Base’
      instance Monad (GHC.ST.ST s) -- Defined in ‘GHC.ST’
      instance Monad (base:Control.Monad.ST.Lazy.Imp.ST s)
        -- Defined in ‘base:Control.Monad.ST.Lazy.Imp’
      instance Monad (Either e) -- Defined in ‘Data.Either’
    (The choice depends on the instantiation of ‘a’
     To pick the first instance above, use IncoherentInstances
     when compiling the other instance declarations)
    In a stmt of a 'do' block: p1 <- unmonadicA a1 v
    In the expression:
      do { p1 <- unmonadicA a1 v;
           p2 <- unmonadicA a2 v;
           p3 <- unmonadicA a3 v;
           p4 <- unmonadicA a4 v;
           .... }
    In the second argument of ‘($)’, namely
      ‘\ v
         -> do { p1 <- unmonadicA a1 v;
                 p2 <- unmonadicA a2 v;
                 .... }’
Failed to install arrowapply-utils-0.1
cabal: Error: some packages failed to install:
arrowapply-utils-0.1 failed during the building phase. The exception was:
ExitFailure 1