标签: composition

我在Haskell中创建了很多临时变量:

main = do
    let nums'' = [1..10]
    let nums' = a . bunch . of_ . functions $ nums''
    let nums = another . bunch . of_ . functions $ nums'
    print nums

也就是说,我不想写这么长的函数链:

let nums = another . bunch . of_ . functions . a . bunch . of_ . functions $ [1..10]

因为它对我来说变得难以理解,所以我尝试根据它们的作用对功能进行分组.在这个过程中,我最终创建了一堆丑陋的临时变量,例如nums''和nums'(我可以给它们更有意义的名称,但这一点仍然有效......每一条新行都意味着一个新的变量).这是一个阴影变量会导致更清晰的代码的情况.我想做点什么:

let nums = [1..10]
nums = a . bunch . of_ . functions $ nums
nums = another . bunch …

我正在写一个简单的游戏,很多游戏对象共享属性.我有两个可能的实现.

第一种是使用继承,如下图所示:

正如您所料,粗体类是抽象类.分支是实际使用的派生类.重要的是要注意这些类包含有关对象的数据,没有与它们相关的功能.

例如,部队和车辆有一个共同的界面,他们都用它来做诸如attack()和move()之类的事情.上面列出的类层次结构只是原始统计数据.此外,它们都是真正的ISA关系.

第二种实现使用组合.而不是上面的类层次结构,每个抽象类都是包含某些数据成员的"模块".因此,SpecialAbility有一个名为PointsValueObject的数据成员(虽然我更改了抽象的名称(尽管它们不再是抽象的),以反映它们的模块/属性性质).而且Troop有数据成员:PointsValueObject,PhysicalObject,PhysicalAttackObject和BattleOBject,它们每个都是存放有关部队数据的模块.同样,这些模块中不存在任何功能,它们仅用于存储数据.行为和功能仍然通过接口类实现.

我的问题是:人们通常更喜欢组合而不是继承,但在这种情况下,我倾向于坚持继承,因为ISA关系成立并且层次结构不包含行为,只包含数据.这个层次结构是好的OOD还是使用属性'modules'构建类更好？

我有一个列表,我希望过滤结果.

用户可以为行上的任何属性提供特定限制(例如,我只想查看x == 1的行).如果它们没有指定限制,那么当然不使用谓词.当然,最简单的形式是:

list.filter(_.x == 1)

有许多可能的简单谓词,我正在构建一个新的谓词函数,其代码将用户搜索项(例如Option [Int])转换为谓词函数或Identity(返回true的函数).代码看起来像这样(缩短了,为了清楚起见添加了显式类型):

case class ResultRow(x: Int, y: Int)

object Main extends App {
  // Predicate functions for the specific attributes, along with debug output
  val xMatches = (r: ResultRow, i: Int) => { Console println "match x"; r.x == i }
  val yMatches = (r: ResultRow, i: Int) => { Console println "match y"; r.y == i }
  val Identity = (r : ResultRow) => { Console println "identity"; true }

