Die übergabe-Liste, die Elemente, die als Parameter an Curry-Funktion

Ich denke, Sie sind Missverständnis, das Haskell Typ-system.

Sind vor allem Ihre "quadsum" - Funktion ist Curry schon. Sie können schreiben, "quadsum 4 3" und wieder eine Funktion, die erwartet, dass die 2 und die 1 als zusätzliche Argumente. Wenn Sie schreiben "quadsum 4 3 2 1", das ist gleichbedeutend mit "((((quadsum 4) 3) 2) 1)".

In Haskell eine Liste von Ganzzahlen hat eine andere Art, eine ganze Zahl oder ein Tupel wie "(4,3,2,1)". Vor diesem hintergrund ist es eher schwierig zu verstehen, was Sie versuchen zu tun. Was soll passieren, wenn Sie schreiben?

magicalFunctionMaker quadsum [5,4,3,2,1]

Ihre "magicalFunctionMaker" wirkt eher wie "foldl", mit der Ausnahme, dass die Funktion, die Sie geben, um foldl nimmt nur zwei Argumente. So können Sie schreiben:

mySum = foldl (+) 0

Dieser gibt eine Funktion, die eine Liste und Summen der Elemente.

(BTW, sobald Sie verstehen lernen, was der Unterschied zwischen foldl und foldr.

Edit:

Haben re-Lesen Sie Ihre Frage, ich denke, Sie versuchen, Sie zu bekommen:

magicalFunctionMaker quadSum [4,3,2,1] :: Integer
magicalFunctionMaker quadSum [4,3,2] :: Integer -> Integer

Dies ist unmöglich, weil die Art der magicalFunctionMaker würde, hängt von der Länge der Liste-argument, das würde bedeuten, dynamische Typisierung. Als jemand sagte, polyvariadic Funktionen tun können, so etwas wie dies (wenn auch nicht mit einer Liste argument), aber das erfordert schon ein paar milli-olegs vom Typ Hack.

InformationsquelleAutor Paul Johnson

Können Sie nicht einmal eine Liste der Fälle, für die unterschiedliche Länge "manuell":

mf f [] = f
mf f [x] = f x
mf f [x,y] = f x y

--Occurs check: cannot construct the infinite type: t = t1 -> t
--Probable cause: `f' is applied to too many arguments
--In the expression: f x
--In the definition of `mf': mf f [x] = f x

Das bedeutet, dass mf nicht nehmen eine Funktion der willkürlichen "stelligkeit", Sie haben sich für eins entscheiden. Aus dem gleichen Grund Sie können nicht konvertieren eine beliebige Liste in ein Tupel: Man kann nicht sagen, wie viele Elemente die Tupel wird halten, aber der Typ system wissen muss.

Könnte es eine Lösung sein, durch die Begrenzung f um eine rekursive Typ a = a -> durch Verwendung von "füralle" (siehe http://www2.tcs.ifi.lmu.de/~abel/fomega/hm.html). Aber ich konnte es nicht funktioniert (es scheint, muss ich sagen, Leksah, verwenden Sie die flag -XRankNTypes irgendwo), und dass die Beschränkung auf f machen würde, Ihre Funktion ziemlich nutzlos.

[Bearbeiten]

Denken, ist die nächste Sache, was, die Sie wollen, ist wahrscheinlich irgendeine Art von reduce-Funktion. Als Paul wies darauf hin, dies ist ähnlich zu foldl, foldr... (aber die version unten ist ohne "extra Arguments" und eine homogene Art, die im Vergleich zu foldl. Beachten Sie die fehlende base-case für leere Listen)

mf :: (a → a → a) -> [a] -> a
mf f [x] = x
mf f (x:y:xs) = mf f ((f x y) : xs)

InformationsquelleAutor Landei

War ich zu Bearbeiten meinem anderen Beitrag, aber dieser ist groß genug, für seine eigenen.

Hier ist ein Weg, es zu tun mit "Art magic", aber es fühlt sich für mich wie es ist etwas suboptimal, da es erfordert eine Hebe-Funktion, die bestimmte Funktionen zu einer bestimmten Anzahl von Argumenten (mehr dazu weiter unten).

Beginnen wir mit der Definition einer rekursiven Datentyp

data RecT a = RecR a
            | RecC (a -> RecT a)

Also Variablen vom Typ RecT kann entweder nur gewickelt Ergebnis (RecR), oder Sie kann eine Fortsetzung der Rekursion (Reg.).

Nun,wie nehmen wir etwas und wirf es in Typ RecT ein?

Werte sind ganz einfach:

valRecT x = RecR x

RecR x ist offensichtlich vom Typ RecT ein.

Was ist eine Funktion, die ein argument, wie die id?

idRecT x = RecC $ \x -> RecR x

Reg. umschließt eine Funktion, eine variable und gibt den Typ RecT ein. Der Ausdruck

\x -> RecR x

ist so eine Funktion, da wir beobachten, bevor RecR x ist vom Typ RecT ein.

Allgemein alle ein-argument-Funktion kann aufgehoben werden:

lift1RecT :: (a -> a) -> RecT a
lift1RecT fn = RecC $ \a -> RecR $ fn a

Können wir verallgemeinern dies durch mehrfaches wickeln mehr tief verschachtelte Funktionsaufrufe innerhalb Reg.:

lift2RecT :: (a -> a -> a) -> RecT a
lift2RecT fn = RecC $ \b -> RecC $ \a -> RecR $ fn b a

lift3RecT :: (a -> a -> a -> a) -> RecT a
lift3RecT fn = RecC $ \c -> RecC $ \b -> RecC $ \a -> RecR $ fn c b a

OK, also wir haben alles getan, dieses Werk wiederum eine Funktion von einer beliebigen Anzahl von Argumenten in einer Art, RecT ein. Wie verwenden wir diese?

Können wir leicht schreiben Sie eine Ebene der Funktion Anwendung:

reduceRecT :: RecT a -> a -> RecT a
reduceRecT (RecC fn) = fn
reduceRecT  _        = undefined

In anderen Worten, reduceRecT nimmt ein argument vom Typ RecT und ein anderer Typ ein und gibt ein neues Rechteck ein, das ist schon eine Ebene reduziert.

Wir können auch entrollen Sie eine fertige Berechnung innerhalb einer RecT-in der Folge:

unrollRecT :: RecT a -> a
unrollRecT (RecR fn) = fn
unrollRecT  _        = undefined

Nun sind wir bereit, um eine Liste von Argumenten an eine Funktion!

lApply :: [a] -> RecT a -> a
lApply    []  fn = unrollRecT fn
lApply (l:ls) fn = lApply ls $ (reduceRecT fn) l

Betrachten wir die base-case-Erstens: wenn wir fertig mit der Berechnung, die wir nur wickeln Sie das Ergebnis und gibt es zurück. Im rekursiven Fall, reduzieren wir die Liste der Argumente durch, dann verwandeln Sie die fn durch die Anwendung der Spitze der Liste der reduzierten fn, woraus ein neues RecT ein.

Let ' s probieren:

lApply [2,5] $ lift2RecT (**)
> 32.0

So, Vorteile und Nachteile hat dieser Ansatz? Gut, das Template Haskell-version tun können unvollständige Liste Anwendung; dies gilt nicht für die isorecursive Art Lösung wie hier vorgestellt, (obwohl wir im Prinzip könnte dieses Problem beheben mit einigen Hässlichkeit). Die Lösung hat auch den Nachteil, dass Sie viel mehr boilerplate-code zugeordnet: brauchen wir eine listNRecT für alle N, die wir verwenden wollen. Endlich, es ist viel weniger einfach zu verallgemeinern, um die Analog-Tupel Lösung, wenn wir wollen lApply zu Funktionen, die von gemischten Variablen-Typen.

Natürlich, eine weitere interessante Möglichkeit ist die Verbesserung Kürze durch die Verwendung von Template Haskell zu generieren, die listNRecT Funktionen; dieses beseitigt einige boilerplate, aber in einem Sinne, kauft die Nachteile der beiden Implementierungen.

InformationsquelleAutor kwantam