(original) (raw)

{-# LANGUAGE Trustworthy #-} {-# LANGUAGE NoImplicitPrelude #-}

, isJust , isNothing , fromJust , fromMaybe , listToMaybe , maybeToList , catMaybes , mapMaybe ) where

import GHC.Base import GHC.Stack.Types ( HasCallStack )

maybe :: b -> (a -> b) -> Maybe a -> b maybe :: forall b a. b -> (a -> b) -> Maybe a -> b maybe b n a -> b _ Maybe a Nothing = b n maybe b _ a -> b f (Just a x) = a -> b f a x

isJust :: Maybe a -> Bool isJust :: forall a. Maybe a -> Bool isJust Maybe a Nothing = Bool False isJust Maybe a _ = Bool True

isNothing :: Maybe a -> Bool isNothing :: forall a. Maybe a -> Bool isNothing Maybe a Nothing = Bool True isNothing Maybe a _ = Bool False

fromJust :: HasCallStack => Maybe a -> a fromJust :: forall a. HasCallStack => Maybe a -> a fromJust Maybe a Nothing = [Char] -> a forall a. HasCallStack => [Char] -> a error [Char] "Maybe.fromJust: Nothing" fromJust (Just a x) = a x

fromMaybe :: a -> Maybe a -> a fromMaybe :: forall a. a -> Maybe a -> a fromMaybe a d Maybe a x = case Maybe a x of {Maybe a Nothing -> a d;Just a v -> a v}

maybeToList :: Maybe a -> [a] maybeToList :: forall a. Maybe a -> [a] maybeToList Maybe a Nothing = [] maybeToList (Just a x) = [a x]

listToMaybe :: [a] -> Maybe a listToMaybe :: forall a. [a] -> Maybe a listToMaybe = (a -> Maybe a -> Maybe a) -> Maybe a -> [a] -> Maybe a forall a b. (a -> b -> b) -> b -> [a] -> b foldr (Maybe a -> Maybe a -> Maybe a forall a b. a -> b -> a const (Maybe a -> Maybe a -> Maybe a) -> (a -> Maybe a) -> a -> Maybe a -> Maybe a forall b c a. (b -> c) -> (a -> b) -> a -> c . a -> Maybe a forall a. a -> Maybe a Just) Maybe a forall a. Maybe a Nothing {-# INLINE listToMaybe #-}

catMaybes :: [Maybe a] -> [a] catMaybes :: forall a. [Maybe a] -> [a] catMaybes = (Maybe a -> Maybe a) -> [Maybe a] -> [a] forall a b. (a -> Maybe b) -> [a] -> [b] mapMaybe Maybe a -> Maybe a forall a. a -> a id

mapMaybe :: (a -> Maybe b) -> [a] -> [b] mapMaybe :: forall a b. (a -> Maybe b) -> [a] -> [b] mapMaybe a -> Maybe b _ [] = [] mapMaybe a -> Maybe b f (a x :[a] xs) = let rs :: [b] rs = (a -> Maybe b) -> [a] -> [b] forall a b. (a -> Maybe b) -> [a] -> [b] mapMaybe a -> Maybe b f [a] xs in case a -> Maybe b f a x of Maybe b Nothing -> [b] rs Just b r -> b rb -> [b] -> [b] forall a. a -> [a] -> [a] :[b] rs {-# NOINLINE [1] mapMaybe #-}

{-# RULES "mapMaybe" [~1] forall f xs. mapMaybe f xs = build ([c](#local-6989586621679574447) n -> foldr (mapMaybeFB c f) n xs) "mapMaybeList" [1] forall f. foldr (mapMaybeFB (:) f) [] = mapMaybe f #-}

{-# INLINE [0] mapMaybeFB #-} mapMaybeFB :: (b -> r -> r) -> (a -> Maybe b) -> a -> r -> r mapMaybeFB :: forall b r a. (b -> r -> r) -> (a -> Maybe b) -> a -> r -> r mapMaybeFB b -> r -> r cons a -> Maybe b f a x r next = case a -> Maybe b f a x of Maybe b Nothing -> r next Just b r -> b -> r -> r cons b r r next