标签: composition

在 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 的组合方式是什么？

最近，我看到了两篇关于 mixin 的文章。这让我在哪个比另一个更好之间感到困惑。

第一个来自mdn

var calculatorMixin = Base => class extends Base {
  calc() { }
};
var randomizerMixin = Base => class extends Base {
  randomize() { }
};

class Foo { }
class Bar extends calculatorMixin(randomizerMixin(Foo)) { }

来自https://javascript.info/mixins 的第二个

let sayMixin = {
  say(phrase) {
    alert(phrase);
  }
};

let sayHiMixin = {
  __proto__: sayMixin, // (or we could use Object.create to set the prototype here)

  sayHi() {
    // call parent method
    super.say(`Hello ${this.name}`);
  }, …

我正在阅读一篇关于组合与继承的文章，该文章使用术语“域类”和“实现类”。作者特别说“领域类应该使用实现类，而不是从它们继承”。请解释域类和实现类之间的区别。

在我最后一个问题下方的评论中详细说明讨论：我正在寻找有关构建 SWI-Prolog 代码的技术或最佳实践的建议，以便能够使用和测试算法及其支持模块的替代、可互换实现。

当前情况可以使用以下虚构的小示例来说明：用户提供一些输入数据 (file data.pl) 并加载具有要应用的算法(file ) 的模块graph.pl。算法模块本身使用来自另一个模块（文件path.pl）的辅助谓词，而后者又需要访问用户提供的数据：

文件“ data.pl”（输入数据集）：

:- use_module(graph).

edge(a,b).
edge(b,c).
edge(c,d).

文件“ graph.pl”（算法）：

:- module(graph, [reachable/2]).
:- use_module(path).

reachable(X,Y) :-
    path(X,Y), !.
reachable(X,Y) :-
    path(Y,X), !.

文件“ path.pl”（带有辅助谓词的模块，注意它访问 中的数据user）：

:- module(path, [path/2]).

path(X,X).
path(X,Y) :-
    user:edge(X,Z),
    path(Z,Y).

对于将算法应用于单个输入数据集和算法的单个实现的用例，这完全没问题：

?- [data].
true.

?- reachable(a,a).
true.

?- reachable(a,d).
true.

?- reachable(d,a).
true.

现在假设我有大量的数据集，以及graph和path模块的多个替代实现（具有相同的接口，即导出的谓词）。对于（小）举例的目的，让我们假设我们文件中的数据文件data1.pl，data2.pl，帮手谓语模块path1.pl，path2.pl和算法模块 …

我尝试使用下面的语法在ES6嵌套类时得到代码完成工作：class Dog extends FoodMixin(Animal)。第一个实现工作正常，让我自动完成 FoodMixin 和 Animal。但是，如果我将它嵌套得更深，或者应用第二个 mixin，自动完成就会停止。例如：class Dog extends OtherMixin(FoodMixin(Animal))将丢失 FoodMixin 类的代码完成。

有没有一种方法可以让 OtherMixin 和 FoodMixin 的智能感知工作？

简单的测试代码：

const FoodMixin = superclass => class extends superclass {
    eat() {
        console.log("Eating");
    }
};

const OtherMixin = superclass => class extends superclass {
    test() {
        console.log("Hello");
    }
};

class Animal {
}

class Dog extends OtherMixin(FoodMixin(Animal)){
}

const dog = new Dog();
dog.test(); //INTELLISENSE WORKS
dog.eat(); //INTELLISENSE DOES NOT WORK

我创建了一个将函数链接在一起的函数。我创建了一堆通用类型来正确关联结果函数可以具有的参数。您可以在此处阅读有关此范例的更多信息、我正在寻找的内容以及我创建它的原因。

一切正常……到了一定程度。由于我生成类型的方式，当链变得太长时，TypeScript 会失败。我正在寻找一种方法来缓解这个问题。

我收到此错误：

Type instantiation is excessively deep and possibly infinite.

毫无疑问，这对于 TypeScript 来说太多了，而且随着每个函数的添加，类型映射呈指数级增长。

我意识到这段代码相当复杂，所以我不是在寻找完整的技术解决方案，只是寻找一种更符合 TypeScript 的/算法更简单的方法来做同样的事情。

namespace Poly {
    export type Omit<T, K extends string | number | symbol> = { [P in Exclude<keyof T, K>]: T[P]; }
}

namespace Use {
    type ThenArg<T> = T extends Promise<infer U> ? U : T
    type RelatedThen<A, B> = A extends Promise<infer U> ? Promise<B> : B
    export type Func = (...args: any[]) => any
    export type Return<A extends …