Syntax-Fehler beim aufrufen von generischen Klassenmethoden

[Guest]

Hallo Leute,

das sieht vllt. ein wenig verrückt aus, was ich hier mache, aber nichts destotrotz maul der der Java-Compiler die ganze Zeit an einer Stelle meines Quelltextes rum. Ich weiß echt nicht mehr weiter.

Der Code:

// Schnittstelle für Funktionsobjekte.
public interface Function<A,B> {
  public B evaluate(final A x);
}


import java.util.List;

// Klasse zur Bereistellung von Funktionsobjekten
public final class F {
  //Funktionsobjekt, das für eine Liste ermittelt ob sie leer ist.
  public static <A> Function<List<A>, Boolean> IsEmpty()  {
    return new Function<List<A>, Boolean>() {
      public Boolean evaluate(List<A> x) {
        return x.isEmpty();
      }
    };
  }
  // Funktionsobjekt, das sein argument logisch negiert.
  public static Function<Boolean,Boolean> Not() {
    return new Function<Boolean,Boolean>() {
      public Boolean evaluate(Boolean x) {
        return !x;
      }
    };
  }
  // Funktionsobejt, das zwei Funktionsobjekte zusammen setzt, ala (f ° g)(x) = f(g(x))
  public static <A,B,C> Function<A,C> Cat(final Function<B,C> f, final Function<A,B> g) {
    return new Function<A,C>() {
      public C evaluate(A x) {
        return f.evaluate(g.evaluate(x));
      }
    };
  }
  // Aus den oberen Funktionsobjekten zusammengesetztes, dass das Gegenteil von
  // IsEmpty liefern soll. (Das ginge vielleicht auch anders, aber der Code ist konstruiert
  // und vom eigentlich Problem soweit heruntergebrochen wurden.
  public static <A> Function<List<A>, Boolean> NotEmpty() {
    return Cat(Not(), IsEmpty<A>());
  }
}

In der letzten Zeile mit dem return bekomme ich immer den Fehler:

F.java:40: illegal start of expression
return Cat(Not(), IsEmpty<A>());
^
F.java:40: ')' expected
return Cat(Not(), IsEmpty<A>());
^

Das scheint daran zu liegen, dass ich der statischen Funktion IsEmpty ihren Typparameter übergeben will. Geht das nicht oder verwende ich nur die falsche Syntax? Lasse ich den Typparameter weg, bekomme ich folgende Fehlermeldung:

found : Function<java.util.List<java.lang.Object>,java.lang.Boolean>
required: Function<java.util.List<A>,java.lang.Boolean>
return Cat(Not(), IsEmpty());
^
Also wie gesagt, ich weiß an dieser Stelle nicht mehr weiter. Es wäre echt sehr nett, wenn mir jemand helfen könnte.

Besten Dank im Voraus,

Martin.

 

[Beni]

Nein, Generics können so nicht gesetzt werden. Da deine argumentlosen Methoden auch keine Generics benötigen (sie machen ja nichts mit dem Inhalt der Listen), kann man einige Generics durch Wildcards ersetzen, und so wieder korrekten Code generieren:

//Schnittstelle für Funktionsobjekte.
interface Function<A,B> {
    public B evaluate(final A x);
}

//Klasse zur Bereistellung von Funktionsobjekten
public final class GenericTest {
//  Funktionsobjekt, das für eine Liste ermittelt ob sie leer ist.
    public static Function<List<?>, Boolean> IsEmpty()  {
        return new Function<List<?>, Boolean>() {
            public Boolean evaluate(List<?> x) {
                return x.isEmpty();
            }
        };
    }
//  Funktionsobjekt, das sein argument logisch negiert.
    public static Function<Boolean,Boolean> Not() {
        return new Function<Boolean,Boolean>() {
            public Boolean evaluate(Boolean x) {
                return !x;
            }
        };
    }
//  Funktionsobejt, das zwei Funktionsobjekte zusammen setzt, ala (f ° g)(x) = f(g(x))
    public static <A,B,C> Function<A,C> Cat(final Function<B,C> f, final Function<A,B> g) {
        return new Function<A,C>() {
            public C evaluate(A x) {
                return f.evaluate(g.evaluate(x));
            }
        };
    }
//  Aus den oberen Funktionsobjekten zusammengesetztes, dass das Gegenteil von
//  IsEmpty liefern soll. (Das ginge vielleicht auch anders, aber der Code ist konstruiert
//  und vom eigentlich Problem soweit heruntergebrochen wurden.
    public static Function<List<?>, Boolean> NotEmpty() {
        return Cat(Not(), IsEmpty());
    }
}

