当前位置:首页 > 开发 > 编程语言 > 编程 > 正文

论面向组合子程序设计方法 之 monad

发表于: 2005-08-13   作者:ajoo   来源:转载   浏览次数:
摘要: 仍然是先用oo把轮廓划出来,我们需要建模一个接口来围绕它进行组合。 因为本文是关于co的论述,那么这个接口怎样分析出来的就暂时忽略掉了: interface Dependency{ Object getArgument(int i, Class type);; Class verifyArgument(int i, Class type);; Object get
仍然是先用oo把轮廓划出来,我们需要建模一个接口来围绕它进行组合。

因为本文是关于co的论述,那么这个接口怎样分析出来的就暂时忽略掉了:

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

这个Dependency接口由每个不同的组件调用,来解决依赖。如果解析失败,则抛出异常。此处,我们暂时忽略异常这个细节。

getArgument负责解析一个函数参数,组件告诉Dependency对象,我需要给第3个参数,类型为String的解析依赖。于是就调用
getArgument(2, String.class)。

getProperty负责解析一个用某个key来标识的属性。比如一个javabean的property。

那两个verify是只取得解析到的那个符合要求的组件类型,但是并不实际创建对象。


然后是Component接口。这里,为了名字简短,我们不用ComponentAdapter这么恶长的名字,直接就是Component好了。


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



getType()用来返回这个Component生成的对象的类型。
create用来创建这个对象。
verify用来保证这个对象可以被创建。

至于容器接口,再简单不过了。我们都知道pico不过是个hash table,yan的容器也差不多,虽然多几个getComponentOfType()的方法,但是大体上就是一个hash table。

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



好了。oo完毕。下面来co。


首先,最简单的Component是什么?什么也不干,直接返回一个值。
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();;
  }
}


稍微难啃点的,是构造函数和工厂方法。这两个都会调用Dependency的getArgument()来取得自己需要的参数实例。
实际上,java的reflection api里面的Method和Constructor还是有很多相似点的。
为了抽取共性,我们定义一个新的接口,叫做Function:

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


这里,我就不展现把Method和Constructor匹配为Function的代码了,因为应该一目了然。
我们只要知道我们现在可以有三个函数产生Function对象:

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



然后是FunctionComponent。
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();;
  }
}


然后一个基本的component应该是java bean的setter了,对应pico的SetterInjectionComponentAdapter,也对应spring的bean。
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);{
    ...
  }
}

具体的实现我省略了很多。因为会调用java.beans的api,并且会有一些caching优化的考虑,但是思路上很清楚,就是对每个property调用getProperty()就是了。


好,最基本的就这么几个了(其实,bean component并不是最基本的,后面我们会看到)。

下面看看都有些什么组合规则。

1。手工指定某个参数。
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);;
      }
    }
    ...
  }
}


好,通过decorate这个Dependency对象,我们得到了手工制定某个参数的能力。
这里,我们对参数仍然用Component,而不是一个简单的Object作为这个参数的值,是因为参数本身也可能需要创建,它的依赖关系也可能需要在Dependency对象中解析。如果参数不需要创建,那么,你尽可以用ValueComponent来包装一下。


2。手工指定property的值。跟上面的代码非常类似,就是重载了getProperty()和verifyProperty()。
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);;
      }
    }
    ...
  }
}



3。和很多组合子一样,map是一个相当有用的组合规则。它负责把一个Component返回的对象作一下额外的处理,transform成另外一个对象。
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;
  }
    ...
}


注意,这里,因为我们无法预先知道Map这个接口返回的对象会是什么类型,所以,我们让getType()返回null来标示这是一个动态决定的组件类型。

4。比map更一般化一点的,是bind动作。所谓bind,也是根据一个Component创建的对象来决定接下来返回什么动作。不同的是,它用这个对象来产生另外一个Component,让这个Component来生成一个新对象。多说无益,让我们看代码:
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;
  }
    ...
}

这个Binder接口看似简单,但是它的存在对整个co都是生死攸关的大事。可以说,如果没有这个Binder, co就基本可以不存在了。
为什么这么说呢?因为这个binder再加上前面的那个ValueComponent代表了一种非常一般性的计算模型:monad。有一个专门的数学分支:组论,就是研究monad的。
它虽然不是放之四海皆准的计算模型,比如,有比它更为一般性的Arrow模型。但是,用它几乎可以描述我们一般所遇到的大量问题。

除了前面的几个基本组合子之外,几乎所有的组合子,如果我们愿意,都可以从这个bind推衍出来。比如上面的map,如果用简洁点的函数式语法来表述的话(原谅我还是忍不住用函数式,java的语法就象一砣一砣屎一样压得我喘不过气来)
map(a, f); = bind (a, \x->value(f(x);););;

这个代码的意思是说,你可以很轻易地把一个Map对象adapt到Binder对象,只要在bind函数里面调用:
return new ValueComponent(map.map(v););;

就行了。

后面的很多组合子,比如对一个组件生成的对象调用某个方法,设置一些java bean setter,都是从这个bind组合子衍生出来的。


好了,今天时间紧迫,到此告一段落吧。

论面向组合子程序设计方法 之 monad

  • 0

    开心

    开心

  • 0

    板砖

    板砖

  • 0

    感动

    感动

  • 0

    有用

    有用

  • 0

    疑问

    疑问

  • 0

    难过

    难过

  • 0

    无聊

    无聊

  • 0

    震惊

    震惊

编辑推荐
有时候我们需要维护一些对象,这些对象具有一定的层次结构,它们之间虽然差异很大,但在使用的时候
Composite 组合模式主要是应对这 样的问题:一类具有“容器特征”的对象——即他们在充当对象的同时
有时候我们需要维护一些对象,这些对象具有一定的层次结构,它们之间虽然差异很大,但在使用的时候
有时候我们需要维护一些对象,这些对象具有一定的层次结构,它们之间虽然差异很大,但在使用的时候
Composite 组合模式主要是应对这 样的问题:一类具有“容器特征”的对象——即他们在充当对象的同时
面向对象的方法学所存在的问题 面向对象方法目前是软件工程学中的主流方法论之一,但在实际运用中,
  英文原文: A Web API Design Methodology    为 Web 设计、实现和维护 API 不仅仅是一项挑战
我最近在做某一个开源产品的项目,项目组的开发方式是敏捷开发+TDD。 项目场景:开发一套开源的持续
转载请注明出处:http://blog.csdn.net/sinyu890807/article/details/9153761 此为Java设计模式透析
转载请注明出处:http://blog.csdn.net/sinyu890807/article/details/9153753 听说你们公司最近新推
版权所有 IT知识库 CopyRight © 2009-2015 IT知识库 IT610.com , All Rights Reserved. 京ICP备09083238号