diff --git a/Data/ByteString/Char8/ExplicitIOModes.hs b/Data/ByteString/Char8/ExplicitIOModes.hs new file mode 100644 --- /dev/null +++ b/Data/ByteString/Char8/ExplicitIOModes.hs @@ -0,0 +1,85 @@ +{-# LANGUAGE UnicodeSyntax, NoImplicitPrelude #-} + +------------------------------------------------------------------------------- +-- | +-- Module : Data.ByteString.ExplicitIOModes +-- Copyright : (c) 2009 Bas van Dijk +-- License : BSD3 (see the file LICENSE) +-- Maintainer : Bas van Dijk +-- +-- This module lifts the bytestring IO operations to handles with explicit +-- IOModes. +-- +------------------------------------------------------------------------------- + +module Data.ByteString.Char8.ExplicitIOModes + ( hGetLine + , hGetContents + , hGet + , hGetNonBlocking + + , hPut + , hPutStr + , hPutStrLn + ) where + +------------------------------------------------------------------------------- +-- Imports +------------------------------------------------------------------------------- + +-- from base: +import Data.Int ( Int ) +import System.IO ( IO ) + +-- from bytestring: +import Data.ByteString.Char8 ( ByteString ) +import qualified Data.ByteString.Char8 as B ( hGetLine + , hGetContents + , hGet + , hGetNonBlocking + + , hPut + , hPutStr + , hPutStrLn + ) + +-- from ourselves: +import System.IO.ExplicitIOModes ( ReadModes, WriteModes ) +import System.IO.ExplicitIOModes.Internal ( Handle, wrap, wrap2 ) + + +------------------------------------------------------------------------------- +-- ByteString I/O with file handles with explicit IOModes +------------------------------------------------------------------------------- + +-- | Wraps @Data.ByteString.@'B.hGetLine'. +hGetLine ∷ ReadModes ioMode ⇒ Handle ioMode → IO ByteString +hGetLine = wrap B.hGetLine + +-- | Wraps @Data.ByteString.@'B.hGetContents'. +hGetContents ∷ ReadModes ioMode ⇒ Handle ioMode → IO ByteString +hGetContents = wrap B.hGetContents + +-- | Wraps @Data.ByteString.@'B.hGet'. +hGet ∷ ReadModes ioMode ⇒ Handle ioMode → Int → IO ByteString +hGet = wrap2 B.hGet + +-- | Wraps @Data.ByteString.@'B.hGetNonBlocking'. +hGetNonBlocking ∷ ReadModes ioMode ⇒ Handle ioMode → Int → IO ByteString +hGetNonBlocking = wrap2 B.hGetNonBlocking + + +-- | Wraps @Data.ByteString.@'B.hPut'. +hPut ∷ WriteModes ioMode ⇒ Handle ioMode → ByteString → IO () +hPut = wrap2 B.hPut + +-- | Wraps @Data.ByteString.@'B.hPutStr'. +hPutStr ∷ WriteModes ioMode ⇒ Handle ioMode → ByteString → IO () +hPutStr = wrap2 B.hPutStr + +-- | Wraps @Data.ByteString.@'B.hPutStrLn'. +hPutStrLn ∷ WriteModes ioMode ⇒ Handle ioMode → ByteString → IO () +hPutStrLn = wrap2 B.hPutStrLn + + +-- The End --------------------------------------------------------------------- diff --git a/Data/ByteString/ExplicitIOModes.hs b/Data/ByteString/ExplicitIOModes.hs new file mode 100644 --- /dev/null +++ b/Data/ByteString/ExplicitIOModes.hs @@ -0,0 +1,85 @@ +{-# LANGUAGE UnicodeSyntax, NoImplicitPrelude #-} + +------------------------------------------------------------------------------- +-- | +-- Module : Data.ByteString.ExplicitIOModes +-- Copyright : (c) 2009 Bas van Dijk +-- License : BSD3 (see the file LICENSE) +-- Maintainer : Bas van Dijk +-- +-- This module lifts the bytestring IO operations to handles with explicit +-- IOModes. +-- +------------------------------------------------------------------------------- + +module Data.ByteString.ExplicitIOModes + ( hGetLine + , hGetContents + , hGet + , hGetNonBlocking + + , hPut + , hPutStr + , hPutStrLn + ) where + +------------------------------------------------------------------------------- +-- Imports +------------------------------------------------------------------------------- + +-- from base: +import Data.Int ( Int ) +import System.IO ( IO ) + +-- from bytestring: +import Data.ByteString ( ByteString ) +import qualified Data.ByteString as B ( hGetLine + , hGetContents + , hGet + , hGetNonBlocking + + , hPut + , hPutStr + , hPutStrLn + ) + +-- from ourselves: +import System.IO.ExplicitIOModes ( ReadModes, WriteModes ) +import System.IO.ExplicitIOModes.Internal ( Handle, wrap, wrap2 ) + + +------------------------------------------------------------------------------- +-- ByteString I/O with file handles with explicit IOModes +------------------------------------------------------------------------------- + +-- | Wraps @Data.ByteString.@'B.hGetLine'. +hGetLine ∷ ReadModes ioMode ⇒ Handle ioMode → IO ByteString +hGetLine = wrap B.hGetLine + +-- | Wraps @Data.ByteString.@'B.hGetContents'. +hGetContents ∷ ReadModes ioMode ⇒ Handle ioMode → IO ByteString +hGetContents = wrap B.hGetContents + +-- | Wraps @Data.ByteString.@'B.hGet'. +hGet ∷ ReadModes ioMode ⇒ Handle ioMode → Int → IO ByteString +hGet = wrap2 B.hGet + +-- | Wraps @Data.ByteString.@'B.hGetNonBlocking'. +hGetNonBlocking ∷ ReadModes ioMode ⇒ Handle ioMode → Int → IO ByteString +hGetNonBlocking = wrap2 B.hGetNonBlocking + + +-- | Wraps @Data.ByteString.@'B.hPut'. +hPut ∷ WriteModes ioMode ⇒ Handle ioMode → ByteString → IO () +hPut = wrap2 B.hPut + +-- | Wraps @Data.ByteString.@'B.hPutStr'. +hPutStr ∷ WriteModes ioMode ⇒ Handle ioMode → ByteString → IO () +hPutStr = wrap2 B.hPutStr + +-- | Wraps @Data.ByteString.@'B.hPutStrLn'. +hPutStrLn ∷ WriteModes ioMode ⇒ Handle ioMode → ByteString → IO () +hPutStrLn = wrap2 B.hPutStrLn + + +-- The End --------------------------------------------------------------------- diff --git a/Data/ByteString/Lazy/Char8/ExplicitIOModes.hs b/Data/ByteString/Lazy/Char8/ExplicitIOModes.hs new file mode 100644 --- /dev/null +++ b/Data/ByteString/Lazy/Char8/ExplicitIOModes.hs @@ -0,0 +1,67 @@ +{-# LANGUAGE UnicodeSyntax, NoImplicitPrelude #-} + +------------------------------------------------------------------------------- +-- | +-- Module : Data.ByteString.ExplicitIOModes +-- Copyright : (c) 2009 Bas van Dijk +-- License : BSD3 (see the file LICENSE) +-- Maintainer : Bas van Dijk +-- +-- This module lifts the bytestring IO operations to handles with explicit +-- IOModes. +-- +------------------------------------------------------------------------------- + +module Data.ByteString.Lazy.Char8.ExplicitIOModes + ( hGetContents + , hGet + , hGetNonBlocking + + , hPut + ) where + +------------------------------------------------------------------------------- +-- Imports +------------------------------------------------------------------------------- + +-- from base: +import Data.Int ( Int ) +import System.IO ( IO ) + +-- from bytestring: +import Data.ByteString.Lazy.Char8 ( ByteString ) +import qualified Data.ByteString.Lazy.Char8 as B ( hGetContents + , hGet + , hGetNonBlocking + + , hPut + ) + +-- from ourselves: +import System.IO.ExplicitIOModes ( ReadModes, WriteModes ) +import System.IO.ExplicitIOModes.Internal ( Handle, wrap, wrap2 ) + + +------------------------------------------------------------------------------- +-- ByteString I/O with file handles with explicit IOModes +------------------------------------------------------------------------------- + +-- | Wraps @Data.ByteString.@'B.hGetContents'. +hGetContents ∷ ReadModes ioMode ⇒ Handle ioMode → IO ByteString +hGetContents = wrap B.hGetContents + +-- | Wraps @Data.ByteString.@'B.hGet'. +hGet ∷ ReadModes ioMode ⇒ Handle ioMode → Int → IO ByteString +hGet = wrap2 B.hGet + +-- | Wraps @Data.ByteString.@'B.hGetNonBlocking'. +hGetNonBlocking ∷ ReadModes ioMode ⇒ Handle ioMode → Int → IO ByteString +hGetNonBlocking = wrap2 B.hGetNonBlocking + + +-- | Wraps @Data.ByteString.@'B.hPut'. +hPut ∷ WriteModes ioMode ⇒ Handle ioMode → ByteString → IO () +hPut = wrap2 B.hPut + + +-- The End --------------------------------------------------------------------- diff --git a/Data/ByteString/Lazy/ExplicitIOModes.hs b/Data/ByteString/Lazy/ExplicitIOModes.hs new file mode 100644 --- /dev/null +++ b/Data/ByteString/Lazy/ExplicitIOModes.hs @@ -0,0 +1,73 @@ +{-# LANGUAGE UnicodeSyntax, NoImplicitPrelude #-} + +------------------------------------------------------------------------------- +-- | +-- Module : Data.ByteString.ExplicitIOModes +-- Copyright : (c) 2009 Bas van Dijk +-- License : BSD3 (see the file LICENSE) +-- Maintainer : Bas van Dijk +-- +-- This module lifts the bytestring IO operations to handles with explicit +-- IOModes. +-- +------------------------------------------------------------------------------- + +module Data.ByteString.Lazy.ExplicitIOModes + ( hGetContents + , hGet + , hGetNonBlocking + + , hPut + , hPutStr + ) where + +------------------------------------------------------------------------------- +-- Imports +------------------------------------------------------------------------------- + +-- from base: +import Data.Int ( Int ) +import System.IO ( IO ) + +-- from bytestring: +import Data.ByteString.Lazy ( ByteString ) +import qualified Data.ByteString.Lazy as B ( hGetContents + , hGet + , hGetNonBlocking + + , hPut + , hPutStr + ) + +-- from ourselves: +import System.IO.ExplicitIOModes ( ReadModes, WriteModes ) +import System.IO.ExplicitIOModes.Internal ( Handle, wrap, wrap2 ) + + +------------------------------------------------------------------------------- +-- ByteString I/O with file handles with explicit IOModes +------------------------------------------------------------------------------- + +-- | Wraps @Data.ByteString.@'B.hGetContents'. +hGetContents ∷ ReadModes ioMode ⇒ Handle ioMode → IO ByteString +hGetContents = wrap B.hGetContents + +-- | Wraps @Data.ByteString.@'B.hGet'. +hGet ∷ ReadModes ioMode ⇒ Handle ioMode → Int → IO ByteString +hGet = wrap2 B.hGet + +-- | Wraps @Data.ByteString.@'B.hGetNonBlocking'. +hGetNonBlocking ∷ ReadModes ioMode ⇒ Handle ioMode → Int → IO ByteString +hGetNonBlocking = wrap2 B.hGetNonBlocking + + +-- | Wraps @Data.ByteString.@'B.hPut'. +hPut ∷ WriteModes ioMode ⇒ Handle ioMode → ByteString → IO () +hPut = wrap2 B.hPut + +-- | Wraps @Data.ByteString.@'B.hPutStr'. +hPutStr ∷ WriteModes ioMode ⇒ Handle ioMode → ByteString → IO () +hPutStr = wrap2 B.hPutStr + + +-- The End --------------------------------------------------------------------- diff --git a/System/IO/ExplicitIOModes.hs b/System/IO/ExplicitIOModes.hs --- a/System/IO/ExplicitIOModes.hs +++ b/System/IO/ExplicitIOModes.hs @@ -1,11 +1,10 @@ -{-# LANGUAGE CPP #-} -{-# LANGUAGE NoImplicitPrelude #-} -{-# LANGUAGE UnicodeSyntax #-} -{-# LANGUAGE EmptyDataDecls #-} -{-# LANGUAGE GADTs #-} -{-# LANGUAGE ScopedTypeVariables #-} -{-# LANGUAGE GeneralizedNewtypeDeriving #-} -{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE CPP + , NoImplicitPrelude + , UnicodeSyntax + , EmptyDataDecls + , GADTs + , ScopedTypeVariables + #-} ------------------------------------------------------------------------------- -- | @@ -39,7 +38,6 @@ , SIO.FilePath , Handle - , regularHandle -- ** IO Modes @@ -218,7 +216,6 @@ import Data.Maybe ( Maybe(Nothing, Just) ) import Data.Int ( Int ) import Data.Char ( Char, String ) -import Data.Typeable ( Typeable ) import Text.Show ( Show, show ) import System.IO ( IO, FilePath ) @@ -231,20 +228,11 @@ -- from tagged: import Data.Tagged ( Tagged(Tagged), unTagged ) +-- from ourselves: +import System.IO.ExplicitIOModes.Internal ( Handle(Handle), wrap) --- * Files and handles --- | A handle to a file with an explicit IOMode. --- --- Wraps: @System.IO.@'SIO.Handle'. -newtype Handle ioMode = Handle - { -- | Retrieves the regular @System.IO.@'SIO.Handle'. - regularHandle ∷ SIO.Handle - } - deriving ( Show, Eq, Typeable ) - -wrap ∷ (SIO.Handle → α) → (Handle ioMode → α) -wrap f = f ∘ regularHandle +-- * Files and handles -- ** IO Modes diff --git a/System/IO/ExplicitIOModes/Internal.hs b/System/IO/ExplicitIOModes/Internal.hs new file mode 100644 --- /dev/null +++ b/System/IO/ExplicitIOModes/Internal.hs @@ -0,0 +1,24 @@ +{-# LANGUAGE NoImplicitPrelude, UnicodeSyntax, DeriveDataTypeable #-} + +module System.IO.ExplicitIOModes.Internal where + +-- from base: +import Text.Show ( Show ) +import Data.Eq ( Eq ) +import Data.Typeable ( Typeable ) +import qualified System.IO as SIO ( Handle ) + +-- | A handle to a file with an explicit IOMode. +-- +-- Wraps: @System.IO.@'SIO.Handle'. +newtype Handle ioMode = Handle + { -- | Retrieves the regular @System.IO.@'SIO.Handle'. + regularHandle ∷ SIO.Handle + } + deriving ( Show, Eq, Typeable ) + +wrap ∷ (SIO.Handle → α) → (Handle ioMode → α) +wrap f = \h → f (regularHandle h) + +wrap2 ∷ (SIO.Handle → β → α) → (Handle ioMode → β → α) +wrap2 f = \h y → f (regularHandle h) y diff --git a/explicit-iomodes.cabal b/explicit-iomodes.cabal --- a/explicit-iomodes.cabal +++ b/explicit-iomodes.cabal @@ -1,5 +1,5 @@ name: explicit-iomodes -version: 0.1.5 +version: 0.2 cabal-version: >=1.6 build-type: Simple license: BSD3 @@ -22,8 +22,16 @@ Location: http://code.haskell.org/~basvandijk/code/explicit-iomodes Library - GHC-Options: -O2 -Wall - build-depends: base >= 4 && < 4.3 + GHC-Options: -Wall + build-depends: base >= 4 && < 4.3 , base-unicode-symbols >= 0.1.1 && < 0.2 - , tagged == 0.0.* + , bytestring == 0.9.* + , tagged == 0.0.* exposed-modules: System.IO.ExplicitIOModes + + Data.ByteString.ExplicitIOModes + Data.ByteString.Char8.ExplicitIOModes + Data.ByteString.Lazy.ExplicitIOModes + Data.ByteString.Lazy.Char8.ExplicitIOModes + + other-modules: System.IO.ExplicitIOModes.Internal