class SingletonComponent implements Component{
  private final Component c;
  private Object val;
  public Class getType(){
    return c.getType();
  }
  public synchronized Object create(Dependency dep){
    if(val!=null) return val;
    val = c.create(dep);
    return val;
  }
  public synchronized Class verify(Dependency dep){
    if(val!=null) return val.getClass();
    else return c.verify(dep);
  }
}

void A createA(){
  B b = new B(...);
  return new A(b,b, ...);
}

Component b_component = Components.ctor(B.class);
return new BoundComponent(b_component, new Binder(){
  public Component bind(Object b){
    final Component arg = Components.value(b);
    return new WithArgument(
      new WithArgument(a, 0, arg),
    1, arg);
  }
});

X createX(){
  A a = A.instance(...);
  if(a.isX(...)){
    return new X(...);
  }
  else{
    return new Y(a, ...).getX(...);
  }
}

Component a_component = Components.static_method(A.class, "instance");
return new BoundComponent(a_component, new Binder(){
  public Component bind(final Object a){
    final Component isx_component = Components.method(a, "isX");
    return new BoundComponent(isx_component, new Binder(){
      public Component bind(Object isx){
        final Boolean v = (Boolean)isx;
        if(v.booleanValue()){
          return Components.ctor(X.class);
        }
        else{
          final Coponent y_component =
           new WithArgument(Components.ctor(Y.class), 0,
              Components.value(a));
          return new BoundComponent(y_component, new Binder(){
            public Component bind(Object y){
              return Components.method(y, "getX");
            }
          });
         
        }
      }
    });
  }
});

new BoundComponent(c1, new Binder(){
  public Component bind(Object obj){
    return Components.method(obj, "method");
  }
});

c1.method("method");

new BoundComponent(c1, new Binder(){
  public Component bind(Object obj){
    if(((Boolean)obj).booleanValue()){
      return a;
    }
    else return b;
  }
});

c1.ifelse(a,b);

Component a_component = Components.static_method(A.class, "instance");
return a_component.bind(new Binder(){
  public Component bind(final Object a){
    final Component isx_component = Components.method(a, "isX");
    return isx_component.ifelse(
      Components.ctor(X.class),
      Components.ctor(Y.class)
        .withArgument(0, Components.value(a))
        .method("getX")
    );
  }
});

X createX(){
  A a = A.instance(...);
  if(a.isX(...)){
    return new X(...);
  }
  else{
    return new Y(...).getX(...);
  }
}

Component a_component = Components.static_method(A.class, "instance");
return a_component.method("isX").ifelse(
    Components.ctor(X.class),
    Components.ctor(Y.class)
      .withArgument(0, Components.value(a))
      .method("getX")
);

Y createY(){
  a = A.createA(...);
  b = B.createB(a, ...);
  c = C.createC(a,b,...);
  return Y.create(a,b,c,...);
}

do
  a <- static_method(A.class, "createA");
  b <- static_method(B.class, "createB")
    .withArgument(0, a);
  c <- static_method(C.class, "createC")
    .withArgument(0, a).withArgument(1, b);
  return (static_method(Y.class, "create")
    .withArgument(0,a).withArgument(1,b).withArgument(2,c);
  )

a <- createA
b <- createB a

createA >>= \a->createB a

interface Dependency{
  Object getArgument(int i, Class type);
  Class verifyArgument(int i, Class type);
  Object getProperty(Object key, Class type);
  Class verifyProperty(Object key, Class type);
}

interface Component{
  Class getType();
  Object create(Dependency dep);
  Class verify(Dependency dep);
}

interface Container{
  Component getComponent(Object key);
  Component getComponentOfType(Class type);
}

class ValueComponent implements Component{
  private final Object v;
  public Class getType(){
    return v==null?null:v.getClass();
  }
  public Object create(Dependency dep){
    return v;
  }
  public Class verify(Dependency dep){
    return getType();
  }
}

interface Function{
  Class getReturnType();
  Class[] getParameterTypes();
  Object call(Object[] args);
}

class Functions{
  static Function ctor(Constructor ctor);
  static Function method(Object obj, Method mtd);
  static Function static_method(Class type, Method mtd);
}

static Function ctor(Class type);

class FunctionComponent implements Component{
  private final Function f;
  public Class getType(){
    return f.getReturnType();
  }
  public Object create(Dependency dep){
    final Class[] types = f.getParameterTypes();
    final Object[] args = new Object[types.length];
    foreach(t:types){
      args[i] = dep.getArgument(i, t);
    }
    return f.call(args);
  }
  public Class verify(Dependency dep){
    final Class[] types = f.getParameterTypes();
    foreach(t:types){
      Class arg_type = dep.verifyArgument(i, t);
      checkTypeMatch(types[i], arg_type);
    }
    return f.getReturnType();
  }
}

