¿Existe un modismo de Haskell para probar varias funciones y detenerse tan pronto como una tenga éxito?

En Haskell, puedo usar el tipo a -> Maybe bpara modelar una función que devuelve un valor de tipo bo no devuelve nada (falla).

Si tengo tipos a1, ..., a(n+1)y funciones f1, ..., fn, con fi :: ai -> Maybe a(i+1)for all i, 1 <= i <= npuedo encadenar las funciones usando el >>=operador de la Maybemónada y escribir:

f1 x >>= f2 >>= f3 >>=... >>= fn

El >>=operador se asegura de que cada función se aplique siempre que su predecesor haya devuelto un valor significativo. Tan pronto como falla una función en la cadena, la cadena completa falla (retorna Nothing) y no se evalúan otras funciones en la cadena.

Tengo un patrón algo similar en el que quiero probar varias funciones en la misma entrada y regresar tan pronto como una función tenga éxito . Si todas las funciones fallan (retorno Nothing), todo el cálculo debería fallar. Más precisamente, tengo funciones f1, ..., fn :: a -> Maybe by defino la función

tryFunctions :: [a -> Maybe b] -> a -> Maybe b
tryFunctions []       _ = Nothing
tryFunctions (f : fs) x = case f x of
                            Nothing    -> tryFunctions fs x
                            r@(Just _) -> r

En cierto sentido, esto es dual para la Maybemónada en que un cálculo se detiene en el primer éxito en lugar de en el primer fracaso.

Por supuesto, puedo usar la función que he escrito anteriormente, pero me preguntaba si hay una forma mejor, bien establecida e idiomática de expresar este patrón en Haskell.

Dado un conjunto cerrado (número fijo de elementos) Scon elementos {a..z}y un operador binario *:

Hay un único elemento de identidad ital que:

forall x in S: i * x = x = x * i

El operador es asociativo de manera que:

forall a, b, c in S: a * (b * c) = (a * b) * c

Tienes un monoide.

Ahora, dado cualquier monoide, puede definir una función binaria fcomo:

f(i, x) = x
f(x, _) = x

Lo que esto significa es que, por ejemplo, el Maybemonoide ( Nothinges el elemento de identidad indicado anteriormente como i):

f(Nothing, Just 5) = Just 5
f(Just 5, Nothing) = Just 5
f(Just 5, Just 10) = Just 5
f(Nothing, f(Nothing, Just 5)) = Just 5
f(Nothing, f(Just 5, Nothing)) = Just 5

Sorprendentemente, no puedo encontrar esta función precisa en las bibliotecas predeterminadas, lo que probablemente se deba a mi propia inexperiencia. Si alguien más puede ser voluntario en esto, lo agradecería sinceramente.

Aquí está la implementación que deduje de la mano del ejemplo anterior:

(<||>) :: (Monoid a, Eq a) => a -> a -> a
x <||> y
     | x == mempty = y
     | True = x

Ejemplo:

λ> [] <||> [1,2] <||> [3,4]
[1,2]
λ> Just "foo" <||> Nothing <||> Just "bar"
Just "foo"
λ> Nothing <||> Just "foo" <||> Just "bar"
Just "foo"
λ> 

Entonces, si desea utilizar una lista de funciones como entrada ...

tryFunctions x funcs = foldl1 (<||>) $ map ($ x) funcs

ejemplo:

instance Monoid Bool where
         mempty = False
         mconcat = or
         mappend = (||)

λ> tryFunctions 8 [odd, even]
True
λ> tryFunctions 8 [odd, odd]
False
λ> tryFunctions 8 [odd, odd, even]
True
λ> 

import Data.Monoid

tryFunctions :: a -> [a -> Maybe b] -> Maybe b
tryFunctions x = getFirst . mconcat . map (First . ($ x))

Esto se parece mucho a reemplazar el fracaso por una lista de éxitos

Estás hablando en Maybe alugar de hacerlo [a], pero en realidad son muy similares: podemos pensar Maybe aque son como [a], excepto que puede contener como máximo un elemento (es decir, Nothing ~= []y Just x ~= [x]).

En el caso de las listas, tryFunctionssería muy simple: aplique todas las funciones al argumento dado y luego concatene todos los resultados juntos. concatMaphará esto muy bien:

tryFunctions :: [a -> [b]] -> a -> [b]
tryFunctions fs x = concatMap ($ x) fs

De esta manera, podemos ver que el <|>operador para Maybeactúa como concatenación para 'listas con como máximo un elemento'.

En el espíritu de Conal, divídalo en operaciones más pequeñas y simples.

En este caso, asumdesde Data.Foldablehace la parte principal.

tryFunction fs x = asum (map ($ x) fs)

Alternativamente, a la respuesta de Jimmy Hoffa puede usar la Monoidinstancia, (->)pero luego necesita una Monoidinstancia Maybey la estándar no hace lo que desea. ¿Quieres Firstpartir Data.Monoid.

tryFunction = fmap getFirst . fold . map (fmap First)

(O mconcatpara una versión anterior y más especializada de fold).