-{-# OPTIONS_GHC -fno-implicit-prelude #-}
+{-# OPTIONS_GHC -XNoImplicitPrelude #-}
-----------------------------------------------------------------------------
-- |
-- Module : Data.Maybe
module Data.Maybe
(
Maybe(Nothing,Just)-- instance of: Eq, Ord, Show, Read,
- -- Functor, Monad, MonadPlus
+ -- Functor, Monad, MonadPlus
- , maybe -- :: b -> (a -> b) -> Maybe a -> b
+ , maybe -- :: b -> (a -> b) -> Maybe a -> b
- , isJust -- :: Maybe a -> Bool
- , isNothing -- :: Maybe a -> Bool
- , fromJust -- :: Maybe a -> a
- , fromMaybe -- :: a -> Maybe a -> a
+ , isJust -- :: Maybe a -> Bool
+ , isNothing -- :: Maybe a -> Bool
+ , fromJust -- :: Maybe a -> a
+ , fromMaybe -- :: a -> Maybe a -> a
, listToMaybe -- :: [a] -> Maybe a
- , maybeToList -- :: Maybe a -> [a]
- , catMaybes -- :: [Maybe a] -> [a]
- , mapMaybe -- :: (a -> Maybe b) -> [a] -> [b]
+ , maybeToList -- :: Maybe a -> [a]
+ , catMaybes -- :: [Maybe a] -> [a]
+ , mapMaybe -- :: (a -> Maybe b) -> [a] -> [b]
) where
#ifdef __GLASGOW_HASKELL__
-import {-# SOURCE #-} GHC.Err ( error )
import GHC.Base
#endif
, fromJust
, fromMaybe
, listToMaybe
- , maybeToList
+ , maybeToList
, catMaybes
, mapMaybe
)
-- monad, where all errors are represented by 'Nothing'. A richer
-- error monad can be built using the 'Data.Either.Either' type.
-data Maybe a = Nothing | Just a
+data Maybe a = Nothing | Just a
deriving (Eq, Ord)
instance Functor Maybe where
Nothing >> _ = Nothing
return = Just
- fail _ = Nothing
+ fail _ = Nothing
-- ---------------------------------------------------------------------------
-- Functions over Maybe
-- | The 'maybe' function takes a default value, a function, and a 'Maybe'
-- value. If the 'Maybe' value is 'Nothing', the function returns the
-- default value. Otherwise, it applies the function to the value inside
--- the 'Just' and returns that.
+-- the 'Just' and returns the result.
maybe :: b -> (a -> b) -> Maybe a -> b
maybe n _ Nothing = n
maybe _ f (Just x) = f x
-- | The 'mapMaybe' function is a version of 'map' which can throw
-- out elements. In particular, the functional argument returns
-- something of type @'Maybe' b@. If this is 'Nothing', no element
--- is added on to the result list. If it just @'Just' a@, then @a@ is
--- added on to the result.
+-- is added on to the result list. If it just @'Just' b@, then @b@ is
+-- included in the result list.
mapMaybe :: (a -> Maybe b) -> [a] -> [b]
mapMaybe _ [] = []
mapMaybe f (x:xs) =