class BeanComponent  implements Component{
  private final Class type;
  public Class getType(){
    return type;
  }
  public Object create(Dependency dep){
    Object r = createInstance();
    setJavaBeans(r,dep);
  }
  public Class verify(Dependency dep){
    ...
  }
}

class WithArgument implements Component{
  private final Component parent;
  private final int pos;
  private final Component arg;
  public Class getType(){
    return parent.getType();
  }
  public Object create(Dependency dep){
    return parent.create(withArg(dep));
  }
  public Class verify(Dependency dep){
    return parent.verify(withArg(dep));
  }
  private Dependency withArg(final Dependency dep){
    return new Dependency(){
      public Object getArgument(int i, Class type){
        if(i==pos){
          checkTypeMatch(type, arg);
          return arg.create(dep);
        }
        else return dep.getArgument(i, type);
      }
    }
    ...
  }
}

class WithProperty implements Component{
  private final Component parent;
  private final Object key;
  private final Component prop;
  public Class getType(){
    return parent.getType();
  }
  public Object create(Dependency dep){
    return parent.create(withProp(dep));
  }
  public Class verify(Dependency dep){
    return parent.verify(withProp(dep));
  }
  private Dependency withProp(final Dependency dep){
    return new Dependency(){
      public Object getProperty(Object k, Class type){
        if(k.equals(key)){
          checkTypeMatch(type, prop);
          return prop.create(dep);
        }
        else return dep.getProperty(k, type);
      }
    }
    ...
  }
}

interface Map{
  Object map(Object obj);
}

class MapComponent implements Component{
  private final Component c;
  private final Map map;
  public Class getType(){
    return null;
  }
  public Object create(Dependency dep){
    return map.map(c.create(dep));
  }
  public Class verify(Dependency dep){
    c.verify(dep);
    return Object.class;
  }
    ...
}

interface Binder{
  Component bind(Object obj);
}

class BoundComponent implements Component{
  private final Component c;
  private final Binder binder;
  public Class getType(){
    return null;
  }
  public Object create(Dependency dep){
    return binder.bind(c.create(dep)).create(dep);
  }
  public Class verify(Dependency dep){
    c.verify(dep);
    return Object.class;
  }
    ...
}

map(a, f) = bind (a, \x->value(f(x)));

return new ValueComponent(map.map(v));

class UseKey extends Component{
  private final Object key;
  public Object create(Dependency dep){
    //?????????
  }
  ....
}

interface Dependency{
  Object getArgument(int i, Class type);
  Object getProperty(Object key, Class type);
  Container getContainer();
}

Container.getInstance(Object key);

class UseKey extends Component{
  private final Object key;
  public Object create(Dependency dep){
     final Component c = dep.getContainer().getComponent(key);
     if(c==null)throw new ComponentNotFoundException(...);
     return c.create(dep);
  }
  ....
}

interface ParameterBinder{
  Component bind(int i, Class type);
}

class ParameterBoundDependency implements Dependency{
  private final Dependency dep;
  private final ParameterBinder binder;
  public Object getArgument(int i, Class type){
    return binder.bind(i, type).create(dep);
  }
  ...
}

ParameterBoundComponent extends Component{
  private final Component c;
  private final ParameterBinder binder;
  public Object create(Dependency dep){
    return c.create(new ParameterBoundDependency(dep, binder));
  }
  ...
}

Component x = ...;
Component x2 = x.bind(new ParameterBinder(){
  public Component bind(int i, Class type){
    if(type.equals(A.class)){
      return Components.useKey("a1");
    }
    else{
      //???? 行1
    }
  }
});

Component x = ...;
Component x2 = x.bind(new ParameterBinder(){
  public Component bind(int i, Class type){
    if(type.equals(A.class)){
      return Components.useKey("a1");
    }
    else{
      return Components.useArgument(i, type);// 行1
    }
  }
});

class UseArgument extends Component{
  private final int i;
  private final Class type;
  public Object create(Dependency dep){
    return dep.getArgument(i, type);
  }
  .....
}

Component withArgument(Component c, final int i, final Component arg){
  return c.bind(new ParameterBinder(){
    public Component bind(int k, Class type){
      if(k==i) return arg;
      else return Components.useArgument(k, type);
    }
  });
}

c.withArguments(new Component[]{c1, c2, c3});

Component withArguments(final Component[] args){
  return bind(new ParameterBinder(){
    public Component bind(int i, Class type){
      return args[i];
    }
  });
}

new ClassX(..., Loggers.instance(ClassX.class), ...);

interface Factory{
  String create();
}
class PrefixLogger implements Logger{
  private final Logger logger;
  private final Factory factory;
  private boolean freshline = true;

