标签: composition

几个星期前,我和我的钢琴老师正在互相提出关于元音乐软件的想法.这个想法是这样的:

有一个系统从一堆乐器输入midi输入,并将输出推送到扬声器和灯.该系统上运行的软件分析它所获得的midi数据,并根据作曲家设置的触发器确定要使用的声音(当我在2秒钟内演奏F7和弦3次时,从大键琴声音切换到钢琴声音),踏板或音乐的实时实时分析.它将以类似的方式根据乐器的性能和声音控制灯光 - 音乐家只需模糊地指定他们想要的东西 - 并且他们演奏的实时分析将完成其余的工作.在程序上,程序生成的音乐也可以与音乐家一起播放.从本质上讲,该软件将与表演者一起演奏,其中一个指导另一个.

我是即兴爵士乐的忠实粉丝.其他艺术形式缺乏的即兴的一个特征是它的时间性.一幅画可以在画完10或1000年后欣赏,但音乐(特别是演奏音乐)与表演有关,因为它是创作.我认为我所描述的软件会对性能产生很大的影响,因为播放完全相同的部分每次都会导致完全不同的节目.

所以,现在提出问题.

我疯了吗？

是否存在可以执行任何或所有这些操作的软件？我做了一些研究,但没有发现任何事情.该系统的关键是它在性能期间运行.

如果我写这样的东西,像Python这样的脚本语言是否足够快以进行我需要的计算？据推测,它将在一个相当快速的系统上运行,并且可以利用英特尔不断发布的2 ^ n核心处理器.

你们中的任何人都可以分享你们与乐器和灯光等接口的经验和建议吗？

有任何想法或建议吗？冷酷而严厉的批评？

感谢您花时间阅读本文,以及任何建议!(对不起标签中的笑话,我无法抗拒.)

你能给我一个具体的例子,当我更喜欢使用私有继承而非组合时？就个人而言,我将使用组合而非私有继承,但可能存在这样的情况:使用私有继承是特定问题的最佳解决方案.阅读C++ faq,给出了一个使用私有继承的示例,但我似乎比私有继承更容易使用组合+策略模式甚至公共继承.

我正在使用JSF来呈现HTML页面.我像这样设计页面:

<f:view xmlns="http://www.w3.org/1999/xhtml"
  xmlns:ui="http://java.sun.com/jsf/facelets"
  xmlns:p="http://primefaces.org/ui"
  xmlns:h="http://java.sun.com/jsf/html"
  xmlns:f="http://java.sun.com/jsf/core">

<h:head>
    <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
    <meta name="language" content="fr" />
    <title><ui:insert name="title">My app</ui:insert></title>
</h:head>

<h:body>
    <div id="top">
        <ui:include src="/header.xhtml"/>
    </div>

    <h:panelGroup id="center" layout="block" >
        <ui:insert name="center"/>
    </h:panelGroup>

    <div id="bottom">
        <ui:include src="/footer.xhtml"/>
    </div>
</h:body>

此模板有一些"客户端"页面,如下所示:

<ui:composition xmlns="http://www.w3.org/1999/xhtml"
            xmlns:ui="http://java.sun.com/jsf/facelets"
            xmlns:h="http://java.sun.com/jsf/html"                
            xmlns:f="http://java.sun.com/jsf/core"
            xmlns:p="http://primefaces.org/ui"
            template="/layouts/master.xhtml">

<ui:define name="center">
    <ui:define name="title"><h:outputText value="#{myBean.description}"/></ui:define>
    <ui:include src="#{myBean.url}"/>
</ui:define>

在客户端,我必须在标题中添加元信息.如果我们有像outputScript或outputStylesheet这样的标签,可以在文档中的任何地方设置并在html"head"标签中呈现,那就太棒了.

我没有发现任何事情.当我处于这种情况时,有没有办法在标题中添加标记？谢谢 !

我正在尝试实现一个隔离对象的一部分的类,并用其他东西替换该部分.对象的一部分可能与对象本身的类型不同.

一个简单的例子是一个类,它接受字符串"--12--",隔离ascii数字,并用下一个自然数替换它.所以,整个序列将是"--12--" -> "12" -> 12 -> 13 -> "13" -> "--13--".

考虑到这一点,我实现了以下内容:

public abstract class Replacer<Outer, Inner>
    {
    protected abstract Inner decompose(Outer something);
    protected abstract Outer compose(Inner something);
    protected abstract Inner inner_replace(Inner something);
    public Outer replace(Outer something)
        {
        Inner s = decompose(something);
        s = inner_replace(s);
        return compose(s);
        }
    }

现在,我希望能够组成一系列替换器 - 将它们堆叠起来,以便每个人inner_replace使用"较低"的替换器来计算它:

