Comment combinez-vous des conditions de filtre

La classe de filtre des fonctions d'une condition (a -> Bool) et l'applique lors du filtrage.

Quelle est la meilleure façon d'utiliser un filtre lorsque vous avez plusieurs conditions?

Utilisé la fonction applicative
liftA2 au lieu de liftM2 parce que je pour une raison quelconque ne pouvait pas comprendre comment liftM2 travaillé au sein du code pur.

InformationsquelleAutor | 2009-05-08
  1. 31

    La liftM2 combinator peut être utilisé dans le Lecteur monade pour ce faire, en plus "fonctionnelle": les

    import Control.Monad
import Control.Monad.Reader

-- ....

filter (liftM2 (&&) odd (> 100)) [1..200]

    Noter que les importations sont importantes; le Contrôle.Monade.Reader offre la Monade (e ->) instance qui fait cela tous les travaux.

    La raison pour laquelle cela fonctionne est que le lecteur monade est juste (e ->) pour certains, l'environnement électronique. Ainsi, une valeur de type boolean prédicat est un 0-aire monadique de la fonction de retour bool dans un environnement correspondant à son argument. Nous pouvons ensuite utiliser liftM2 à distribuer de l'environnement plus de deux de ces prédicats.

    Ou, en termes plus simples, liftM2 agira un peu comme ça quand les types de travail:

    liftM2 f g h a = f (g a) (h a)

    Vous pouvez également définir un nouveau combinateur si vous voulez être en mesure de la chaîne de ces facilement, et/ou ne voulez pas salir avec liftM2:

    (.&&.) :: (a -> Bool) -> (a -> Bool) -> (a -> Bool)
(.&&.) f g a = (f a) && (g a)
-- or, in points-free style:
(.&&.) = liftM2 (&&)    

filter (odd .&&. (> 5) .&&. (< 20)) [1..100]
    • Les deux exemples de travail sur GHC 7.6.3 même si vous n'importez pas les Control.Monad.Reader.
    • Je suis liftM2 peut (aujourd'hui) sera remplacé comme ceci: filter ((&&) <$> odd <*> (>100)) [1.200]. Qui est la même, mais plus joli. 🙂 De plus, cela ne nécessite Control.Applicative, et pas des monades. ... Bien que je me demande encore quel opérateur permet ANDing plus de deux fonctions Booléennes...
    InformationsquelleAutor bdonlan
  2. 16

    Bien, vous pouvez combiner des fonctions toutefois vous souhaitez en Haskell (aussi longtemps que les types sont corrects) et à l'aide de lambda vous n'avez même pas le nom de votre fonction de prédicat, c'est à dire,

    filter (\x -> odd x && x > 100) [1..200]
    InformationsquelleAutor Jonas
  3. 11

    Disons que vos conditions sont stockées dans une liste appelée conditions. Cette liste a le type [a -> Bool].

    À appliquer toutes les conditions pour une valeur x, vous pouvez utiliser map:

    map ($ x) conditions

    Cela s'applique chaque condition pour x et retourne une liste de Bool. Afin de réduire cette liste dans un booléen, Vrai si tous les éléments sont True et False dans le cas contraire, vous pouvez utiliser le and fonction:

    and $ map ($ x) conditions

    Maintenant, vous avez une fonction qui combine toutes les conditions. Nous allons lui donner un nom:

    combined_condition x = and $ map ($ x) conditions

    Cette fonction est du type a -> Bool, donc on peut l'utiliser dans un appel à filter:

    filter combined_condition [1..10]
    • Attention avec ($x), par opposition à ($ x), comme si vous tournez sur le Modèle Haskell pour une autre raison, la valeur de $x soudain ressembler à une épissure.
    • Vous avez découvert la all fonction: filter (all conditions) [1..10]
    • Il y a aussi la toute fonction, en fonction de la façon dont vous souhaitez combiner les prédicats: tout p = ou . carte p; p = et . carte p;
    • tous a de type (a -> Bool) -> [a] -> Bool, pas [(a -> Bool)] -> a -> Bool.
    • comme Stephan202 souligné, "toutes", s'applique une condition à une liste de valeurs. Ma fonction s'applique à une liste de conditions à une valeur unique.
    • filter (and . sequence conditions)
    • Toujours, au lieu de and $ map ($ x) conditions il est possible de type: all ($ x) conditions
    • and (map ($ x) conditions) peut être écrit and (conditions ?? x) avec (??)

    InformationsquelleAutor Ayman Hourieh
  4. 4

    Si vous avez une liste de fonctions de filtrage du type de a -> Bool et souhaitez les combiner en un seul concis fonction de filtrage du même type, on peut écrire des fonctions pour faire juste. Laquelle des deux fonctions ci-dessous que vous utilisez dépend du comportement de filtre dont vous avez besoin.

    anyfilt :: [(a -> Bool)] -> (a -> Bool)
anyfilt fns = \el -> any (\fn -> fn el) fns

allfilt :: [(a -> Bool)] -> (a -> Bool)
allfilt fns = \el -> all (\fn -> fn el) fns

    anyfilt sera de retour vrai si l'une des fonctions de filtre de retour vrai et false si toutes les fonctions de filtre de retour faux.
    allfilt renvoie true si toutes les fonctions de filtre de retour vrai et faux si l'une des fonctions de filtre de retour faux.
    Notez que vous ne pouvez pas η-réduction soit la fonction que les références à fns sur les RHS sont à l'intérieur d'une fonction anonyme.

    L'utiliser comme ceci:

    filterLines :: [String] -> [String]
filterLines = let
  isComment = isPrefixOf "# "
  isBlank = (==) ""
  badLine = anyfilt([isComment, isBlank])
  in filter (not . badLine)

main = mapM_ putStrLn $ filterLines ["# comment", "", "true line"]
--> "true line"
    InformationsquelleAutor Quint