  private void prefix(int lvl){
    if(freshline){
      Object r = factory.create();
      if(r!=null)
        logger.print(lvl, r);
      freshline = false;
    }
  }
  public void print(int lvl, String s){
    prefix(lvl);
    logger.print(lvl, s);
  }
  public void println(int lvl, String s){
    prefix(lvl);
    logger.println(lvl, s);
    freshline = true;
  }
  public void printException(int lvl, Throwable e){
    prefix(lvl);
    logger.printException(lvl, e);
    freshline = true;
  }
}

class TimestampFactory implements Factory{
  private final DateFormat fmt;
  public String create(){
    return fmt.format(new Date());
  }
}

interface SourceLocationFormat{
  String format(StackTraceElement frame);
}
class TraceBackFactory implements Factory{
  private final SourceLocationFormat fmt;
  public String create(){
    final StackTraceElement frame = getNearestUserFrame();
    if(frame!=null)
      return fmt.format(frame);
    else return null;
  }
  private StackTraceElement getNearestUserFrame(){
    final StackTraceElement[] frames = new Throwable().getStackTrace();
    foreach(frame: frames){
      if(!frame.getClassName().startsWith("org.mylogging")){
        //user frame
        return frame;
      }
    }
    return null;
  }
}

class ReturnFactory implements Factory{
  private final String s;
  public String create(){return s;}
}

class ConcatFactory implements Factory{
  private final Factory[] fs;
  public String create(){
    StringBuffer buf = new StringBuffer();
    foreach(f: fs){
      buf.append(f.create());
    }
    return buf.toString();
  }
}

Logger myprefix(Logger l){
  Factory timestamp = new TimestampFactory(some_date_format);
  Factory traceback = new TraceBackFactory(some_location_format);
  Factory both = new ConcatFactory(
    timestamp,
    new ReturnFactory(" - "),
    traceback,
    new ReturnFactory(" : ")
  );
  return new PrefixLogger(both, l);
}

class Boy{
  private final Girl girl;
  public Boy(Girl g){
    this.girl = g;
  }
...
}

picocontainer container = new DefaultContainer();
container.registerComponentImplementation(Boy.class);
container.registerComponentImplementation(Girl.class);

Object obj = container.getComponentInstance(Boy.class);

void A createA(){
  B b = new B();
  return new A(b,b);
}

container.registerComponent("b" new CachingComponentAdapter(new ConstructorInjectionComponentAdapter(B.class)));
container.registerComponent("a", new ConstructorInjectionComponentAdapter(A.class));

A createA(){
  B b = new B();
  return new A(b, b.createC(x_component));
}

b_component = Components.ctor(B.class).singleton();
a_component = Components.ctor(A.class)
  .withArgument(0, b_component)
  .withArgument(1, b_component.method("createC"));

if level > 1 then logger1 else logger2

ignore(1, logger1, logger2);

public class StreamLogger {
  private final OutputStream out;
 
  /**
   * To create a StreamLogger object.
   * @param out the OutputStream object that the log message should go to.
   */
  public StreamLogger(OutputStream out) {
    this.out = out;
  }
 
  /**
   * To get the OutputStream that the log messages should go to.
   */
  public OutputStream getStream() {
    return out;
  }
  private static Logger getBaseLogger(PrintWriter writer){
    final Logger nop = new NopLogger();
    final Logger base = Loggers.logger(writer);
    final Logger neptune_logger = new NeptuneExceptionLogger(writer, nop);
    final Logger jaskell_logger = new JaskellExceptionLogger(writer, nop);
    return Loggers.sequence(
        new Logger[]{neptune_logger, jaskell_logger, base}
    );
  }
  private static Logger getEchoLogger(PrintWriter writer){
    return new ErrorMessageLogger(writer);
  }
  private static Logger getErrorLogger(PrintWriter writer){
    final Logger err_logger = new ErrorMessageLogger(writer);
    final Logger jaskell_logger = new JaskellExceptionLogger(writer, err_logger);
    final Logger neptune_logger = new NeptuneExceptionLogger(writer, jaskell_logger);
    return neptune_logger;
  }
  /**
   * Get the Logger instance.
   * @param min_level the minimal critical level for a log message to show up in the log.
   * @return the Logger instance.
   */
  public Logger getDefaultLogger(int min_level){
    final PrintWriter writer = new PrintWriter(out, true);
    final PrintWriter err = new PrintWriter(System.err, true);
    final PrintWriter warn = new PrintWriter(System.out, true);
    final Logger all = Loggers.sequence(new Logger[]{
        Loggers.ignore(getErrorLogger(err), Logger.ERROR),
        Loggers.filter(getEchoLogger(warn), Logger.WARNING),
        getBaseLogger(writer)
      }
    );
    return Loggers.ignore(all, min_level);
  }
}

  all_logger = ignore messages below ERROR for getErrorLogger(err);
          filter messages except WARNING for getEchoLogger(warn);
          baseBaseLogger(writer);
  ignore messages below lvl for all_logger;