public abstract class ComposableReplacer<Outer, Inner> extends Replacer<Outer, Inner>
    {
    protected Replacer<Inner, ?> child;

    @Override
    public Outer replace(Outer something)
        {
        Inner s = decompose(something); …

我正在使用Python中的两个类,其中一个应该被允许将来自另一个类的任何数字对象作为子项,同时将这些子项的清单作为属性保留.继承似乎是这个父<>孩子情况的明显选择,而是我所得到的是一个组合的例子.这是简化的代码:

class Parent():

    def __init__(self,firstname,lastname):
        self.firstname = firstname
        self.lastname = lastname
        self.kids = []

    def havechild(self,firstname):
        print self.firstname,"is having a child"
        self.kids.append(Child(self,firstname))

class Child(Parent):

    def __init__(self,parent,firstname):
        self.parent = parent
        self.firstname = firstname
        self.lastname = parent.lastname

所以基本上,虽然从Child()继承Child()似乎直觉上有意义,但删除继承并不会改变任何东西.我可以看到离开Child(Parent)而不仅仅是类Child()的唯一好处是,如果我需要向Parent添加更多方法,我希望Child继承.使用self.parent = parent,我已经可以访问Parent的任何其他未来属性.

有没有其他方法可以使用纯继承而不是将Parent实例传递给Child构造函数(组合)？

我正在尝试制作标签组件.TabsSwitcher和TabsPanel必须是单独的组件,因此它们可以在DOM中的任何位置使用,例如TabsSwitcher不必跟随TabsPanel.

为了使它工作,我需要以某种方式连接这些组件.此外,TabsSwitcher必须能够在单击选项卡时告诉TabsPanel.

/** @jsx React.DOM */

var TabsExample = React.createClass({
    render: function() {
        var tabs = [
            {title: 'first', content: 'Content 1'},
            {title: 'second', content: 'Content 2'}
        ];
        return <div>
            <TabsSwitcher items={tabs}/>
            <TabsContent items={tabs}/>
        </div>;
    }
});

var TabsSwitcher = React.createClass({
    render: function() {
        var items = this.props.items.map(function(item) {
            return <a onClick={this.onClick}>{item.title}</a>;
        }.bind(this));
        return <div>{items}</div>;
    },
    onClick: function(e) {
        // notify TabsContent about the click
    }
});

var TabsContent = React.createClass({
    render: function() {
        var items = this.props.items.map(function(item) {
            return …

定义取自这里

依赖

类的结构或行为的变化会影响其他相关的类,然后这两个类之间存在依赖关系.它不一定相同,反之亦然.当一个类包含另一个类时,就会发生这种情况.

组成

组合是聚合的特例.以更具体的方式,受限制的聚合称为组合.当一个对象 包含另一个对象时,如果所包含的对象不存在而不存在容器对象,那么它就称为组合.

Java中的具体示例来自此处和此处

依赖

class Employee {
    private Address address;

    // constructor 
    public Employee( Address newAddress ) {
        this.address = newAddress;
    }

    public Address getAddress() {
    return this.address;
    }
    public void setAddress( Address newAddress ) {
        this.address = newAddress;
    }
}

组成

final class Car {

  private final Engine engine;

  Car(EngineSpecs specs) {
    engine = new Engine(specs);
  }

  void move() {
    engine.work();
  }
}

通过组合字符，可以在单个位置使用 2 个 unicode 字符，创建两个图形的组合。我正在考虑简单的 ascii 艺术，我需要首先使用，正如维基百科所说的“带有水平填充的正方形”▤，然后在上面使用字母“A”。如何做到这一点？

这是我在某处遇到的代码，但想知道它是如何工作的：

    findIndices :: (a -> Bool) -> [a] -> [Int]
    findIndices _ [] = []
    findIndices pred xs = map fst (filter (pred . snd) (zip [0..] xs))

输出：findIndices (== 0) [1,2,0,3,0]==[2,4]，其中pred是(==0)&xs是[1,2,0,3,0]

我将展示我的一些理解：

    (zip [0..] xs)

上面一行的作用是为列表中的所有内容添加索引。对于上面给出的输入，它是这样的：[(0,1),(1,2),(2,0),(3,3),(4,0)]。

    (pred . snd)

我发现这意味着类似于pred (snd (x)). 我的问题是，x列表是由该zip行制作的吗？我倾向于是，但我的猜测是站不住脚的。

接下来是我对fstand 的理解snd。我知道

    fst(1,2) = 1 

和

    snd(1,2) = 2

这两个命令如何在代码中有意义？

我的理解filter是它返回匹配条件的项目列表。例如， …

我正在玩可组合的失败并设法用签名编写一个函数

getPerson :: IO (Maybe Person)

一个人在哪里:

data Person = Person String Int deriving Show

它的工作原理我用以下的方式编写了它:

import Control.Applicative

getPerson = do
    name <- getLine -- step 1
    age  <- getInt  -- step 2
    return $ Just Person <*> Just name <*> age 

哪里

getInt :: IO (Maybe Int)
getInt = do
    n <- fmap reads getLine :: IO [(Int,String)]
    case n of
        ((x,""):[])   -> return (Just x)
        _ -> return Nothing

我编写此函数的目的是创建可组合的可能失败.虽然我对除了Maybe和IO之外的monad的经验很少,但是如果我有一个更复杂的数据类型以及更多的字段,那么链接计算并不复杂.

我的问题是,如果没有写符号,我将如何重写？由于我无法将值绑定到名称或年龄等名称,因此我不确定从哪里开始.

提问的原因只是为了提高我对(>> =)和(<*>)的理解,并构成失败和成功(不要用难以辨认的单行代码来捣乱我的代码).

编辑:我想我应该澄清一下,"我应该怎么重写getPerson而不用do-notation",我不关心getInt函数的一半.