Wie kombinieren Sie filter-Bedingungen

Filter Klasse von Funktionen nimmt einen Zustand (a -> Bool) und gilt es bei der Filterung.

Was ist der beste Weg, um einen filter auf, wenn Sie mehrere Bedingungen?

Verwendet der applicative-Funktion
liftA2 statt liftM2, weil ich aus irgendeinem Grund nicht verstehen, wie liftM2 arbeitete in reiner code.

InformationsquelleAutor | 2009-05-08
  1. 30

    Den liftM2 combinator können verwendet werden in der Reader-Monade zu tun, das in einer 'funktionaler' Weise:

    import Control.Monad
import Control.Monad.Reader

-- ....

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

    Beachten Sie, dass die Importe sind wichtig; die Kontrolle.Monade.Leser bietet die Monade (e ->) Instanz, die macht das ganze funktioniert.

    Den Grund, warum dies funktioniert, ist die reader-Monade ist gerade (e ->) für einige Umwelt e. So ein Boolesches Prädikat ist eine 0-fache monadischen Funktion Rückgabe bool in einer Umgebung entsprechend seiner Argumentation. Wir können dann liftM2 zu verteilen und die Umwelt über zwei solcher Prädikate.

    Oder, in einfacheren Worten, liftM2 wird, wirken ein bisschen so, wenn die Typen arbeiten aus:

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

    Können Sie auch definieren Sie einen neuen combinator, wenn Sie wollen in der Lage sein, um diese Kette leicht und/oder nicht zu verwirren wollen mit 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]
    • Beide Beispiele arbeiten auf GHC 7.6.3, auch wenn Sie nicht importieren Control.Monad.Reader.
    • Ich bin liftM2 können (heute) ersetzt werden, wie dies: filter ((&&) <$> odd <*> (>100)) [1.200]. Das ist das gleiche, aber schöner. 🙂 Es werden auch nur benötigt Control.Applicative und keine vollständigen Monaden. ... Obwohl ich mich noch Frage, was Betreiber ermöglicht die Verknüpfung von mehr als zwei Boolesche Funktionen...
    InformationsquelleAutor bdonlan
  2. 15

    Gut, können Sie Funktionen kombinieren, aber Sie wollen in Haskell (solange die Typen sind korrekt) und mit lambdas Sie haben noch nicht einmal den Namen Ihrer Prädikat-Funktion, d.h.,

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

    Lassen Sie uns sagen, dass Ihre Bedingungen gespeichert sind, in einer Liste genannt conditions. Diese Liste hat den Typ [a -> Bool].

    Gelten alle Bedingungen auf einen Wert x verwenden, können Sie map:

    map ($ x) conditions

    Dies gilt jede Bedingung zu x aus und liefert eine Liste von Bool. Reduzieren Sie diese Liste in einer einzelnen boolean-True, wenn alle Elemente Wahr sind, und False sonst, können Sie die and Funktion:

    and $ map ($ x) conditions

    Nun haben Sie eine Funktion, welche alle Bedingungen. Geben wir ihm einen Namen:

    combined_condition x = and $ map ($ x) conditions

    Diese Funktion hat den Typ a -> Bool, so können wir es in einem Aufruf filter:

    filter combined_condition [1..10]
    • Vorsichtig mit ($x) im Gegensatz zu ($ x), als wenn Sie auf Template-Haskell aus einem anderen Grund die $x wird plötzlich Aussehen wie ein Spleiß.
    • Sie haben entdeckt, die all Funktion: filter (all conditions) [1..10]
    • Es gibt auch keine Funktion, je nachdem, wie Sie wollen, kombinieren Sie die Prädikate: any p = or . Karte p; alle p = und . Karte p;
    • alle Typ a -> Bool) -> [a] -> Bool, nicht [(a -> Bool)] -> a -> Bool.
    • Guter Punkt. Behoben.
    • als Stephan202 darauf hingewiesen, 'alle' gilt eine Bedingung auf eine Liste von Werten. Meine Funktion gilt eine Liste von Bedingungen, die zu einem einzigen Wert.
    • filter (and . sequence conditions)
    • Noch, statt and $ map ($ x) conditions es ist möglich, Typ: all ($ x) conditions
    • and (map ($ x) conditions) geschrieben werden können and (conditions ?? x) mit (??)

    InformationsquelleAutor Ayman Hourieh
  4. 3

    Wenn Sie haben eine Liste von Filter-Funktionen vom Typ a -> Bool und wollen Sie zu kombinieren in einem kurzen Filterfunktion der gleichen Art können wir Funktionen schreiben zu tun. Welche der beiden folgenden Funktionen, die Sie verwenden, hängt vom filter-Verhalten, das Sie brauchen.

    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 zurück true, wenn der filter-Funktionen geben true zurück, und false, wenn alle filter-Funktionen false zurück.
    allfilt true zurückgeben, wenn alle filter-Funktionen geben true zurück und false, wenn einer der filter-Funktionen false zurück.
    Beachten Sie, dass Sie nicht η-reduzieren Sie entweder die Funktion die Verweise auf fns auf RS sind innerhalb der anonymen Funktionen.

    Verwenden Sie es wie diese:

    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
Schreibe einen Kommentar