Funktionserklärung < Haskell < Programmiersprachen < Praxis < Informatik < Vorhilfe
|
Hi,
diesmal hab ich ein anderes Problem, nämlich mit Haskell. Für eine Arbeit muss ich die folgenden beiden Funktionen interpretieren mit ihrer Funktion. Die erste lautet wie folgt:
mapped:: (a->b) -> [a] -> [b]
mapped f [] = []
mapped f (x:xe) = (f x) : (mapped f xe)
Könnte man diese Funktion so interpretieren:
Die Funktion map bekommt als Parameter zum einen eine Funktion und zum anderen eine Liste einen beliebigen Typs. Sie holt einzelne Paramter aus der Liste heraus und übergibt sie an eine andere Funktion. Das Ergebnis wird dann an eine neue Liste angefügt. Die Funktion hört auf zu Arbeiten, wenn die Liste leer ist.
Die 2.
filt:: (a-> Bool) -> [a] -> [a]
filt bedingung [] = []
filt bedingung (x:xe)
| (bedingung x) = x: (filt bedingung xe)
| otherwise = filt bedingung xe
Die Funktion filt bekommt ebenso eine Funktion als Parameter und eine beliebige Liste. Die Funktion filt übergibt dann der anderen Funktion den ersten Paramter der Liste. Falls die Bedingung zutrifft, wird dieser wieder an eine neue Liste angefügt. Falls nicht, wird mit dem nächsten Wert fortgefahren. Am Ende ist dann die alte liste leer und die neue mit den Werten gefüllt, die die gegebene Bedingung erfüllen.
Könnte man die beiden Funktionen so interpretieren?
Meine zweite Frage. Werden die Parameter an eine neue Liste angefügt oder an die alte? Wenn es die alte wäre, würde es doch ins unendliche laufen, da die abbruchbedingung "filt bedingung [] =[]" nie zuträfe.
Eine letzte Frage habe ich dann doch noch. Was ist dr Unterschied zwischen Paramter und Argument. Ich habe nämlich in meiner Interpretation oft das Wort Paramter verwendet.
Würde mich über eure Hilfe sehr freuen!
Grüße
WaterofLife
|
|
| |
|
Hallo!
Vorab: ich bin keineswegs der Profi in solchen Sachen. 
> [b] mapped:: (a->b) -> [a] ->
> mapped f [] = []
> mapped f (x:xe) = (f x) : (mapped f xe)
>
> Könnte man diese Funktion so interpretieren:
> Die Funktion map bekommt als Parameter zum einen eine
> Funktion und zum anderen eine Liste einen beliebigen Typs.
> Sie holt einzelne Paramter aus der Liste heraus und
> übergibt sie an eine andere Funktion. Das Ergebnis wird
> dann an eine neue Liste angefügt. Die Funktion hört auf zu
> Arbeiten, wenn die Liste leer ist.
Ich bin mir nicht sicher, ob der Typ der Liste, die als Parameter gegeben wird, egal ist, muss es nicht vielleicht eine Liste des Typs sein, den auch die Funktion als Eingabewert bekommt (schließlich steht dort beide Male a)? Aber das ließe sich sicher ausprobieren.
Dann würde ich nicht sagen, dass ein Parameter an eine andere Funktion übergeben wird, sondern erstens ist es der erste Wert (hier würde ich auch nicht das Wort Parameter verwenden - kann es nicht erklären, aber irgendwie passt es mir hier nicht hin), der übergeben wird (und nicht nur irgendeiner), und zweitens ist es doch keine andere Funktion, sondern genau die Funktion, die mapped als Eingabe bekommen hat.
Ich würde das Ganze etwas anders formulieren:
Die Funktion mapped bildet jedes einzelne Element der Liste mit der Funktion f ab und gibt die Funktionswerte in einer Liste aus.
Das dürfte doch eigentlich alles sein - jedenfalls wird das erste Element abgebildet und als erste Element der Ausgabeliste ausgegeben. Und dann wird die Funktion rekursiv auf die Restliste xe angewendet, also wird von der Restliste wieder das erste Element abgebildet und als nächste Element in der Ausgabeliste ausgegeben. Usw..
> Die 2.
> filt:: (a-> Bool) -> [a] -> [a]
> filt bedingung [] = []
> filt bedingung (x:xe)
> | (bedingung x) = x: (filt bedingung xe)
> | otherwise = filt bedingung xe
>
> Die Funktion filt bekommt ebenso eine Funktion als
> Parameter und eine beliebige Liste. Die Funktion filt
> übergibt dann der anderen Funktion den ersten Paramter der
> Liste. Falls die Bedingung zutrifft, wird dieser wieder an
> eine neue Liste angefügt. Falls nicht, wird mit dem
> nächsten Wert fortgefahren. Am Ende ist dann die alte liste
> leer und die neue mit den Werten gefüllt, die die gegebene
> Bedingung erfüllen.
Ich denke, das könnte man so sagen. Nur das "am Ende ist dann die alte Liste leer" würde ich weglassen. Irgendwie ist das klar, denn die Funktion läuft halt so lange, bis die Liste leer ist, weil die einzige "Abbruchbedingung" eben genau "filt bedingung [] = []" ist.
> Könnte man die beiden Funktionen so interpretieren?
> Meine zweite Frage. Werden die Parameter an eine neue Liste
> angefügt oder an die alte? Wenn es die alte wäre, würde es
> doch ins unendliche laufen, da die abbruchbedingung "filt
> bedingung [] =[]" nie zuträfe.
Ich glaube, diese Frage kann man eigentlich gar nicht stellen. An die alte Liste - wie soll man da etwas anfügen? Die wird doch nur als Eingabe benutzt, und das Ergebnis (das, was du irgendwie mit anfügen bezeichnest), ist das, was rauskommt, und das ist dann halt der Funktionswert der Eingabe, hat aber nicht direkt etwas mit dieser Liste zu tun. Außerdem ist im ersten Fall die Ausgabeliste von einem anderen Typ als die Eingabeliste, so dass das nicht mal passen könnte, wie du dir das vorstellst.
> Eine letzte Frage habe ich dann doch noch. Was ist dr
> Unterschied zwischen Paramter und Argument. Ich habe
> nämlich in meiner Interpretation oft das Wort Paramter
> verwendet.
Gute Frage. Jetzt so speziell kann ich dir das nicht mal beantworten...
> Würde mich über eure Hilfe sehr freuen!
Hoffe, das hat ein bisschen geholfen?
Viele Grüße
Bastiane
![[cap]](/images/smileys/cap.gif "[cap]")
|
|
|
| |
|
| Status: |
(Antwort) fertig  | | Datum: | 12:03 Mo 22.05.2006 | | Autor: | Frank05 |
> mapped:: (a->b) -> [a] ->
> mapped f [] = []
> mapped f (x:xe) = (f x) : (mapped f xe)
>
> Könnte man diese Funktion so interpretieren:
> Die Funktion map bekommt als Parameter zum einen eine
> Funktion und zum anderen eine Liste einen beliebigen Typs.
> Sie holt einzelne Paramter aus der Liste heraus und
> übergibt sie an eine andere Funktion. Das Ergebnis wird
> dann an eine neue Liste angefügt. Die Funktion hört auf zu
> Arbeiten, wenn die Liste leer ist.
Wie Bastiane schon richtig angemerkt hat sind die Typen nicht ganz so beliebig. Es ist ja auch klar, wenn du die übergebene Funktion auf irgendwas anwendest, dann muss der Typ passen. Folglich kann die erste Liste nur vom Typ [a] sein (wobei a jetzt aber wirklich beliebig ist). Ebenso kann die Ergebnisliste, die ja aus Werten besteht, die die übergebene Funktion erzeugt, somit nur vom Typ [b] sein (auch hier ist b beliebig).
Was mapped macht hast du richtig erkannt, lässt sich aber evtl. kompakter ausdrücken: mapped wendet die übergebene Funktion auf jeden Wert in der übergebenen Liste an und liefert als Ergebnis eine Liste mit den Ergebnissen der Funktionsanwendungen.
> Die 2.
> filt:: (a-> Bool) -> [a] -> [a]
> filt bedingung [] = []
> filt bedingung (x:xe)
> | (bedingung x) = x: (filt bedingung xe)
> | otherwise = filt bedingung xe
>
> Die Funktion filt bekommt ebenso eine Funktion als
> Parameter und eine beliebige Liste. Die Funktion filt
> übergibt dann der anderen Funktion den ersten Paramter der
> Liste. Falls die Bedingung zutrifft, wird dieser wieder an
> eine neue Liste angefügt. Falls nicht, wird mit dem
> nächsten Wert fortgefahren. Am Ende ist dann die alte liste
> leer und die neue mit den Werten gefüllt, die die gegebene
> Bedingung erfüllen.
>
Auch hier gilt wieder das gleiche wie oben bzgl. der Typen. Die Funktion kann natürlich nur angewandt werden, wenn sie auch den zur Liste passenden Typ hat. Die Funktion, die hier an filt übergeben wird, wird üblicherweise als 'Prädikat' bezeichnet. Somit ist die Aufgabe der Funktion filt - wie du richtig erkannt hast - aus der übergebenen Liste alle Elemente zu entfernen, die das Prädikat nicht erfüllen.
> Könnte man die beiden Funktionen so interpretieren?
Ja kann man.. bis auf die paar Kleinigkeiten bzgl Typen.
> Meine zweite Frage. Werden die Parameter an eine neue Liste
> angefügt oder an die alte? Wenn es die alte wäre, würde es
> doch ins unendliche laufen, da die abbruchbedingung "filt
> bedingung [] =[]" nie zuträfe.
Es wird natürlich eine neue Liste angelegt. Die Eingabelist wird ja mittels Patternmatching zerlegt, und was auf der rechten Seite jeweils aufgebaut wird ist eine vollkommen neue Liste. Das ist auch klar, wenn du dir überlegst, dass es in rein funktionalen Sprachen nicht so etwas wie Variablenzuweisungen gibt. Es geht immer nur um den Datenfluss, also geht eine Liste rein in die Funktion, dann passiert <irgendwas> und es kommt eine Liste raus. Dabei spielt es prinzipiell keine große Rolle, ob das nun eine neue Liste ist oder nicht.
> Eine letzte Frage habe ich dann doch noch. Was ist dr
> Unterschied zwischen Paramter und Argument. Ich habe
> nämlich in meiner Interpretation oft das Wort Paramter
> verwendet.
Ich denke nicht, dass es eine universelle Definition dieser Terme gibt. Sie werden üblicherweise von n Leuten auf n+1 Arten aufgefasst. Eine vernünftige Definition, an die ich mich zu halten versuche, wäre die folgende:
Parameter ist die Bezeichnung für die Deklaration im Funktionskopf und deren Verwendung innerhalb der Funktion.
Argument ist das tatsächliche Objekt, dass an eine Funktion übergeben wird.
Unter dieser Definition gilt:
Parameter sind im Scope auf die Funktion beschränkt.
Eine Funktion hat Parameter, aber keine Argumente.
Ein Funktionsaufruf erwartet Argumente in der Anzahl der Parameter der Funktion (ohne Betrachtung von Unterversorgung&Co)
Ein Argument wird beim Aufruf der Funktion an einen Parameter gebunden.
usw.
> Würde mich über eure Hilfe sehr freuen!
PS: In Haskell gibt es die Funktionen mapped und filt unter den Namen map und filter schon vordefiniert.
Dann hoffe ich, dass dir das weitergeholfen hat,
Frank
|
|
|
|
