-- ------------------------------------------------------------

{- |
   Module     : Control.Arrow.ArrowIO
   Copyright  : Copyright (C) 2005 Uwe Schmidt
   License    : MIT

   Maintainer : Uwe Schmidt (uwe\@fh-wedel.de)
   Stability  : experimental
   Portability: portable

  Lifting of IO actions to arrows

-}

-- ------------------------------------------------------------

module Control.Arrow.ArrowIO
    ( ArrowIO(..)
    , ArrowIOIf(..)
    )
where

import Control.Arrow

-- | the interface for converting an IO action into an arrow

class Arrow a => ArrowIO a where

    -- | construct an arrow from an IO action
    arrIO               :: (b -> IO c) -> a b c

    -- | construct an arrow from an IO action without any parameter
    arrIO0              :: IO c -> a b c
    arrIO0 f            = arrIO (const f)
    {-# INLINE arrIO0 #-}

    -- | construction of a 2 argument arrow from a binary IO action
    -- |
    -- | example: @ a1 &&& a2 >>> arr2 f @

    arrIO2              :: (b1 -> b2 -> IO c) -> a (b1, b2) c
    arrIO2 f            = arrIO (\ ~(x1, x2) -> f x1 x2)
    {-# INLINE arrIO2 #-}

    -- | construction of a 3 argument arrow from a 3-ary IO action
    -- |
    -- | example: @ a1 &&& a2 &&& a3 >>> arr3 f @

    arrIO3              :: (b1 -> b2 -> b3 -> IO c) -> a (b1, (b2, b3)) c
    arrIO3 f            = arrIO (\ ~(x1, ~(x2, x3)) -> f x1 x2 x3)
    {-# INLINE arrIO3 #-}

    -- | construction of a 4 argument arrow from a 4-ary IO action
    -- |
    -- | example: @ a1 &&& a2 &&& a3 &&& a4 >>> arr4 f @

    arrIO4              :: (b1 -> b2 -> b3 -> b4 -> IO c) -> a (b1, (b2, (b3, b4))) c
    arrIO4 f            = arrIO (\ ~(x1, ~(x2, ~(x3, x4))) -> f x1 x2 x3 x4)
    {-# INLINE arrIO4 #-}


-- | the interface for converting an IO predicate into a list arrow

class (Arrow a, ArrowIO a) => ArrowIOIf a where

    -- | builds an arrow from an IO predicate
    --
    -- if the predicate holds, the single list containing the input is returned, else the empty list,
    -- similar to 'Control.Arrow.ArrowList.isA'

    isIOA               :: (b -> IO Bool) -> a b b

-- ------------------------------------------------------------
