Existe um idioma Haskell para tentar várias funções e parar assim que alguém for bem-sucedido?

No Haskell, posso usar o tipo a -> Maybe bpara modelar uma função que retorna um valor do tipo bou não retorna nada (falha).

Se eu tiver tipos a1, ..., a(n+1)e funções f1, ..., fn, com fi :: ai -> Maybe a(i+1)para todos i, 1 <= i <= nposso encadear as funções usando o >>=operador da Maybemônada e escrever:

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

O >>=operador garante que cada função seja aplicada desde que seu predecessor retorne um valor significativo. Assim que uma função na cadeia falha, a cadeia inteira falha (retorna Nothing) e outras funções na cadeia não são avaliadas.

Eu tenho um padrão um pouco semelhante no qual desejo tentar várias funções na mesma entrada e retornar assim que uma função for bem-sucedida . Se todas as funções falharem (retornar Nothing), todo o cálculo falhará. Mais precisamente, tenho funções f1, ..., fn :: a -> Maybe be defino a função

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

Em certo sentido, isso é duplo para a Maybemônada, pois um cálculo para no primeiro sucesso, e não na primeira falha.

Obviamente, posso usar a função que escrevi acima, mas fiquei pensando se há uma maneira melhor, bem estabelecida e idiomática de expressar esse padrão em Haskell.

Dado um conjunto fechado (número fixo de elementos) Scom elementos {a..z}e um operador binário *:

Existe um único elemento de identidade ique:

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

O operador é associativo de modo que:

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

Você tem um monóide.

Agora, dado qualquer monóide, você pode definir uma função binária fcomo:

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

O que isso significa é que, para o exemplo do Maybemonóide ( Nothingé o elemento de identidade indicado acima 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

Surpreendentemente, não consigo encontrar essa função precisa nas bibliotecas padrão, o que provavelmente se deve à minha própria inexperiência. Se mais alguém puder oferecer isso voluntariamente, eu agradeceria sinceramente.

Aqui está a implementação que deduzi de imediato do exemplo acima:

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

Exemplo:

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

Então, se você quiser usar uma lista de funções como entrada ...

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

exemplo:

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))

Isso parece muito com a substituição de falhas por uma lista de sucessos

Você está falando mais Maybe ado que [a], mas na verdade eles são muito parecidos: podemos pensar Maybe acomo sendo [a], exceto que pode conter no máximo um elemento (ie. Nothing ~= []E Just x ~= [x]).

No caso de listas, você tryFunctionsseria muito simples: aplique todas as funções ao argumento fornecido e concatene todos os resultados juntos. concatMapfará isso muito bem:

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

Dessa maneira, podemos ver que o <|>operador Maybeatua como concatenação para 'listas com no máximo um elemento'.

No espírito de Conal, divida-o em operações menores e mais simples.

Neste caso, asumde Data.Foldablefaz a parte principal.

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

Como alternativa, na resposta de Jimmy Hoffa, você pode usar a Monoidinstância, (->)mas precisa de uma Monoidinstância Maybee a padrão não faz o que você deseja. Você quer Firstde Data.Monoid.

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

(Ou mconcatpara uma versão mais antiga e especializada de fold.)