Eine andere Variante: anstelle von Methoden die "Function"-Objekte erzeugen, machst du ein paar benannte Klassen. Dann würde dein "NotEmpty" halt so aussehen:

    public static <A> Function<List<A>, Boolean> NotEmpty() {
  // nit einer Klasse "IsEmpty"
        return Cat(Not(), new IsEmpty<A>());
    }

P.S. In Java schreibt man Methoden normalerweise klein :bae:

 

[Guest]

Vielen Dank für die schnelle Hilfe.

Ich habe das so wie vorgschlagen mit den Wildcards umgesetzt und es funktioniert. Als ich dann weiter Programmiert habe, kam dann ein neuer Fehler ähnlicher Art. Das Interface Function sei wie oben belassen, die Klasse F aber um zwei statische Methoden zur Funktionobjektserzeugung erweitert. id liefert das Funktionsobjekt, das einfach nur sein Argument zurückgibt und id2 wendet id mittels cat zweimal hintereinander an, was zwar total nutzlos ist, aber eine heruntergebrochene Version des eigentlichen Problems ist.

public final class F
{
  // Funktion, die zwei Funktionsobjekte zusammensetzt, ala (f ° g)(x) = f(g(x)) 
  public static <A, B, C> Function<A, C> cat(final Function<B, C> f, final Function<A, B> g) {
    return new Function<A, C>() {
      public C evaluate(A x) {
        return f.evaluate(g.evaluate(x));
      }
    };
  }
  // Funktionsobjekt für die identische Funktion, ala id(x) = x
  public static <A> Function<A, A> id() {
    return new Function<A, A>() {
      public A evaluate(A x) {
        return x;
      }
    };
  }
  // Funktionsobjekt für die doppelt angewendete identische Funktion id2 = id ° id
  public static <A> Function<A, A> id2() {
    return cat(id(), id());
  }
}

Die letzte Funktion lehnt der Compiler wieder ab, mit folgender Fehlermeldung:

F.java:28: incompatible types
found : Function<java.lang.Object,java.lang.Object>
required: Function<A,A>
return cat(id(), id());

Wie es aussieht instantiert der Compiler id() vom Typ

Function<Object,Object>

anstatt als

Function<A,A>

. Gibt es einen Weg den Compiler davon zu überzeugen, das Funktionsobjekt richtig zu instantiieren?

Wer sich fragt, was ich hier für komische Dinge treibe, der bekommt unter http://www.haskell.org/ einen Einblick.

Erneut vielen Dank im Voraus,

Martin.

 

[Beni]

Zuerst wollte ich dir Casts vorschlagen, dann fiel mir ein, dass die Generics doch indirekt eingeschmuggelt werden können:

    // Funktionsobjekt für die doppelt angewendete identische Funktion id2 = id ° id
    public static <A> Function<A, A> id2() {
        Function<A,A> idA = id();
        Function<A,A> idB = id();
        
        return cat( idA, idB );
    }

Ich vermute mal, der Compiler wird sogar idA und idB wegoptimieren.

Naja, damit könntest du wohl auch die Wildcards vermeiden :-/

 

[Guest]

Danke, jetzt ist das Problem gelöst. Und die Wildcards musste ich sogar zugunsten dieser Variante fallen lassen, weil es sonst an anderen Stellen hakt.

Das ganze ist natürlich ziemlich häßlich, was da im Ergebnis rauskommt. Im einem konkreten Beispiel sieht das jetzt so aus:

  public final[B] List[B] map(final Function<A,B> f)
  {
    Function<List<A>,Boolean> nl = L.isEmpty();
    Function<List<A>,A>       hd = L.head();
    Function<List<A>,List<A>> tl = L.tail();
    return new Iterate<B,List<A>>(this, tl, nl, P.cat(f, hd));
  }

wobei

  public final[B] List[B] map(final Function<A,B> f)
  {
    return new Iterate<B,List<A>>(this, L.tail<A>(), L.isEmpty<A>(), P.cat(f, L.head<A>()));
  }

natürlich viel kürzer und prägnanter wäre. Aber wenn das nicht geht, habe ich natürlich keine Wahl. Aber vielleicht gelant sowas ja man irgendwann in die Sprache Java hinein.

Also, besten Dank nochmal,

Martin.