  def makePredicate(a: …

LinkedIn上的人们一直在以有趣的方式使用Play来处理需要由许多不同组件组成的页面:http://engineering.linkedin.com/play/composable-and-streamable-play-apps

他们如何做到的关键组成部分是Play中的"动作"返回完整的响应,因此能够通过更高级别的动作"组合"成另一个响应.

Grails似乎并没有真正从动作中返回任何东西(或者至少没有任何特定的东西),并且当你在一个动作中时,没有一种简单的方法可以调用另一个动作.

那么,Grails可以采用这种构图方式吗？

我正在取一些我在 VS2010 中编写的 MEF 代码，并在 VS2012 中再次编写它。不幸的是，我卡在了这个简单的界面上：

  public interface IModulesContainer
  {
    [ImportMany]
    IEnumerable<Lazy<IModule, IModuleMetadata>> Container { get; }
  }

VS2012 在这方面有一个编译错误：

Error   Using the generic type 'System.Lazy<T>' requires 1 type arguments

我知道有两个 System.Lazy<> 泛型类，一个采用一种参数类型，另一个采用两种（第二个是元数据）。

我不知道如何让 VS2012 识别后一类。（两者都在 System 命名空间下）

VS2010 看到它就好了。我错过了什么？

提前致谢，--埃里克

在 Prolog 中玩弄镜头。镜头是一种显微镜，可以放大结构并以功能方式进行一些读取或写入。基本上我的出发点是以下 Prolog 中 setter 和声明性 getter 的建模：

消气：只是<closure>，
被称为call(<closure>, X, Y)，这将检索该值Y从X。

声明式设置器：相同<closure>但使用不同的元数，
称为 as call(<closure>, X, Y, Z)，这将X通过一个新值更新 并Y给出一个新的Z。

我很快就得出了镜头合成运算符 @ 的定义，它可用于将两个镜头组合成一个新镜头，仅基于它们的闭合。附录中提供了一个示例和定义。但根据这篇文章，镜头可以简单地合成。

在我看来，当某些东西是合成的时，它可以很容易地通过 DCG 建模。我可以按如下方式为 getter 执行此操作，但我还没有找到为声明性 setter 执行此操作的方法：

/* Getter composition as DCG */
@(C1, C2) --> 
     call(C1),
     call(C2).

我将如何在 DCG 中对 setter 组合进行建模？这是可能的，也许会改变 getter 和 declarative setter 如何建模的初始假设，以便结果只是组合？

此致

附录：以下是一些 setter 和 getter 的示例：

/* …

Python 有一个非常有用的函数装饰器特性，而且它允许组合。例如，如果编写一个函数foo，那么您可以声明您希望foo被记忆，但也可以通过以下方式重试 多次，以防缓存未命中foo并引发异常：

@lru_cache
@retry
def foo(...):

装饰器可组合性允许foo独立开发功能和单独的功能装饰器，然后根据需要混合它们。如果我们也可以在 C++ 中这样做（在可能的范围内），那就太好了。

虽然 StackOverflow 上有几个关于函数装饰器的问题，但由于对装饰函数签名的严格假设，它们似乎都生成了不可组合的问题。例如，考虑一下这个问题的最佳投票答案。装饰的形式

template <typename R, typename... Args>
std::function<R (Args...)> memo(R (*fn)(Args...)) {

因此，它不能应用于其自身的结果（对于 memoization 的特定装饰器使用，诚然不是太大的问题）。

那么，我们如何编写可组合的函数装饰器呢？

我是 Swift 的新手，我想知道该语言是否有一些等效于 Python 的装饰器模式。
例如：

import functools


def announce(func):
    """Print a function's arguments and return value as it's called."""
    @functools.wraps(func)
    def announced_func(*args, **kwargs):
        rv = func(*args, **kwargs)
        print('In: {0}, {1}'.format(args, kwargs))
        print('Out: {}'.format(rv))
        return rv
    return announced_func


@announce  # add = announce(add)
def add(a, b):
    return a + b

add(2, 5)
# In: (2, 5), {}
# Out: 7
# 7

也许我只是还没有找到它，但 Swift 似乎没有办法将任意参数转发给函数或保留包装函数的信息（如 functools.wraps 那样）。

是否有等价物，或者该模式不打算在 Swift 中使用？

我的 Android 项目中有复杂的多层架构。

目前我想使用以下 DI 组件和模块的结构：

[Data Layer]
    @DataScope //scope is used for caching (Singleton) some Data Layer entities for whole application
    - DataComponent //exposes just interfaces which should be used on the BL Layer
        //Modules exposes entities for internal (Data Layer) injections and entities which exposed by DataComponent for BL Layer
        * DataModule1
        * DataModule2
        * DataModule3

[Business Logic Layer] (also has component dependency on DataComponent)
    @BlScope //scope is used for caching (Singleton) some BL Layer entities for whole …

我现在很清楚 mixin 和继承通常被认为是不好的，组合是要走的路，这来自：

https://medium.com/@dan_abramov/mixins-are-dead-long-live-higher-order-components-94a0d2f9e750

https://facebook.github.io/react/blog/2016/07/13/mixins-thinked-harmful.html

现在，当您发现两个专用于不同事物的组件并且您想要一个是两种行为混合的结果的组件时，该怎么办？例如，我想要一个 textarea，当文本超出初始行时，它会自动增长，并允许在里面提及（又名。react-mentions与混合react-textarea-autosize）

• 我应该如何以有效的方式组合两者？
• 我应该编写一个全新的组件来复制/合并两个组件的内部代码吗？
• 在这种情况下，ReactJs 的组合方式是什么？