[linux-l] Ocml vs. Java

[Ivan Villanueva]

Hi Oliver,

On Tue, Sep 20, 2005 at 06:23:57PM +0200, Oliver Bandel wrote:
> > >  - funktional
> > Java auch mit Interfaces (ohne pointers) aber sehr "verbose"
> 
> Na, das wage ich doch sehr zu bezweifeln, daß Java funktionale Programmierung ermöglicht.
> [Beispiel in Ocaml]
Danke für das Beispiel. Sehr schön, wenn man ein 200 Zeile Programm schnell
hacken will.
Java finde ich gut für große Projekte. Funktionale Programmierung gehts auch
wenn man mehr schreibt: Beispiel:

interface Func { int operation(int i1, int i2) ; }
class Sum implements Func { int operation(int i1, int i2) { return i1 + i2 ; }
class Pro implements Func { int operation(int i1, int i2) { return i1 * i2 ; }

Jetzt kannst Du mit Sums und Pros machen was Du willst.

> Kannst Du in Java Funktionen als Argumente und als Rückgabewerte haben?

Object example(Func f, int a, int b) {
    if ((f instanceof Sum) && (a ==b)) return new Pro() ;
    return f.operation(a,b) ;
}

> Also Funktionen eine Funktion als Übergabeparameter geben?
Auch. Z.B. eine Collection<Func>
 
 
> klar.
> OO ist ja sicherlich Java's Schwerpunkt.

Genau. Es gibt Einschränkungen die C++ nicht hat, aber dafür ist einfacher und,
was mir sehr wichtig ist, es ist schnell, Programme von anderen zu verstehen.
 
 
> > >  - mächtiges Modulsystem (mit Funktoren (Funktionen über Module :)) !)
> > Was ist das ? Wofür ist es gut ?
> 
> Sauberes Aufteilen des Codes, Code-Reuse, ...
> 
> Es gibt nicht nur die einzelnen Compilation-Units, also getrennte
> Files, sondern eine eigene OCaml-interne Modul-Sprache.
> 
> Module bestehen aus Structures (die Implementierung) und Signatures
> (das Interface).
> 
> Jede Structure hat eine Default-Signature, die alle definierten
> Values frei zugänglich macht. Mit einer gesonderten Signature kann
> mann dann alles verbergen, was man nicht haben will.
> Dabei kann man die Typen der einzelnen Values sichtbar lassen,
> oder (abstract data type) auch den Typ nur abstrakt zugänglich
> halten.

Code-reuse ist auch eine Stärke von Java. Es gibt domains; packages; classes;
und public, friendly und private methods and fields.
(Entschuldigung, ich kenne die Wörter auf Deutsch nicht.)
 
> Funktoren:
> Man hat ein Modul mit allgemeiner Implementierung (z.B.
> Balanced Tree). Man will dies auf einen speziellen Datentyp
> hin spezialisieren.
> Dann definiert man die speziellen Funktionen in einem eigenen
> Modul, setzt den Funktor auf die beiden Module an und hat als
> Ergebnis ein neues Modul!
> 
> Sozusagen ein Modul als Parameter eines anderen zur Erstellung eines
> weiteren.
> 
> Extrem geniales Feature! :)

Weiß nicht genau was gemeint ist. :-(

> > >  - pattern matching (im Sinne von Haskell, nicht im Sinne von Perl)
> Beipiel:
> 
> (* ----------------------------------------------------------------- *)
> (* is_dir dir  liefert als Ergebnis:                                 *)
> (*       wenn dir ein Verzeichnis ist  -> true                       *)
> (*       wenn dir kein Verzeichnis ist -> false                      *)
> (*       wenn Fehler auftritt          -> false (und Fehlermeldung)  *)
> (* ----------------------------------------------------------------- *)
> let is_dir name =
>     try
>       match (Unix.stat name).Unix.st_kind with
>        | Unix.S_DIR -> true
>        | _          -> false
>     with
>       _ -> ignore ( output_string stderr ( "ignoring:" ^ name ^ "\n" ) ); false

Cool. In Java:
    if (file.isDirectory()) ...
Das funktioniert in Linux, Windows, Unix, in meinem Handy, etc.

> > >  - Bytecode-Compiler
> > Java auch
> 
> ja, klar.
;-)
 
> > >  - keine Pointer, keine Casts
> > Java hat auch keine Pointer, Casts sehr wenig seid Java 5
> 
> Jeder Cast ist einer zu viel.
> Wenn es die Sprache erlaubt, ist es Mist.

Einverstanden. Aber wie kannst Du sonst Objeckte einfach so auf einen Datei
speichern und wieder lesen? z.B.:
file.writeObject("Beispiel") ;
String s = (String)file.readObject() ;
           ^^^^^^^^
           cast Notwendig
 
> lex/yacc? javacc?
> 
> Wo ist da der Zusammenhang?
Ich dachte lex/yacc ist so eine Art parser generator. Sorry.
 
 
> Funktionale Programmierung macht die meisten OO-Design-Patterns platt.
> Man muß zwar umdenken, aber hat dann das meiste im Nu schon in der Kiste
> und kann die Design-Patterns Literatur ins Museum bringen. ;-)

Das ist gut.
 

> Komisch, daß unter den OCaml-Leuten auch viele Ex-Java-Leute sind und
> Ocaml nicht mehr missen wollen. :-)

Ich frage mich ob Sie Lisp kennen. Sie scheinen mir sehr ähnlich zu sein.


Gruß,
Iván