lio 0.11.5.0 → 0.11.6.0

raw patch · 16 files changed

+441/−41 lines, 16 filesdep ~basePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: base

API changes (from Hackage documentation)

Files

• LIO/Concurrent/LChan/Trans.hs +50/−0
• LIO/Concurrent/LMVar/Trans.hs +100/−0
• LIO/Core.hs +9/−16
• LIO/Core/Trans.hs +73/−0
• LIO/DCLabel.hs +2/−3
• LIO/Error/Trans.hs +29/−0
• LIO/LIORef/Trans.hs +71/−0
• LIO/Label.hs +2/−6
• LIO/Labeled/Trans.hs +58/−0
• LIO/Monad.hs +19/−0
• LIO/TCB.hs +2/−2
• examples/channel.hs +8/−5
• examples/dclabel.hs +1/−0
• examples/gate.hs +1/−1
• examples/waitAndCatch.hs +3/−4
• lio.cabal +13/−4

@@ -0,0 +1,50 @@+{-# LANGUAGE Safe #-}++{- | 'MonadLIO' generalizations for "LIO.Concurrent.LChan". -}+module LIO.Concurrent.LChan.Trans (+    newLChan+  , newLChanP+  , writeLChan+  , writeLChanP+  , readLChan+  , readLChanP+  , dupLChan+  , dupLChanP+  ) where++import safe LIO.Core+import safe LIO.Label++import safe qualified LIO.Concurrent.LChan as C++-- | See 'LIO.Concurrent.LChan.newLChan'.+newLChan :: (MonadLIO l m, Label l) => l -> m (C.LChan l a)+newLChan = liftLIO . C.newLChan++-- | See 'LIO.Concurrent.LChan.newLChanP'.+newLChanP :: (MonadLIO l m, PrivDesc l p) => Priv p -> l -> m (C.LChan l a)+newLChanP p = liftLIO . C.newLChanP p++-- | See 'LIO.Concurrent.LChan.writeLChan'.+writeLChan :: (MonadLIO l m, Label l) => C.LChan l a -> a -> m ()+writeLChan c = liftLIO . C.writeLChan c++-- | See 'LIO.Concurrent.LChan.writeLChanP'.+writeLChanP :: (MonadLIO l m, PrivDesc l p) => Priv p -> C.LChan l a -> a -> m ()+writeLChanP p c = liftLIO . C.writeLChanP p c++-- | See 'LIO.Concurrent.LChan.readLChan'.+readLChan :: (MonadLIO l m, Label l) => C.LChan l a -> m a+readLChan = liftLIO . C.readLChan++-- | See 'LIO.Concurrent.LChan.readLChanP'.+readLChanP :: (MonadLIO l m, PrivDesc l p) => Priv p -> C.LChan l a -> m a+readLChanP p = liftLIO . C.readLChanP p++-- | See 'LIO.Concurrent.LChan.dupLChan'.+dupLChan :: (MonadLIO l m, Label l) => C.LChan l a -> m (C.LChan l a)+dupLChan = liftLIO . C.dupLChan++-- | See 'LIO.Concurrent.LChan.dupLChanP'.+dupLChanP :: (MonadLIO l m, PrivDesc l p) => Priv p -> C.LChan l a -> m (C.LChan l a)+dupLChanP p = liftLIO . C.dupLChanP p

@@ -0,0 +1,100 @@+{-# LANGUAGE Safe #-}++{- | 'MonadLIO' generalizations for "LIO.Concurrent.LMVar". -}+module LIO.Concurrent.LMVar.Trans+  ( newEmptyLMVar+  , newEmptyLMVarP+  , newLMVar+  , newLMVarP+  , takeLMVar+  , takeLMVarP+  , tryTakeLMVar+  , tryTakeLMVarP+  , putLMVar+  , putLMVarP+  , tryPutLMVar+  , tryPutLMVarP+  , readLMVar+  , readLMVarP+  , swapLMVar+  , swapLMVarP+  , isEmptyLMVar+  , isEmptyLMVarP+  ) where++import safe LIO.Core+import safe LIO.Label++import safe qualified LIO.Concurrent.LMVar as M++-- | See 'LIO.Concurrent.LMVar.newEmptyLMVar'.+newEmptyLMVar :: (MonadLIO l m, Label l) => l -> m (M.LMVar l a)+newEmptyLMVar = liftLIO . M.newEmptyLMVar++-- | See 'LIO.Concurrent.LMVar.newEmptyLMVarP'.+newEmptyLMVarP :: (MonadLIO l m, PrivDesc l p) => Priv p -> l -> m (M.LMVar l a)+newEmptyLMVarP p = liftLIO . M.newEmptyLMVarP p++-- | See 'LIO.Concurrent.LMVar.newLMVar'.+newLMVar :: (MonadLIO l m, Label l) => l -> a -> m (M.LMVar l a)+newLMVar l = liftLIO . M.newLMVar l++-- | See 'LIO.Concurrent.LMVar.newLMVarP'.+newLMVarP :: (MonadLIO l m, PrivDesc l p) => Priv p -> l -> a -> m (M.LMVar l a)+newLMVarP p l = liftLIO . M.newLMVarP p l++-- | See 'LIO.Concurrent.LMVar.takeLMVar'.+takeLMVar :: (MonadLIO l m, Label l) => M.LMVar l a -> m a+takeLMVar = liftLIO . M.takeLMVar++-- | See 'LIO.Concurrent.LMVar.takeLMVarP'.+takeLMVarP :: (MonadLIO l m, PrivDesc l p) => Priv p -> M.LMVar l a -> m a+takeLMVarP p = liftLIO . M.takeLMVarP p++-- | See 'LIO.Concurrent.LMVar.tryTakeLMVar'.+tryTakeLMVar :: (MonadLIO l m, Label l) => M.LMVar l a -> m (Maybe a)+tryTakeLMVar = liftLIO . M.tryTakeLMVar++-- | See 'LIO.Concurrent.LMVar.tryTakeLMVarP'.+tryTakeLMVarP :: (MonadLIO l m, PrivDesc l p) => Priv p -> M.LMVar l a -> m (Maybe a)+tryTakeLMVarP p = liftLIO . M.tryTakeLMVarP p++-- | See 'LIO.Concurrent.LMVar.putLMVar'.+putLMVar :: (MonadLIO l m, Label l) => M.LMVar l a -> a -> m ()+putLMVar mvar = liftLIO . M.putLMVar mvar++-- | See 'LIO.Concurrent.LMVar.putLMVarP'.+putLMVarP :: (MonadLIO l m, PrivDesc l p) => Priv p -> M.LMVar l a -> a -> m ()+putLMVarP p mvar = liftLIO . M.putLMVarP p mvar++-- | See 'LIO.Concurrent.LMVar.tryPutLMVar'.+tryPutLMVar :: (MonadLIO l m, Label l) => M.LMVar l a -> a -> m Bool+tryPutLMVar mvar = liftLIO . M.tryPutLMVar mvar++-- | See 'LIO.Concurrent.LMVar.tryPutLMVarP'.+tryPutLMVarP :: (MonadLIO l m, PrivDesc l p) => Priv p -> M.LMVar l a -> a -> m Bool+tryPutLMVarP p mvar = liftLIO . M.tryPutLMVarP p mvar++-- | See 'LIO.Concurrent.LMVar.readLMVar'.+readLMVar :: (MonadLIO l m, Label l) => M.LMVar l a -> m a+readLMVar = liftLIO . M.readLMVar++-- | See 'LIO.Concurrent.LMVar.readLMVarP'.+readLMVarP :: (MonadLIO l m, PrivDesc l p) => Priv p -> M.LMVar l a -> m a+readLMVarP p = liftLIO . M.readLMVarP p++-- | See 'LIO.Concurrent.LMVar.swapLMVar'.+swapLMVar :: (MonadLIO l m, Label l) => M.LMVar l a -> a -> m a+swapLMVar mvar = liftLIO . M.swapLMVar mvar++-- | See 'LIO.Concurrent.LMVar.swapLMVarP'.+swapLMVarP :: (MonadLIO l m, PrivDesc l p) => Priv p -> M.LMVar l a -> a -> m a+swapLMVarP p mvar = liftLIO . M.swapLMVarP p mvar++-- | See 'LIO.Concurrent.LMVar.isEmptyLMVar'.+isEmptyLMVar :: (MonadLIO l m, Label l) => M.LMVar l a -> m Bool+isEmptyLMVar = liftLIO . M.isEmptyLMVar++-- | See 'LIO.Concurrent.LMVar.isEmptyLMVarP'.+isEmptyLMVarP :: (MonadLIO l m, PrivDesc l p) => Priv p -> M.LMVar l a -> m Bool+isEmptyLMVarP p = liftLIO . M.isEmptyLMVarP p

@@ -41,7 +41,7 @@ label to ensure that @l_r ``canFlowTo`` l_cur@.  This is acomplished using a function such as 'taint'. -The second purpose of the current label is to prevent inforation leaks+The second purpose of the current label is to prevent information leaks into public channels. Specifically, it is only permissible to modify or write to data labeled @l_w@ when @l_cur``canFlowTo`` l_w@. Thus, the following attempt to leak the @val@ after reading it from a secret@@ -91,6 +91,7 @@ import safe LIO.Error import safe LIO.Exception import safe LIO.Label+import safe LIO.Monad(MonadLIO(..)) import safe LIO.Run import LIO.TCB @@ -316,8 +317,13 @@ -- -- > guardWrite l = guardAlloc l >> taint l ----- This guarantees that @l@ ``canFlowTo`` the current label (and--- clearance), and that the current label ``canFlowTo`` @l@.+-- The 'guardAlloc' ensures that we can write(-only) to the object+-- labeled @l@, i.e., the current label ``canFlowTo`` @l@ (and @l@+-- ``canFlowTo`` the current clearance). If this check succeeds then+-- we raise the current label with 'taint' to reflect the fact that+-- this is a also a read effect. Note that if the write-only guard+-- succeeds, the 'taint' will always suceed (we're simply raising the+-- current label to a label that is below the clearance). -- guardWrite :: Label l => l -> LIO l () guardWrite newl = withContext "guardWrite" $ do@@ -330,16 +336,3 @@ guardWriteP p newl = withContext "guardWriteP" $ do   guardAllocP p newl   taintP p newl------- Monad base------- | Synonym for monad in which 'LIO' is the base monad.-class (Label l, Monad m) => MonadLIO l m | m -> l where-  -- | Lift an 'LIO' computation.-  liftLIO :: LIO l a -> m a--instance Label l => MonadLIO l (LIO l) where-  liftLIO = id-

@@ -0,0 +1,73 @@+{-# LANGUAGE Safe #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE FunctionalDependencies #-}+{-# LANGUAGE FlexibleInstances #-}++{- | 'MonadLIO' generalizations for "LIO.Core". -}+module LIO.Core.Trans (+    getLabel+  , setLabel+  , setLabelP+  , getClearance+  , setClearance+  , setClearanceP+  , guardAlloc+  , guardAllocP+  , taint+  , taintP+  , guardWrite+  , guardWriteP+  ) where++import safe LIO.Label+import safe LIO.Monad++import safe qualified LIO.Core as C++-- | See 'LIO.Core.getLabel'.+getLabel :: (MonadLIO l m, Label l) => m l+getLabel = liftLIO C.getLabel++-- | See 'LIO.Core.setLabel'.+setLabel :: (MonadLIO l m, Label l) => l -> m ()+setLabel = liftLIO . C.setLabel++-- | See 'LIO.Core.setLabelP'.+setLabelP :: (MonadLIO l m, PrivDesc l p) => Priv p -> l -> m ()+setLabelP p = liftLIO . C.setLabelP p++-- | See 'LIO.Core.getClearance'.+getClearance :: (MonadLIO l m, Label l) => m l+getClearance = liftLIO C.getClearance++-- | See 'LIO.Core.setClearance'.+setClearance :: (MonadLIO l m, Label l) => l -> m ()+setClearance = liftLIO . C.setClearance++-- | See 'LIO.Core.setClearanceP'.+setClearanceP :: (MonadLIO l m, PrivDesc l p) => Priv p -> l -> m ()+setClearanceP p = liftLIO . C.setClearanceP p++-- | See 'LIO.Core.guardAlloc'.+guardAlloc :: (MonadLIO l m, Label l) => l -> m ()+guardAlloc = liftLIO . C.guardAlloc++-- | See 'LIO.Core.guardAllocP'.+guardAllocP :: (MonadLIO l m, PrivDesc l p) => Priv p -> l -> m ()+guardAllocP p = liftLIO . C.guardAllocP p++-- | See 'LIO.Core.taint'.+taint :: (MonadLIO l m, Label l) => l -> m ()+taint = liftLIO . C.taint++-- | See 'LIO.Core.taintP'.+taintP :: (MonadLIO l m, PrivDesc l p) => Priv p -> l -> m ()+taintP p = liftLIO . C.taintP p++-- | See 'LIO.Core.guardWrite'.+guardWrite :: (MonadLIO l m, Label l) => l -> m ()+guardWrite = liftLIO . C.guardWrite++-- | See 'LIO.Core.guardWriteP'.+guardWriteP :: (MonadLIO l m, PrivDesc l p) => Priv p -> l -> m ()+guardWriteP p = liftLIO . C.guardWriteP p

@@ -1,4 +1,4 @@-{-# LANGUAGE Trustworthy #-}+{-# LANGUAGE Safe #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-}@@ -110,13 +110,12 @@   , cTrue, cFalse, cToSet, cFromList   ) where -import safe Control.Applicative import safe Control.Monad import safe Data.Bits import safe qualified Data.ByteString as S import Data.Hashable import safe Data.List-import safe Data.Monoid+import safe Data.Monoid () import safe Data.Set (Set) import safe qualified Data.Set as Set import safe Data.String

@@ -0,0 +1,29 @@+{-# LANGUAGE Safe #-}+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE ExistentialQuantification #-}++{- | 'MonadLIO' generalizations for "LIO.Error". -}+module LIO.Error.Trans (+    labelError+  , labelErrorP+  ) where++import safe LIO.Label+import safe LIO.Monad++import safe qualified LIO.Error as E++-- | See 'LIO.Error.labelError'.+labelError :: (MonadLIO l m, Label l)+    => String -- ^ Function that failed.+    -> [l]    -- ^ Labels involved in error.+    -> m a+labelError fl = liftLIO . E.labelError fl++-- | See 'LIO.Error.labelErrorP'.+labelErrorP :: (MonadLIO l m, Label l, PrivDesc l p)+    => String  -- ^ Function that failed.+    -> Priv p  -- ^ Privileges involved.+    -> [l]     -- ^ Labels involved.+    -> m a+labelErrorP fl p = liftLIO . E.labelErrorP fl p

@@ -0,0 +1,71 @@+{-# LANGUAGE Safe #-}+{-# LANGUAGE ConstraintKinds,+             FlexibleContexts #-}++{- | 'MonadLIO' generalizations for "LIO.LIORef". -}+module LIO.LIORef.Trans (+    newLIORef+  , newLIORefP+  , readLIORef+  , readLIORefP+  , writeLIORef+  , writeLIORefP+  , modifyLIORef+  , modifyLIORefP+  , atomicModifyLIORef+  , atomicModifyLIORefP+  ) where++import safe LIO.Core+import safe LIO.Label++import safe LIO.LIORef (LIORef)+import safe qualified LIO.LIORef as R++-- | See 'LIO.LIORef.newLIORef'.+newLIORef :: (MonadLIO l m, Label l)+          => l                  -- ^ Label of reference+          -> a                  -- ^ Initial value+          -> m (LIORef l a) -- ^ Mutable reference+newLIORef l = liftLIO . R.newLIORef l++-- | See 'LIO.LIORef.newLIORefP'.+newLIORefP :: (MonadLIO l m, PrivDesc l p) => Priv p -> l -> a -> m (LIORef l a)+newLIORefP p l = liftLIO . R.newLIORefP p l++-- | See 'LIO.LIORef.readLIORef'.+readLIORef :: (MonadLIO l m, Label l) => LIORef l a -> m a+readLIORef = liftLIO . R.readLIORef++-- | See 'LIO.LIORef.readLIORefP'.+readLIORefP :: (MonadLIO l m, PrivDesc l p) => Priv p -> LIORef l a -> m a+readLIORefP priv = liftLIO . R.readLIORefP priv++-- | See 'LIO.LIORef.writeLIORef'.+writeLIORef :: (MonadLIO l m, Label l) => LIORef l a -> a -> m ()+writeLIORef ref = liftLIO . R.writeLIORef ref++-- | See 'LIO.LIORef.writeLIORefP'.+writeLIORefP :: (MonadLIO l m, PrivDesc l p) => Priv p -> LIORef l a -> a -> m ()+writeLIORefP priv ref = liftLIO . R.writeLIORefP priv ref++-- | See 'LIO.LIORef.modifyLIORef'.+modifyLIORef :: (MonadLIO l m, Label l)+             => LIORef l a             -- ^ Labeled reference+             -> (a -> a)               -- ^ Modifier+             -> m ()+modifyLIORef ref = liftLIO . R.modifyLIORef ref++-- | See 'LIO.LIORef.modifyLIORefP'.+modifyLIORefP :: (MonadLIO l m, PrivDesc l p)+              =>  Priv p -> LIORef l a -> (a -> a) -> m ()+modifyLIORefP priv ref = liftLIO . R.modifyLIORefP priv ref++-- | See 'LIO.LIORef.atomicModifyLIORef'.+atomicModifyLIORef :: (MonadLIO l m, Label l) => LIORef l a -> (a -> (a, b)) -> m b+atomicModifyLIORef ref = liftLIO . R.atomicModifyLIORef ref++-- | See 'LIO.LIORef.atomicModifyLIORefP'.+atomicModifyLIORefP :: (MonadLIO l m, PrivDesc l p)+                    => Priv p -> LIORef l a -> (a -> (a, b)) -> m b+atomicModifyLIORefP priv ref = liftLIO . R.atomicModifyLIORefP priv ref

@@ -18,7 +18,7 @@   , NoPrivs(..), noPrivs   ) where -import safe Data.Monoid+import safe Data.Monoid () import safe Data.Typeable  import LIO.TCB@@ -46,7 +46,7 @@ with current label @lcur@ observes data labeled @l1@, it must hold that @l1 ``canFlowTo`` lcur@.  If the thread is later permitted to modify an object labeled @l2@, it must hold that @lcur ``canFlowTo``-l2@.  By transitifity of the ``canFlowTo`` relation, it holds that @l1+l2@.  By transitivity of the ``canFlowTo`` relation, it holds that @l1 ``canFlowTo`` l2@.  -}@@ -221,10 +221,6 @@     -- Less formally, @downgradeP p l@ returns a label representing     -- the furthest you can downgrade data labeled @l@ given     -- privileges described by @p@.-    ---    -- Yet another way to view this function is that @downgradeP p l@-    -- returns the greatest lower bound (under 'canFlowTo') of the set-    -- of all labels @l'@ such that @'canFlowToP' p l' l@.     downgradeP :: p     -- ^ Privilege description                   -> l  -- ^ Label to downgrade                   -> l  -- ^ Lowest label equivelent to input

@@ -0,0 +1,58 @@+{-# LANGUAGE Trustworthy #-}++{- | 'MonadLIO' generalizations for "LIO.Labeled". -}+module LIO.Labeled.Trans (+    label+  , labelP+  , unlabel+  , unlabelP+  , relabelLabeledP+  , taintLabeled+  , taintLabeledP+  , lFmap+  , lAp+  ) where++import safe LIO.Label+import safe LIO.Core+import LIO.TCB++import safe qualified LIO.Labeled as L++-- | See 'LIO.Labeled.label'.+label :: (MonadLIO l m, Label l) => l -> a -> m (Labeled l a)+label l = liftLIO . L.label l++-- | See 'LIO.Labeled.labelP'.+labelP :: (MonadLIO l m, PrivDesc l p) => Priv p -> l -> a -> m (Labeled l a)+labelP p l = liftLIO . L.labelP p l++-- | See 'LIO.Labeled.unlabel'.+unlabel :: (MonadLIO l m, Label l) => Labeled l a -> m a+unlabel = liftLIO . L.unlabel++-- | See 'LIO.Labeled.unlabelP'.+unlabelP :: (MonadLIO l m, PrivDesc l p) => Priv p -> Labeled l a -> m a+unlabelP p = liftLIO . L.unlabelP p++-- | See 'LIO.Labeled.relabelLabeledP'.+relabelLabeledP :: (MonadLIO l m, PrivDesc l p)+                => Priv p -> l -> Labeled l a -> m (Labeled l a)+relabelLabeledP p newl = liftLIO . L.relabelLabeledP p newl++-- | See 'LIO.Labeled.taintLabeled'.+taintLabeled :: (MonadLIO l m, Label l) => l -> Labeled l a -> m (Labeled l a)+taintLabeled l = liftLIO . L.taintLabeled l++-- | See 'LIO.Labeled.taintLabeledP'.+taintLabeledP :: (MonadLIO l m, PrivDesc l p)+              => Priv p -> l -> Labeled l a -> m (Labeled l a)+taintLabeledP p l = liftLIO . L.taintLabeledP p l++-- | See 'LIO.Labeled.lFmap'.+lFmap :: (MonadLIO l m, Label l) => Labeled l a -> (a -> b) -> m (Labeled l b)+lFmap l = liftLIO . L.lFmap l++-- | See 'LIO.Labeled.lAp'.+lAp :: (MonadLIO l m, Label l) => Labeled l (a -> b) -> Labeled l a -> m (Labeled l b)+lAp lf = liftLIO . L.lAp lf

@@ -0,0 +1,19 @@+{-# LANGUAGE Trustworthy #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE FunctionalDependencies #-}+{-# LANGUAGE FlexibleInstances #-}++module LIO.Monad (+    MonadLIO(..)+  ) where++import safe LIO.Label+import LIO.TCB++-- | Synonym for monad in which 'LIO' is the base monad.+class (Label l, Monad m) => MonadLIO l m | m -> l where+  -- | Lift an 'LIO' computation.+  liftLIO :: LIO l a -> m a++instance Label l => MonadLIO l (LIO l) where+  liftLIO = id

@@ -34,11 +34,11 @@   , LabeledResult(..), LResStatus(..)   ) where -import safe Control.Applicative+import safe Control.Applicative () import safe Control.Exception (Exception(..), SomeException(..)) import safe qualified Control.Concurrent as IO import safe Control.Monad-import safe Data.Monoid+import safe Data.Monoid () import safe Data.IORef import safe Data.Typeable 

@@ -9,15 +9,18 @@  import LIO.TCB (ioTCB) +main :: IO () main = evalDC $ do-  log <- newLChan ("Logger" %% True)+  logger <- newLChan ("Logger" %% True)   forkLIO $ forever $ do-    msg  <- readLChan log+    msg  <- readLChan logger     lcur <- getLabel     ioTCB $ putStrLn $ show lcur ++ " > " ++ msg   forkLIO $ do-    writeLChan log "in them alternate threads"+    writeLChan logger "in them alternate threads"   forkLIO $ do     taint ("Alice" %% True)-    writeLChan log "i has failed"-  forM_ [1..10] $ \i -> writeLChan log $ "yo "++ show  i+    writeLChan logger "i has failed"+  forM_ oneToTen $ \i -> writeLChan logger $ "yo "++ show  i+    where oneToTen :: [Int]+          oneToTen = [1..10]

@@ -24,6 +24,7 @@ p :: DCPriv p = PrivTCB  $ "Alice" /\ "Carla" +main :: IO () main = do   putStrLn $ "Label 1: " ++ show l1   putStrLn $ "Label 2: " ++ show l2

@@ -1,5 +1,4 @@ import LIO-import LIO.Delegate import LIO.DCLabel  import LIO.TCB@@ -18,6 +17,7 @@ bob   = PrivTCB . toCNF $ "Bob" clark = PrivTCB . toCNF $ "Clark" +main :: IO () main = putStrLn . show $    [ callGate addGate alice 1 2 -- Just 3   , callGate addGate bob   3 4 -- Just 7

@@ -2,19 +2,18 @@  module Main (main) where -import Prelude hiding (catch)+import Prelude import LIO import LIO.TCB (ioTCB) import LIO.DCLabel import LIO.Concurrent-import Control.Exception (SomeException)  -l,m,h :: DCLabel+l,m :: DCLabel l = "A" \/ "B" %% True m = "M" %% True-h = "A" /\ "B" %% True +main :: IO () main =  do   lr <- evalDC $ do     lb <- label m (6 :: Int)

@@ -1,13 +1,15 @@ Name:           lio-Version:        0.11.5.0+Version:        0.11.6.0 Cabal-Version:  >= 1.8 Build-type:     Simple License:        GPL License-File:   LICENSE Author:         Hails team-Maintainer:	Hails team <hails at scs dot stanford dot edu>+Maintainer:     Deian Stefan <deian at cs dot ucsd dot edu> Synopsis:       Labeled IO Information Flow Control Library Category:       Security+Homepage:       https://github.com/plsyssec/lio+Bug-Reports:    https://github.com/plsyssec/lio/issues Description:    The /Labeled IO/ (LIO) library is an information flow control (IFC)@@ -60,11 +62,11 @@  Source-repository head   Type:     git-  Location: git://github.com/scslab/lio.git+  Location: https://github.com/PLSysSec/lio.git  Library   Build-Depends:-    base          >= 4.5     && < 5.0+    base          >= 4.5     && < 6.0    ,containers    ,bytestring    >= 0.10    ,hashable      >= 1.2@@ -80,18 +82,25 @@     LIO.Label     -- * Core library     LIO.Core+    LIO.Core.Trans+    LIO.Monad     LIO.Error+    LIO.Error.Trans     LIO.Exception     -- * Labeled values     LIO.Labeled+    LIO.Labeled.Trans     -- * Labeled IORefs     LIO.LIORef+    LIO.LIORef.Trans     -- * LIO privileges     LIO.Delegate     -- * Concurrency     LIO.Concurrent     LIO.Concurrent.LMVar+    LIO.Concurrent.LMVar.Trans     LIO.Concurrent.LChan+    LIO.Concurrent.LChan.Trans     -- * DCLabels     LIO.DCLabel     -- * Privileged internals