interface Logger{
  println(int level, String msg);
  printException(Throwable e);
}

class NopLogger implements Logger{
  public void println(int level, String msg){}
  public void printException(Throwable e){}
}

class FileLogger implements Logger{
  public void println(int level, String msg){
    write msg to log file.
  }
  public void printException(Throwable e){
    write exceptioon to log file.
  }
}

class WriterLogger implements Logger{
  private final PrintWriter writer;
  public void println(int level, String msg){
    writer.println(msg);
  }
  public void printException(Throwable e){
    e.printStackTrace(writer);
  }
  WriterLogger(PrintWriter writer){
     this.writer = writer;
  }
}

class SequenceLogger implements Logger{
  public void println(int level, String msg){
    foreach(l: loggers){
      l.println(level, msg);
    }
  }
  public void printException(Throwable e){
    foreach(l:loggers){
      l.printException(e);
    }
  }
  private final Logger[] loggers;
  SequenceLogger(Logger[] ls){
    this.loggers = ls;
  }
}

class FilteredLogger implements Logger{
  private final Logger logger1;
  private final Logger logger2;
  private final int lvl;
  public void println(int level, String msg){
    if(level==lvl)logger1.println(level, msg);
    else logger2.println(level, msg);
  }
  public void printException(Throwable e){
    if(lvl==ERROR) logger1.printException(e);
    else logger2.printException(e);
  }
}

class IgnoringLogger implements Logger{
  private final Logger logger1;
  private final Logger logger2;
  private final int lvl;
  public void println(int level, String msg){
    if(level>=lvl)logger1.println(level, msg);
    else logger2.println(level, msg);
  }
  public void printException(Throwable e){
    if(lvl<=ERROR) logger1.printException(e);
    else logger2.printException(e);
  }
}

class ErrorMessageLogger implements Logger{
  private final PrintWriter out;
  private final Logger logger;
  public void println(int level, String msg){
     logger.println(level, msg);
  }
  public void printException(Throwable e){
     out.println(e.getMessage());
  }
}

class NeptuneExceptionLogger implements Logger{
  private final PrintWriter out;
  private final Logger logger;
  public void println(int level, String msg){
    logger.println(level, msg);
  }
  public void printException(Throwable e){
    if(e instanceof NeptuneException){
      ((NeptuneException)e).printExecutionTrace(out);
    }
    else{
      logger.printException(e);
    }
  }
}

class JaskellExceptionLogger implements Logger{
  private final PrintWriter out;
  private final Logger logger;
  public void println(int level, String msg){
    logger.println(level, msg);
  }
  public void printException(Throwable e){
    if(e instanceof EvaluationException){
      ((EvaluationException)e).printEvaluationTrace(out);
    }
    else{
      logger.printException(e);
    }
  }
}

class TimestampLogger implements Logger{
  private final Logger logger;
  public void println(int level, String msg){
    logger.println(level, new Date().toString()+": " + msg);
  }
  public void printException(Throwable e){
    logger.println(ERROR, new Date().toString()+": ");
    logger.printException(e);
  }
}

class TimestampLogger implements Logger{
  private final Logger logger;
  private boolean freshline = true;
  private void printTimestamp(int level){
    if(freshline){
      logger.print(level, new Date().toString()+": ");
    }
  }
  public void print(int level, String msg){
    printTimestamp(level);
    logger.print(level, msg);
    freshline = false;
  }
  public void println(int level, String msg){
    printTimestamp(level);
    logger.println(msg);
    freshline = true;
  }
  public void printException(Throwable e){
    printTimestamp(ERROR);
    logger.printException(e);
    freshline = true;
  }
}

class Loggers{
  static Logger nop(){return new NopLogger();}
  static Logger writer(PrintWriter writer){
    return new WriterLogger(writer);
  }
  static Logger writer(OutputStream out){
    return writer(new PrintWriter(out, true));
  }
  static Logger filter(int lvl, Logger l1, Logger l2){
    return new FilteredLogger(lvl, l1, l2);
  }
  static Logger ignore(...){...}
  static Logger timestamp(...){...}
  ...
}

public interface Logger{
  void print(int level, String msg);
  void println(int level, String msg);
  void logException(Throwable e);
}

class SimpleLogger implements Logger{
  public void print(int lvl, String msg){
    System.out.print(msg);
  }
  public void println(int lvl, String msg){
    System.out.println(msg);
  }
  public void printException(Throwable e){
    e.printStackTrace();
  }
}