In Haskell, I can use the type a -> Maybe b to model a function that either returns a value of type b, or returns nothing (it fails).If I have types a1, ..., a(n+1) and functions f1, ..., fn, with fi :: ai -> Maybe a(i+1) for all i, 1 <= i <= n, I can chain the functions by using the >>= operator of the Maybe monad and write:f1 x >>= f2 >>= f3 >>=... >>= fnThe >>= operator ensures that each function is applied as long as its predecessor has returned a meaningful value. As soon as a function in the chain fails, the whole chain fails (returns Nothing) and further functions in the chain are not evaluated.I have a somewhat similar pattern in which I want to try several functions on the same input, and return as soon as one function succeeds. If all functions fail (return Nothing), the whole computation should fail. More precisely, I have functions f1, ..., fn :: a -> Maybe b and I define the functiontryFunctions :: [a -> Maybe b] -> a -> Maybe btryFunctions []       _ = NothingtryFunctions (f : fs) x = case f x of                            Nothing    -> tryFunctions fs x                            r@(Just _) -> rIn a sense this is dual to the Maybe monad in that a computation stops at the first success instead of at the first failure.Of course, I can use the function I have written above but I was wondering if there is a better, well-established and idiomatic way of expressing this pattern in Haskell.
Is there a Haskell idiom for trying several functions and stop as soon as one succeeds?
functional programming;haskell;patterns and practices