take -text -containers

take :: Int -> [a] -> [a]
base Prelude, base Data.List
take n, applied to a list xs, returns the prefix of xs of length n, or xs itself if n > length xs: > take 5 "Hello World!" == "Hello" > take 3 [1,2,3,4,5] == [1,2,3] > take 3 [1,2] == [1,2] > take 3 [] == [] > take (-1) [1,2] == [] > take 0 [1,2] == [] It is an instance of the more general Data.List.genericTake, in which n may be of any integral type.
take :: Int -> ByteString -> ByteString
bytestring Data.ByteString, bytestring Data.ByteString.Char8
O(1) take n, applied to a ByteString xs, returns the prefix of xs of length n, or xs itself if n > length xs.
take :: Int64 -> ByteString -> ByteString
bytestring Data.ByteString.Lazy, bytestring Data.ByteString.Lazy.Char8
O(n\c)/ take n, applied to a ByteString xs, returns the prefix of xs of length n, or xs itself if n > length xs.
takeWhile :: (a -> Bool) -> [a] -> [a]
base Prelude, base Data.List
takeWhile, applied to a predicate p and a list xs, returns the longest prefix (possibly empty) of xs of elements that satisfy p: > takeWhile (< 3) [1,2,3,4,1,2,3,4] == [1,2] > takeWhile (< 9) [1,2,3] == [1,2,3] > takeWhile (< 0) [1,2,3] == []
takeMVar :: MVar a -> IO a
base Control.Concurrent.MVar
Return the contents of the MVar. If the MVar is currently empty, takeMVar will wait until it is full. After a takeMVar, the MVar is left empty. There are two further important properties of takeMVar: * takeMVar is single-wakeup. That is, if there are multiple threads blocked in takeMVar, and the MVar becomes full, only one thread will be woken up. The runtime guarantees that the woken thread completes its takeMVar operation. * When multiple threads are blocked on an MVar, they are woken up in FIFO order. This is useful for providing fairness properties of abstractions built using MVars.
takeBaseName :: FilePath -> String
filepath System.FilePath.Windows, filepath System.FilePath.Posix
Get the base name, without an extension or path. > takeBaseName "file/test.txt" == "test" > takeBaseName "dave.ext" == "dave" > takeBaseName "" == "" > takeBaseName "test" == "test" > takeBaseName (addTrailingPathSeparator x) == "" > takeBaseName "file/file.tar.gz" == "file.tar"
takeDirectory :: FilePath -> FilePath
filepath System.FilePath.Windows, filepath System.FilePath.Posix
Get the directory name, move up one level. > takeDirectory x `isPrefixOf` x || takeDirectory x == "." > takeDirectory "foo" == "." > takeDirectory "/foo/bar/baz" == "/foo/bar" > takeDirectory "/foo/bar/baz/" == "/foo/bar/baz" > takeDirectory "foo/bar/baz" == "foo/bar" > Windows: takeDirectory "foo\\bar" == "foo" > Windows: takeDirectory "foo\\bar\\\\" == "foo\\bar" > Windows: takeDirectory "C:\\" == "C:\\"
takeDrive :: FilePath -> FilePath
filepath System.FilePath.Windows, filepath System.FilePath.Posix
Get the drive from a filepath. > takeDrive x == fst (splitDrive x)
takeExtension :: FilePath -> String
filepath System.FilePath.Windows, filepath System.FilePath.Posix
Get the extension of a file, returns "" for no extension, .ext otherwise. > takeExtension x == snd (splitExtension x) > Valid x => takeExtension (addExtension x "ext") == ".ext" > Valid x => takeExtension (replaceExtension x "ext") == ".ext"
takeExtensions :: FilePath -> String
filepath System.FilePath.Windows, filepath System.FilePath.Posix
Get all extensions > takeExtensions "file.tar.gz" == ".tar.gz"
takeFileName :: FilePath -> FilePath
filepath System.FilePath.Windows, filepath System.FilePath.Posix
Get the file name. > takeFileName "test/" == "" > takeFileName x `isSuffixOf` x > takeFileName x == snd (splitFileName x) > Valid x => takeFileName (replaceFileName x "fred") == "fred" > Valid x => takeFileName (x </> "fred") == "fred" > Valid x => isRelative (takeFileName x)
takeInput :: [(String, String)] -> ByteString -> ByteString
cgi Network.CGI.Protocol
Takes the right number of bytes from the input.
takeTMVar :: TMVar a -> STM a
stm Control.Concurrent.STM.TMVar
Return the contents of the TMVar. If the TMVar is currently empty, the transaction will retry. After a takeTMVar, the TMVar is left empty.
takeWhile :: (Char -> Bool) -> ByteString -> ByteString
bytestring Data.ByteString.Char8, bytestring Data.ByteString.Lazy.Char8
takeWhile, applied to a predicate p and a ByteString xs, returns the longest prefix (possibly empty) of xs of elements that satisfy p.
takeWhile :: (Word8 -> Bool) -> ByteString -> ByteString
bytestring Data.ByteString, bytestring Data.ByteString.Lazy
takeWhile, applied to a predicate p and a ByteString xs, returns the longest prefix (possibly empty) of xs of elements that satisfy p.
genericTake :: Integral i => i -> [a] -> [a]
base Data.List
The genericTake function is an overloaded version of take, which accepts any Integral value as the number of elements to take.
tryTakeMVar :: MVar a -> IO (Maybe a)
base Control.Concurrent.MVar
A non-blocking version of takeMVar. The tryTakeMVar function returns immediately, with Nothing if the MVar was empty, or Just a if the MVar was full with contents a. After tryTakeMVar, the MVar is left empty.
tryTakeTMVar :: TMVar a -> STM (Maybe a)
stm Control.Concurrent.STM.TMVar
A version of takeTMVar that does not retry. The tryTakeTMVar function returns Nothing if the TMVar was empty, or Just a if the TMVar was full with contents a. After tryTakeTMVar, the TMVar is left empty.
unsafeTake :: Int -> ByteString -> ByteString
bytestring Data.ByteString.Unsafe
A variety of take which omits the checks on n so there is an obligation on the programmer to provide a proof that 0 <= n <= length xs.