Generics

[Set Lonnert]

Having trouble with comprehending generics, especially the wildcard addition. Perhaps there is someone here which could tell me about how to circumvent the oddities of type conversion in the following ...

What am I thinking wrong?

(Ok, I've studied a bit about GJ, Pizza, NextGen etc. but still ... doesn't get things right, yet.)

abstract class Node<A> {
  abstract <A> Node<A> accept(NodeVisitor<A> ask);
}
 
class EmptyNode<A> extends Node<A> {
  <A> Node<A> accept(NodeVisitor<A> ask) {
    return ask.forEmptyNode(this);
  }
}
 
class NextNode<A> extends Node<A> {
  A t;
  Node n;
  NextNode(A _t, Node _n) {
    t = _t; n = _n;
  }
  <A> Node<A> accept(NodeVisitor<A> ask) {
    return ask.forNextNode(this);
  }
}
 
interface NodeVisitor<A> {
  <A> Node<A> forEmptyNode(EmptyNode that);
  <A> Node<A> forNextNode(NextNode that);
}
 
class Remove<A> implements NodeVisitor<A> {
  A o;
  Remove(A _o) {
    o = _o;
  }
  public <A> Node<A> forEmptyNode(EmptyNode that) {
    return new EmptyNode<A>();
  }
  public <A> Node<A> forNextNode(NextNode that) {
    if (o.equals(that.t)) {
      return that.n.accept(this);
    } else {
      return new NextNode(that.t, (Node) that.n.accept(this));
    }
  }
}

Regards!
/Set Lonnert

[Set Lonnert]

I'm sorry if my posting is somewhat cryptic? In any way, I should perhaps be more verbose? In the code followup, kind of:

interface TreeDuties<A> {
  public void add(A o);
  public void remove(A o);
}
 
class Gardener<A> implements TreeDuties<A> {
  Node<A> t = new EmptyNode<A>();
  public void add(A o) {
    t = new NextNode<A>(o, t);
  }
  public void remove(A o) {
    t = (Node<A> :wink:  t.accept(new Remove<A>(o));
  }
}

my problem is the lack of type casting give compiler warnings, warnings which I have really no idea how to handle? Casting down to what becomes raw types give me a, kind of, headache. Or at least the compiler thins so. Could anyone give me an idea on how to handle casts (with-) in type parameters correctly, that will not give unsafe type conversions? Any short sample will do, not necessarily referring to the above. (My prevois experience derives from logic, but here the logic seems to be only erasure compatible with ordinary Java. Hm.)

Regards!
/Set Lonnert

[Jeanne Boyarsky]

Set,
Welcome to JavaRanch!

Are you compiling in 1.5 compatibility mode? What kind of compiler warnings do you get?

[Set Lonnert]

Thanks for having me

Yes I compile using the 1.5 or whatever version numbering they use these days. These are approx. the warnings I get:

// code
class Remove<A> implements NodeVisitor<A> {
  A o;
  Remove(A _o) {
    o = _o;
  }
  // ----
  public <A> Node<A> forEmptyNode(EmptyNode that) {
    return new EmptyNode<A>();
  }
  public <A> Node<A> forNextNode(NextNode that) {
    if (o.equals(that.t)) {
      return that.n.accept(this); // <-- line 42
    } else {
      return new NextNode(that.t,  // <-- line 44 &
        (Node) that.n.accept(this)); // <-- line 44
    }
  }
}
// end of code
 

// compiler warnings
   Line 42:
 
warning: [unchecked] unchecked call to
<A>accept(NodeVisitor<A> :wink:  as a member of the raw type Node
      return that.n.accept(this);
 
warning: [unchecked] unchecked conversion
found   : Node
required: Node<A>
      return that.n.accept(this);
 
// and
  Line 44:
 
warning: [unchecked] unchecked call to
<A>accept(NodeVisitor<A> :wink:  as a member of the raw type Node
      return new NextNode(that.t, (Node) that.n.accept(this));
                                                      ^
warning: [unchecked] unchecked call to
NextNode(A,Node) as a member of the raw type NextNode
      return new NextNode(that.t, (Node) that.n.accept(this));
             ^
warning: [unchecked] unchecked conversion
found   : NextNode
required: Node<A>
      return new NextNode(that.t, (Node) that.n.accept(this));
             ^

Should there be wrappers to avoid implicit conversions to raw types (most frequent
warning), or should there perhaps be a wildcard somewhere (as mentioned, I don't yet
understand its significance)? Any ideas are most welcome ...

Regards!
/Set Lonnert
PS. I was here years ago, but then there were to few to mention
.. no talk to I mean