[linux-l] Ocml vs. Java

[Volker Grabsch]

On Mon, Nov 21, 2005 at 12:12:24AM +0100, Oliver Bandel wrote:
> > > [...]
> > > > Btw: Die Sache mit den Verschachtelungen sehe ich noch ein bischen
> > > > anders. Man kann sich auch Funktionen als composites erstellen.
> > > > In Haskell gibt es dafür sogar einen eigenen Operator (".").
> > > [...]
> > > 
> > > 
> > >   "The direct combination of functions by means of the operator '.' which we
> > >    have seen here is not possible in other programming paradigms, or at least
> > >    it would be an 'advanced' aspect of the language, rather than appearing on
> > >    page 11 of an introductory text."
> > >                                        (Simon Thompson, "Haskell")
> > 
> > 
> > Naja ... also bei Ocaml bzw. Python bzw. Ruby ist es kein Ding, sowas
> > auch schnell selbst zu schreiben:
> > 
> > def wende_an(start,*funcs):
> > 	result = start
> > 	for func in funcs:
> > 		result = func(result)
> > 	return result
> 
> (oder lannst Du mal 'n beispiel brigen? sollen das da Listen
>  von Funktionen sein?)

wende_an(start,func1,func2,func3,func4)

Der Parameter "*funcs" heißt, dass alle folgenden Argumente zu
einem Tupel zusammengefasst werden, das man dann durchiterieren kann.

> Bei Haskell kann man den "."-Operator auch auf eine
> Reihe von Funktionen anwenden, nicht nur auf zweie,
> so, wie man in der Shell die Pipe immer wieder
> anwenden kann:
> 
> $  ls -l | sort -u -k5 | grep -v txt | less

Naja, wobei es hier um einzelne Werte geht. Wenn es um sequenziell
erzeugte Daten geht, wäre es besser, wenn man diese Funktionen über
Iteratoren zusammenketten würde, statt immer erst eine Funktion
ihren gesamten Kram in eine Liste kippen zu lassen, bevor es die
nächste nimmt. Zumindest, soweit möglich. (sort ist natürlich ne
Ausnahme, aber ls und grep sind wunderbare Beispiele)

> Und das dann in Haskell mit dem "."-Operator
> zwischen diversen Funktioenn - quasi eine Pipleine...
> 
> da wird dann aus
> 
> let fges x = f1 ( f2 ( f3 (x) ) )
> 
> etwas wie:
> 
> fges = f3 . f2 . f1 

Ähhmm .. ja, und? Das, was du hier schreibst hat nicht das geringste
mit meinem Posting zu tun. Der "."-Operator von Haskell war schließlich
Ausgangspunkt der Diskussion, ich verstehe den Sinn deiner Erläuterung
nicht. Du wiederholst nur, was bisher längst argumentiert wurde.

> Man spart sich die ganze Klammerei...
> ...das ist echt super-genial in Haskell gelöst.

Bei mir sind's Kommas statt Klammern, und *eine* Funktion drumherum.
Das meinte ich mit "es ist kein Ding, sowas auch selbst zu stricken".
Und *jetzt* bitte dein Argument, falls du noch eins hast ...

> Wenn man also wirklich krasse Kaskaden von Funktionen
> aufbauen muß, dann kann man sowas in haskell ganz bequem
> und elegant lösen. IMHO macht das keine andere Sprache so.

Mag sein, aber ich persönlich habe davon noch nicht groß profitiert.
Hast du ein praktisches Anwendungsbeispiel parat?

Außerdem kann man viel mit Schleifen etc. vereinfachen, sodass es
in Python oder Ruby wahrscheinlich eher solche Konstrukte nehmen
würde, statt Funktionen elendig oft zu verschachteln. Aber wenn
man in Haskell oft in diese Verlegenheit kommt, wieso nicht? Ist
ein netter Operator.


Viele Grüße,

	Volker

-- 
Volker Grabsch
---<<(())>>---
Administrator
NotJustHosting GbR