Hoogle Search

Within LTS Haskell 24.4 (ghc-9.10.2)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

  1. lookup :: Ord k => k -> Map k a -> Maybe a

    containers Data.Map.Strict.Internal

    Lookup the value at a key in the map. The function will return the corresponding value as (Just value), or Nothing if the key isn't in the map. An example of using lookup: 

    import Prelude hiding (lookup)
import Data.Map

employeeDept = fromList([("John","Sales"), ("Bob","IT")])
deptCountry = fromList([("IT","USA"), ("Sales","France")])
countryCurrency = fromList([("USA", "Dollar"), ("France", "Euro")])

employeeCurrency :: String -> Maybe String
employeeCurrency name = do
dept <- lookup name employeeDept
country <- lookup dept deptCountry
lookup country countryCurrency

main = do
putStrLn $ "John's currency: " ++ (show (employeeCurrency "John"))
putStrLn $ "Pete's currency: " ++ (show (employeeCurrency "Pete"))
    The output of this program: 
    John's currency: Just "Euro"
Pete's currency: Nothing

  2. lookup :: Int -> Seq a -> Maybe a

    containers Data.Sequence

    The element at the specified position, counting from 0. If the specified position is negative or at least the length of the sequence, lookup returns Nothing. 

    0 <= i < length xs ==> lookup i xs == Just (toList xs !! i)

    i < 0 || i >= length xs ==> lookup i xs = Nothing
    Unlike index, this can be used to retrieve an element without forcing it. For example, to insert the fifth element of a sequence xs into a Map m at key k, you could use 
    case lookup 5 xs of
Nothing -> m
Just x -> insert k x m

  3. lookup :: Int -> Seq a -> Maybe a

    containers Data.Sequence.Internal

    The element at the specified position, counting from 0. If the specified position is negative or at least the length of the sequence, lookup returns Nothing. 

    0 <= i < length xs ==> lookup i xs == Just (toList xs !! i)

    i < 0 || i >= length xs ==> lookup i xs = Nothing
    Unlike index, this can be used to retrieve an element without forcing it. For example, to insert the fifth element of a sequence xs into a Map m at key k, you could use 
    case lookup 5 xs of
Nothing -> m
Just x -> insert k x m

  4. lookup :: Key -> KeyMap v -> Maybe v

    aeson Data.Aeson.KeyMap

    Return the value to which the specified key is mapped, or Nothing if this map contains no mapping for the key.

  5. lookup :: (Eq k, Hashable k) => k -> HashMap k v -> Maybe v

    unordered-containers Data.HashMap.Internal

    Return the value to which the specified key is mapped, or Nothing if this map contains no mapping for the key.

  6. lookup :: (Eq k, Hashable k) => k -> HashMap k v -> Maybe v

    unordered-containers Data.HashMap.Internal.Strict

    Return the value to which the specified key is mapped, or Nothing if this map contains no mapping for the key.

  7. lookup :: (Eq k, Hashable k) => k -> HashMap k v -> Maybe v

    unordered-containers Data.HashMap.Lazy

    Return the value to which the specified key is mapped, or Nothing if this map contains no mapping for the key.

  8. lookup :: (Eq k, Hashable k) => k -> HashMap k v -> Maybe v

    unordered-containers Data.HashMap.Strict

    Return the value to which the specified key is mapped, or Nothing if this map contains no mapping for the key.

  9. lookup :: Eq a => a -> [(a, b)] -> Maybe b

    hedgehog Hedgehog.Internal.Prelude

    lookup key assocs looks up a key in an association list. For the result to be Nothing, the list must be finite.

    Examples

    >>> lookup 2 []
Nothing

    >>> lookup 2 [(1, "first")]
Nothing

    >>> lookup 2 [(1, "first"), (2, "second"), (3, "third")]
Just "second"

  10. lookup :: Key -> Word64Map a -> Maybe a

    ghc GHC.Data.Word64Map.Internal

    Lookup the value at a key in the map. See also lookup.

Page 2 of many | Previous | Next