empty :: Alternative f => f a
base Control.Applicative
empty :: Array
text Data.Text.Array
An empty immutable array.
empty :: BlockTable a
html Text.Html.BlockTable
empty :: ByteString
bytestring Data.ByteString, bytestring Data.ByteString.Char8, bytestring Data.ByteString.Lazy, bytestring Data.ByteString.Lazy.Char8
O(1) The empty ByteString
empty :: Doc
template-haskell Language.Haskell.TH.PprLib
An empty document
empty :: Doc
pretty Text.PrettyPrint.HughesPJ, pretty Text.PrettyPrint
The empty document, with no height and no width. empty is the identity for <>, <+>, $$ and $+$, and anywhere in the argument list for sep, hcat, hsep, vcat, fcat etc.
empty :: IntMap a
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
O(1). The empty map. > empty == fromList [] > size empty == 0
empty :: IntSet
containers Data.IntSet
O(1). The empty set.
empty :: Map k a
containers Data.Map.Lazy, containers Data.Map.Strict
O(1). The empty map. > empty == fromList [] > size empty == 0
empty :: Seq a
containers Data.Sequence
O(1). The empty sequence.
empty :: Set a
containers Data.Set
O(1). The empty set.
empty :: Text
text Data.Text.Internal, text Data.Text
O(1) The empty Text.
empty :: Text
text Data.Text.Lazy.Internal, text Data.Text.Lazy
Smart constructor for Empty.
empty :: Data a => a
syb Data.Generics.Builders
Construct the empty value for a datatype. For algebraic datatypes, the leftmost constructor is chosen.
empty :: Extract source => source
regex-base Text.Regex.Base.RegexLike
empty :: Graph gr => gr a b
fgl Data.Graph.Inductive.Graph
empty :: Ord a => Heap a b
fgl Data.Graph.Inductive.Internal.Heap
package empty
emptySampleVar :: SampleVar a -> IO ()
base Control.Concurrent.SampleVar
If the SampleVar is full, leave it empty. Otherwise, do nothing.
emptyAttr :: String -> HtmlAttr
html Text.Html, xhtml Text.XHtml.Strict, xhtml Text.XHtml.Frameset, xhtml Text.XHtml.Transitional
emptyB :: BoundedPrim a
bytestring Data.ByteString.Builder.Prim
The BoundedPrim that always results in the zero-length sequence.
emptyBuffer :: RawBuffer e -> Int -> BufferState -> Buffer e
base GHC.IO.Buffer
emptyDef :: LanguageDef st
parsec Text.Parsec.Language, parsec Text.ParserCombinators.Parsec.Language
emptyF :: FixedPrim a
bytestring Data.ByteString.Builder.Prim
The FixedPrim that always results in the zero-length sequence.
emptyFM :: Ord a => FiniteMap a b
fgl Data.Graph.Inductive.Internal.FiniteMap
emptyM :: GraphM m gr => m (gr a b)
fgl Data.Graph.Inductive.Monad
emptyN :: Int -> IO (SGr a b)
fgl Data.Graph.Inductive.Monad.IOArray
emptyPermissions :: Permissions
directory System.Directory
emptySignalSet :: SignalSet
unix System.Posix.Signals
emptyWriteBuffer :: BufferedIO dev => dev -> Buffer Word8 -> IO (Buffer Word8)
base GHC.IO.BufferedIO
Empty :: FiniteMap a b
fgl Data.Graph.Inductive.Internal.FiniteMap
Empty :: Heap a b
fgl Data.Graph.Inductive.Internal.Heap
Empty :: Text
text Data.Text.Lazy.Internal
Empty :: a -> Consumed a
parsec Text.Parsec.Prim
EmptyL :: ViewL a
containers Data.Sequence
empty sequence
EmptyR :: ViewR a
containers Data.Sequence
empty sequence
eNOTEMPTY :: Errno
base Foreign.C.Error
isEmptyChan :: Chan a -> IO Bool
base Control.Concurrent.Chan
Returns True if the supplied Chan is empty.
isEmptyMVar :: MVar a -> IO Bool
base Control.Concurrent.MVar
Check whether a given MVar is empty. Notice that the boolean value returned is just a snapshot of the state of the MVar. By the time you get to react on its result, the MVar may have been filled (or emptied) - so be extremely careful when using this operation. Use tryTakeMVar instead if possible.
isEmptySampleVar :: SampleVar a -> IO Bool
base Control.Concurrent.SampleVar
Returns True if the SampleVar is currently empty. Note that this function is only useful if you know that no other threads can be modifying the state of the SampleVar, because otherwise the state of the SampleVar may have changed by the time you see the result of isEmptySampleVar.
mempty :: Monoid a => a
base Data.Monoid
newEmptyMVar :: IO (MVar a)
base Control.Concurrent.MVar
Create an MVar which is initially empty.
newEmptySampleVar :: IO (SampleVar a)
base Control.Concurrent.SampleVar
Build a new, empty, SampleVar
buf_empty :: BufferOp a -> a
HTTP Network.BufferType
buf_isEmpty :: BufferOp a -> a -> Bool
HTTP Network.BufferType
getNonEmpty :: NonEmptyList a -> [a]
QuickCheck Test.QuickCheck.Modifiers, QuickCheck Test.QuickCheck
isEmpty :: Doc -> Bool
pretty Text.PrettyPrint.HughesPJ, pretty Text.PrettyPrint
Returns True if the document is empty
isEmpty :: Doc -> PprM Bool
template-haskell Language.Haskell.TH.PprLib
Returns True if the document is empty
isEmpty :: Graph gr => gr a b -> Bool
fgl Data.Graph.Inductive.Graph
isEmpty :: Ord a => Heap a b -> Bool
fgl Data.Graph.Inductive.Internal.Heap
isEmptyBuffer :: Buffer e -> Bool
base GHC.IO.Buffer
isEmptyFM :: FiniteMap a b -> Bool
fgl Data.Graph.Inductive.Internal.FiniteMap
isEmptyM :: GraphM m gr => m (gr a b) -> m Bool
fgl Data.Graph.Inductive.Monad
isEmptyTBQueue :: TBQueue a -> STM Bool
stm Control.Concurrent.STM.TBQueue
Returns True if the supplied TBQueue is empty.
isEmptyTChan :: TChan a -> STM Bool
stm Control.Concurrent.STM.TChan
Returns True if the supplied TChan is empty.
isEmptyTMVar :: TMVar a -> STM Bool
stm Control.Concurrent.STM.TMVar
Check whether a given TMVar is empty.
isEmptyTQueue :: TQueue a -> STM Bool
stm Control.Concurrent.STM.TQueue
Returns True if the supplied TQueue is empty.
newEmptyTMVar :: STM (TMVar a)
stm Control.Concurrent.STM.TMVar
Create a TMVar which is initially empty.
newEmptyTMVarIO :: IO (TMVar a)
stm Control.Concurrent.STM.TMVar
IO version of newEmptyTMVar. This is useful for creating top-level TMVars using unsafePerformIO, because using atomically inside unsafePerformIO isn't possible.
package non-empty
We provide the data type NonEmpty that allows to store a list-like structure with at least or exactly n elements, where n is fixed in the type in a kind of Peano encoding and is usually small. The datatype is intended to increase safety by making functions total that are partial on plain lists. E.g. on a non-empty list, head and tail are always defined. There are more such data types like Optional and Empty. Together with NonEmpty you can define a list type for every finite set of admissible list lengths. The datatype can be combined with Lists, Sequences and Sets (from the containers package). The package needs only Haskell 98. Similar packages: * semigroups, semigroupoids: restricted to lists, minimum number of elements: 1, provides more type classes tailored to the use of non-empty lists. * NonEmptyList: restricted to lists, minimum number of elements: 1 * NonEmpty: restricted to lists, minimum number of elements: 1, designed for unqualified use of identifiers * Cardinality:NeverEmptyList * http://www.haskell.org/haskellwiki/Non-empty_list Related packages: * Stream: Lists that contain always infinitely many elements. * fixed-list: Uses the same data structure as this package but is intended for fixing the number of elements in a list. Requires multi-parameter type classes with functional dependencies. Version 0.1.3

Show more results