Zurück Weiter Inhalt

2.5 Filter

Ein Filter a b = F (a -> [b]) kapselt eine Funktion, die aus einem a eine Liste b erzeugt. Diese allgemeine Konstrukt wird für 4 Fälle verwendet:

Totale Funktion: eine partiell gültige Funktion wird gekapselt. Sie immer gütig.
Prädikat: Eine Funktion testet, ob eine Bedingung erfüllt ist. Dieses ist wichtig, um z.B. zu selektieren.
Relation: Abbilden von 1 auf n. Beispielsweise kann eine Funktion alle Kinder eines Elementes liefern.
Funktionskomposition: Aneinanderreihung mehrer Funktionen. Die Funktionf liefert ein Liste von a, die darauf angewandte Funktion g hat aber nur ein a als Parameter.

Filter sind ein eingebauter Datentyp in Haskell. HXML erweitert die Funktionalität und stellt Funktionen zum Erzeugen und Anwenden bereit.

Defintionen zu Filtern

Filter a b = F (a -> [b])

runFilter :: Filter a b -> a -> [b] Führt einen Filter aus

makeFilter :: (a -> [b]) -> Filter a b Erzeugt einen neune Filter

apFilter :: ([a] -> [b]) -> Filter c a -> Filter c b

wrap :: a -> [a] Kapslet ein Element a in einer Liste von a

(!>>=) :: [a] -> (a -> [b]) -> [b] Erzeugt aus einer Liste a und einem Filter a b eine Liste von b

Beispiel: Infix-Operator, Pattern-Matching, Filterfunktion

(!>>=) :: [a] -> (a -> [b]) -> [b]

[ ] !>>= _ = [ ]

[x] !>>= f = f x

(x:xs) !>>= f = f x ++ (xs !>>= f)

In diesem Beispiel wird er Infixoperator !>>= definiert. Die 3 Defineitionen werden alternativ per Pattern-Matching ausgewählt, wobei sich das Pattern-Matching auf die Liste [a] bezieht. Ist die Liste leer, so wird eine leer Liste geliefert. Anderenfalls wird erst das Kopfelemente mit der Funktion f, also (a -> [b]) bearbeitet und anschliessend der Rest der Liste rekursiv behandelt.

Filter und Arrows

Um Filter beliebig miteinander kombinieren zu können, werden diese in einem Arrow gekapselt. Zwichen Arrows werden Operationen definiert. Mit diesen Operationen können dann die gekapselten Filter kombiniert werden. Folgend sind die Operationen auf Arrows und damit die Filterkombinatoren aufgelistet:

Algemeine Operationen

f >>> g Rückgabewert von f ist Parameter von g. Es werden zwei Arrows aneinander gehängt. Umgekehrte Reihenfolge zum Operator fü Funktionskomposition

arr f die Funktion f in eine Arrow kapseln

f +++ g Ergebnisse von f, g werden aneinander gehängt

Produkt-Kombinatoren

f >&< g Parameter ist ein Paar. Erstes Element wird durch f, zweites durch g verarbeitet. Ergebnisse werden kombiniert

f &&& g Kartesisches Produkt, Rückgabewerte von f, g werden kombiniert

apfst (f) "Aply First", Parameter ist Paar. Erstes Element wird verändert, zweites wird durch gereicht

apsnd (g) "Aply Seconf", wie apfst (f), jedoch wird zweites Element bearbeitet

Zurück Weiter Inhalt

`Filter a b = F (a -> [b])`
`runFilter :: Filter a b -> a -> [b]`	Führt einen Filter aus
`makeFilter :: (a -> [b]) -> Filter a b`	Erzeugt einen neune Filter
`apFilter :: ([a] -> [b]) -> Filter c a -> Filter c b`
`wrap :: a -> [a]`	Kapslet ein Element `a` in einer Liste von `a`
`(!>>=) :: [a] -> (a -> [b]) -> [b]`	Erzeugt aus einer Liste `a` und einem `Filter a b` eine Liste von `b`

`(!>>=)`	`:: [a] -> (a -> [b]) -> [b]`
`[ ]`	`!>>= _ = [ ]`
`[x]`	`!>>= f = f x`
`(x:xs)`	`!>>= f = f x ++ (xs !>>= f)`

`f >>> g`	Rückgabewert von f ist Parameter von g. Es werden zwei Arrows aneinander gehängt. Umgekehrte Reihenfolge zum Operator fü Funktionskomposition
`arr f`	die Funktion f in eine Arrow kapseln
`f +++ g`	Ergebnisse von f, g werden aneinander gehängt

`f >&< g`	Parameter ist ein Paar. Erstes Element wird durch f, zweites durch g verarbeitet. Ergebnisse werden kombiniert
`f &&& g`	Kartesisches Produkt, Rückgabewerte von f, g werden kombiniert
`apfst (f)`	"Aply First", Parameter ist Paar. Erstes Element wird verändert, zweites wird durch gereicht
`apsnd (g)`	"Aply Seconf", wie apfst (f), jedoch wird zweites Element bearbeitet