标签: composition

我写了一个函数“rep”，它接受一个函数 f 并接受 f 的 n 个组合。所以rep(square,3)的行为如下：square(square(square(x)))。当我将 3 传递给它时，rep(square,3)(3)=6561。

我的代码没有问题，但我想知道是否有一种方法可以使其“更漂亮”（或更短），而不必调用另一个函数或导入任何内容。谢谢！

def compose1(f, g):
    """Return a function h, such that h(x) = f(g(x))."""
    def h(x):
        return f(g(x))
    return h

def rep(f,n):
    newfunc = f
    count=1
    while count < n:
        newfunc = compose1(f,newfunc)
        count+=1
    return newfunc

考虑以下示例：

• 我们有订单，任何订单都可以有不同的类型。
• 订单有交易，每种订单可以分配n笔交易。

例如：

OrderA 必须有一笔交易。

OrderB 必须有两笔交易。

OrderC 可以有 n 笔交易。

当我们更新订单的价值时，我们需要根据算法特定的订单类型来计算交易的价值。

我们如何为这种情况设计模型？我们可以在aggregateRoot中使用继承还是我们应该使用组合？例如 ？

 /// <summary>
///     AggregateRoot
/// </summary>
public abstract class Order
{
    protected ISet<Transaction> _transactions;

    public IEnumerable<Transaction> Transactions
    {
        get { return _transactions; }
    }

    public abstract OrderType OrderType { get; }
    public decimal? Value { get; protected set; }

    public void SetValue(decimal? value)
    {
        Value = value;
        UpdateReleatedTransaction();
    }

    protected abstract void UpdateReleatedTransaction();
}

public class OrderA : Order
{
    public OrderA()
    {
        _transactions.Add(new Transaction(this)); …

我在Haskell中定义了一个函数,该函数应该是正方形,然后在给定列表中的所有数字上加1.我想用函数组合编写该函数但不幸的是它不适用于dot beetwen函数但它在我写的时候有效我的函数括号.我不明白为什么它不适用于dot或者更确切地说它不适用于函数组合？

square :: Int -> Int
square x = x * x

funSqr :: [Int] -> [Int]
funSqr xs = [(square x) | x <- xs]

funAdd1 :: [Int] -> [Int]
funAdd1 xs = [(x + 1) | x <- xs]

funFoldr :: [Int] -> Int 
funFoldr [] = 0
funFoldr (x:xs) = x + (funFoldr xs)

fun :: [Int] -> Int
fun xs = funFoldr(funAdd1(funSqr xs))

但

fun :: [Int] -> Int
fun xs = funFoldr.funAdd1.funSqr xs  --Why …

假设我有一些功能Int => Option[Int]:

val f1: Int => Option[Int] = x => if (x < 10) Some(x + 1) else None
val f2: Int => Option[Int] = x => if (x < 10) Some(x + 2) else None
val f3: Int => Option[Int] = x => if (x < 10) Some(x + 3) else None

现在,我想他们撰写并作出新的功能,其累积的中间结果,即结果f1,f2和f3.

所以我添加了一个新类Accumulator:

class Accumulator(x: Int) {
  val ox1 = f1(x)
  val ox2 = ox1.flatMap(f2) …

几周以来,我一直试图弄清楚Haskell编译器如何将(.)应用于fmap.

我的意思是.

:t (.)
(.) :: (b -> c) -> (a -> b) -> a -> c

:t fmap
fmap :: Functor f => (a -> b) -> f a -> f b

:t (.) fmap
(.) fmap :: Functor f => (a -> a1 -> b) -> a -> f a1 -> f b

编译器是如何得到(.)fmap的类型的？

我实际上是在这里问这个问题但是当我解释我尝试过的时候,所有这些都在一起.所以现在我也要发布答案了.

我想做一些函数组合。我已经知道这一点：

如果f3(x)应该和f1(f2(x)) 那时一样f3 = _.flowRight(f1,f2);

如果f3(x,y)和f1(x, f2(y)) 那时一样……？

（用例是 node.js/express 中间件函数的组合。）

我试图了解C ++中组成与继承之间的语法差异。

我希望有人会提供两个简单的例子。使用组成的类的一个示例，使用继承的类的一个示例。

假设我有两个函数f，g它们都接受常规值并返回一个Either像这样的值：

g :: a -> Either x b
f :: b -> Either x c

我如何将两者链接在一起以获得类似的东西f . g？

我想出的最佳解决方案是创建一个名为的辅助函数applyToRight，其工作方式如下

applyToRight :: (a -> Either x b) -> Either x a -> Either x b
applyToRight f x =
  case x of
    Left a -> Left a
    Right b -> f b

这样我就可以做

applyToRight f (g a)

在这种情况下，我专门谈论Either，但我认为这个问题可以推广到所有应用函子。处理这个问题的最优雅的方法是什么？

在 Apple doc 中发现，该Codable协议由Encodable和组成Decodable。因此，

Codable = Encodable & Decodable

现在，假设我在下面的类中实现，

class X: Codable {
    var name: String
}

class Y: Encodable, Decodable {
    var name: String
}

class Z: Encodable & Decodable {
    var name: String
}

那么，类X、Y和之间是否存在功能差异Z？

如果没有尊重为什么我们不能&在 的地方使用,？

对于 UML 类图，如果一个类 A 与另一个类 B 具有组合关系，它是否像继承一样工作？我知道类A不能没有类b而存在，但是类A继承了类B的属性和方法吗？