Yet another reason for me to get my own copy of the GoF.

I'll comment on your suggestion below, but I wanted to re-emphasize
the point that I really would like to use generics for the their type-
safety in this case.  Recall the function prototype I mentioned in the
OP

public static <T, P> Distribution<P> conjugate( List<T> data,
Distribution<T> likelihood, Distribution<P> prior )

Fro, the perspective of enforcing mathematical correctness, it is
important to constrain the return type to be the same as the prior
parameters and force the data to be compatible with the likelihood.
Now, on to your (slightly edited) suggestion....

Ok, so we set up a base class (abstract in this example) where we
consider every possible distribution as a potential prior.  It will be
up to the implementing classes to override the conjugate cases
supported by their particular form.

Now, when we invoke .posterior(data, prior) for a distribution x, it
will visit the prior, passing itself along as a parameters.  Since we
invoke .visit() on the prior object, it will call the correct method,
i.e. normal or gamma or whatever.  Now, the prior calls back to the
likelihood object, passing itself.  This will give the type
specificity to actually call one of the polymorphic posterior()
methods.  Very nice!!  This is a double-dispatch pattern, correct?

Correct.  The particular bit of statistics I'm implementing here is
described at

http://en.wikipedia.org/wiki/Conjugate_prior

Very much!  I'll give your suggestion a whirl and see how it plays
out.

Many thanks.

Small point, but "Visitor pattern" is an application of the broadly useful
technique of double-dispatch (which can be called a pattern too, if you like,
though it isn't often seen that way).  In this case, I think, your suggestion
would be better seen as a direct application of double-dispatch, rather than an
application of Visitor -- and a better name could be found for the visit()
method (exposing what it /does/ rather than what feature of "Visitor" it
reflects).

A suggestion for the OP.  Design and implement this stuff without using
generics at all, then go back and put in the necessary generic declarations.
Double dispatch -- or whatever -- is part of the /semantics/ of your system,
whereas generics are just a way of telling the typechecker what rules correct
applications of those semantics will follow.  So unless generics make the
design/code easier to articulate in the first place (which I doubt in this
particular case), trying to keep the typechecker happy at the same time as
trying to think through the actual object interactions will be
counter-productive.

   -- chris

Daniel,

Thank to you suggestion, I have a functional prototype that I've
included in this post.  One question: In order for each class to
dispatch properly, *every* class has to implement the visit() method.
If there are subclasses that inherit from a parent class, the generic
posterior() class in the abstract Distribution class is invoked which
leads to an infinite loop.

It's just syntactic sugar, but is there a way to get around this
problem?  The only solution I could come up with is that the abstract
class would have to implement a posterior() method for every class
that extends Distribution, which is not feasible since new
Distribution sub-classes will be created.

Anyway, thanks for the insight.  Couldn't have gotten to this point
without eveyone's help.

P.S> The semantics of the Distribution.posterior() method is that
"this" is the prior distribution and we are attempting to combine it
with a likelihood.  This has a nice side effect that every posterior()
method in a class returns a Distribution<T> object rather than the
other way around of treating "this" as the likelihood and have to take
and return a Distribution<?> object.

/**
* Experiment with a conjugate class hierarchy
*/

import java.util.*;

public class Conjugacy
{
 static abstract class Distribution<T> {
   public <S> Distribution<T> posterior( List<S> data,
Distribution<S> likelihood ) {
     return likelihood.dispatch( data, this );
   }

   public Distribution<T> posterior( List<Double> data,
NormalUnknownMean likelihood ) {
     System.out.println( "FAIL" );
     return null;
   }

   public Distribution<T> posterior( List<Double> data,
NormalUnknownVariance likelihood ) {
     System.out.println( "FAIL" );
     return null;
   }

   public Distribution<T> posterior( List<Integer> data,
PoissonUnknownRate likelihood ) {
     System.out.println( "FAIL" );
     return null;
   }

   public abstract <S> Distribution<S> dispatch( List<T> data,
Distribution<S> prior );
 }

 /**
  * Create a normal, gamma and poisson distributions
  */
 static class Normal extends Distribution<Double> {
   public Distribution<Double> posterior( List<Double> data,
NormalUnknownMean likelihood ) {
     System.out.println( "mu ~ Normal ~ Normal-Normal" );
     return new Normal();
   }

   public <S> Distribution<S> dispatch( List<Double> data,
Distribution<S> prior ) {
     System.out.println( "FAIL" );
     return null;
   }
 }

 static class NormalUnknownMean extends Normal {
    public <S> Distribution<S> dispatch( List<Double> data,
Distribution<S> prior ) {
      return prior.posterior( data, this );
   }
 }

 static class NormalUnknownVariance extends Normal {
    public <S> Distribution<S> dispatch( List<Double> data,
Distribution<S> prior ) {
      return prior.posterior( data, this );
   }
 }

 // Gamma distribution
 static class Gamma extends Distribution<Double> {
   public Distribution<Double> posterior( List<Double> data,
NormalUnknownVariance likelihood ) {
     System.out.println( "sigma ~ Gamma ~ Normal-Gamma" );
     return new Gamma();
   }

   public Distribution<Double> posterior( List<Integer> data,
PoissonUnknownRate likelihood ) {
     System.out.println( "lambda ~ Gamma ~ Poisson-Gamma" );
     return new Gamma();
   }

   public <S> Distribution<S> dispatch( List<Double> data,
Distribution<S> prior ) {
     System.out.println( "FAIL" );
     return null;
   }
 }

 // Poisson distribution
 static class Poisson extends Distribution<Integer> {
   public <S> Distribution<S> dispatch( List<Integer> data,
Distribution<S> prior ) {
     System.out.println( "FAIL" );
     return null;
   }
 }

 static class PoissonUnknownRate extends Poisson {
    public <S> Distribution<S> dispatch( List<Integer> data,
Distribution<S> prior ) {
      return prior.posterior( data, this );
   }
 }

 public static void main( String[] args )
 {
   Distribution<Double>  normal      = new Normal();
   Distribution<Double>  gamma       = new Gamma();
   Distribution<Integer> poisson     = new Poisson();
   Distribution<Double>  normalMu    = new NormalUnknownMean();
   Distribution<Double>  normalSig   = new NormalUnknownVariance();
   Distribution<Integer> poissonRate = new PoissonUnknownRate();

   List<Double>  data1 = new ArrayList<Double>();
   List<Integer> data2 = new ArrayList<Integer>();

   System.out.println( "Using a Normal as a prior distribution" );
   normal.posterior( data1, normal );      // Fail
   normal.posterior( data1, gamma );       // Fail
   normal.posterior( data2, poisson );     // Fail
   normal.posterior( data1, normalMu );    // Pass
   normal.posterior( data1, normalSig );   // Fail
   normal.posterior( data2, poissonRate ); // Fail

   System.out.println();
   System.out.println( "Using a Gamma as a prior distribution" );
   gamma.posterior( data1, normal );      // Fail
   gamma.posterior( data1, gamma );       // Fail
   gamma.posterior( data2, poisson );     // Fail
   gamma.posterior( data1, normalMu );    // Fail
   gamma.posterior( data1, normalSig );   // Pass
   gamma.posterior( data2, poissonRate ); // Pass
 }
}