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));

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"));

<xs:element name="onchange" minOccurs="0">
          <xs:complexType>
            <xs:sequence>
        <xs:element name="onchange-func" type="xs:string"/>
        <xs:element name="onchange-process" type="xs:string"/>
        <xs:element name="param-name" type="xs:string"/>
        <xs:element name="dest-name" type="xs:string"/>
        <xs:element name="dest-desc" type="xs:string"/>
        <xs:element name="dest-value" type="xs:string"/>
        <xs:element name="delete-name" type="xs:string" minOccurs="0" maxOccurs="unbounded"/>
            </xs:sequence>
          </xs:complexType>
        </xs:element>

if level > 1 then logger1 else logger2

ignore(1, logger1, logger2);