小编deo*_*ian的帖子

最近关于Haskell中关于2d网格的问题的启发,我想知道是否有可能创建一个二维拉链来跟踪列表列表中的位置.列表中的一维拉链允许我们在大型列表中实际高效地移动本地(常见示例是文本编辑器).但是我们假设我们有这样的第二个维度:

grid = 
    [[ 1, 2, 3, 4, 5]
    ,[ 6, 7, 8, 9,10]
    ,[11,12,13,14,15]
    ,[16,17,18,19,20]
    ,[21,22,23,24,25]]

我们是否可以创建某种拉链数据结构,不仅可以高效地左右移动,而且可以在网格中上下移动？如果是这样,如果我们用无限列表的无限列表替换列表列表,我们仍然可以获得有效的运动吗？

我正在构建一个RESTful Web服务,我正在创建一些自定义媒体类型.在媒体类型中,当您使用"+"从右到左时,子类型变得更具体.例如:

application/jsonapplication/hal+json因为HAL在json之上添加了更多限制,所以比一般更通用.

我的问题是这是标准的,还是只是一个约定(我已经通过一些关于MIME类型的RFC进行了调查,我找不到任何东西,但我可能看起来不够努力).

如果它是标准的,它是否一般化,所以我可以添加更多特定的子类型,application/vnd.custom.mime+hal+json或者仅限于一个"+"？

我正在尝试解析一个简单的key = value查询语言.我实际上是用一个巨大的怪物解析器完成它,然后我再次通过来清理解析树.我想要做的是从下往上,其中包括像使用套为划清解析(KEY,VAL)对,这样对冗余消除等,虽然我之前的工作,我不觉得就像我完全理解为什么pyparsing按照它的方式行事,所以我做了大量的工作等等,有点像对抗谷物.

目前,这是我的"简化"解析器的开头:

from pyparsing import *   

bool_act = lambda t: bool(t[0])
int_act  = lambda t: int(t[0])

def keyval_act(instring, loc, tokens):
    return set([(tokens.k, tokens.v)])

def keyin_act(instring, loc, tokens):
    return set([(tokens.k, set(tokens.vs))])

string = (
      Word(alphas + '_', alphanums + '_')
    | quotedString.setParseAction( removeQuotes )
    )
boolean = (
      CaselessLiteral('true')
    | CaselessLiteral('false')
    )
integer = Word(nums).setParseAction( int_act )
value = (
      boolean.setParseAction(bool_act)
    | integer
    | string
    )
keyval = (string('k') + Suppress('=') + value('v')
          ).setParseAction(keyval_act)
keyin = (
    string('k') + …

假设我们创建了C的重新实现,唯一的区别是推断了类型.仍然需要给出存储类和修饰符(const,static,restrict等),让我们暂时将注意力限制在单个文件C程序上.可以吗？主要障碍是什么？

关于什么可能导致类型推断问题的一些想法

• 具有相同字段名称的结构需要手动消除歧义
• 对于具有相同字段名称的联盟也是如此

• 演员可能需要一个"从"注释,类似于

  var i = (uint32_t -> uint64_t) *some_pointer;
  

  Run Code Online (Sandbox Code Playgroud)

这些问题需要一些用户注释,但不应该太繁琐,是否有一些将这个想法从水中吹出的杀手问题？

编辑:为了澄清,我不是在谈论添加泛型或参数多态,只是对现有C类型进行类型推断.

编辑2014:任何对此概念感兴趣的人都可能想要研究Rust

受Brent Yorgey 冒险游戏的启发 ,我一直在编写一个使用MonadPrompt 库的小型文本冒险游戏(la Zork) .使用它将IO后端与管理游戏玩法的实际功能分开是相当简单的,但我现在正试图做一些更复杂的事情.

基本上,我想启用撤消和重做作为游戏的一个功能.我的策略是保持游戏状态的拉链(包括最后输入的内容).由于我希望能够在重新加载游戏时保持历史记录,因此保存文件只是玩家执行的所有输入的列表,可以影响游戏状态(因此,检查库存不会包括在内).这个想法是在加载游戏时快速重放保存文件中输入的最后一个游戏(跳过输出到终端,并从文件中的列表中获取输入),从而建立游戏状态的完整历史记录.

这里有一些代码基本上显示了我的设置(我为长度道歉,但这从实际代码中大大简化):

data Action = UndoAction | RedoAction | Go Direction -- etc ...
-- Actions are what we parse user input into, there is also error handling
-- that I left out of this example
data RPGPrompt a where
    Say :: String -> RPGPrompt ()
    QueryUser :: String -> RPGPrompt Action
    Undo :: RPGPrompt ( Prompt RPGPrompt ())
    Redo :: RPGPrompt ( Prompt RPGPrompt ())
    {-
    ... More prompts like …

因此,在使用Java泛型之后,为了更深入地了解它们的功能,我决定尝试实现组合函数的curried版本,熟悉函数式程序员.Compose具有类型(在函数语言中)(b -> c) -> (a -> b) -> (a -> c).做currying算术函数并不太难,因为它们只是多态的,但是compose是一个更高阶的函数,并且它证明了我对Java中泛型的理解.

这是我到目前为止创建的实现:

public class Currying {

  public static void main(String[] argv){
    // Basic usage of currying
    System.out.println(add().ap(3).ap(4));
    // Next, lets try (3 * 4) + 2
    // First lets create the (+2) function...
    Fn<Integer, Integer> plus2 = add().ap(2);
    // next, the times 3 function
    Fn<Integer, Integer> times3 = mult().ap(3);
    // now we compose them into a multiply by 2 and add 3 function
    Fn<Integer, Integer> times3plus2 = compose().ap(plus2).ap(times3); …

我有一些ORM映射表，（缩减）如下所示：

class Tag(Base):
    __tablename__ = 'tags'

    tag_name = Column(String, primary_key=True)

task2tag_assoc = Table('tasktags', Base.metadata,
    Column('task_id', UUID, ForeignKey('tasks.task_id', ondelete='cascade'), 
           primary_key=True),
    Column('tag_name', String, ForeignKey('tags.tag_name', ondelete='cascade'),
           primary_key=True)
    )

class Task(Base):
    __tablename__ = 'tasks'

    task_id = Column(UUID, primary_key=True)
    _tags = relationship('Tag', secondary=task2tag_assoc, backref='tasks',
            collection_class=set)
    tags = association_proxy('_tags', 'tag_name')

    def __init__(self, task_id, tags):
        self.task_id = task_id
        self.tags = set([tags])

通过此设置，我可以使用新标签创建任务。它在tags表中创建标签行，然后在表中创建与新任务的关联tasktags。

t = Task(task_id = uuid4(), tags=['foo', 'bar']) #this works

当我尝试使用tags表中已经存在的标签创建任务时，就会出现问题。

t2 = Task(task_oid = uuid4(), tags=['foo', 'baz']) #this will …

我的C代码中有几个uint8_t数组，我想将任意一个序列位与另一个序列进行比较。例如，我有bitarray_1和bitarray_2，我想将bitarray_1的13-47位与bitarray_2的5-39位进行比较。最有效的方法是什么？

当前，这是我程序中的一个巨大瓶颈，因为我只有一个幼稚的实现，可以将这些位复制到新的临时数组的开头，然后对它们使用memcmp。

我有一个大型数据集,我在R中绘图,我想在图表的每一侧都有一个轴,以两种不同的比例显示数据.因此,例如,在左侧垂直轴上,我想直接绘制数据(例如,绘图(y~x)),而在右轴上,我想要对左轴进行线性缩放.(例如情节(y*20~x).

因此,只会显示一个数据集,但轴将显示这些数据点的不同含义.

我尝试过以下方法:

plot(x = dataset$x, y = dataset$y)
axis(4, pretty(dataset$y,10) )

这将正确打印一个新的右轴,其刻度与默认左轴相同.(基本没用,但它有效)但是,如果我做了这个微小的改变:

plot(x = dataset$x, y = dataset$y)
axis(4, pretty(10*dataset$y,10) )

突然,它拒绝添加我的新右轴.我怀疑这与R有关,看看轴是否以某种方式与数据集匹配,如果没有则拒绝它.如何让R忽略数据集并只打印我选择的任意轴？

关于以下代码是否更好,我看到了相互矛盾的建议

def function():
    ret_val = 0
    if some_condition():
        ret_val = 2
    else:
        ret_val = 3
    return ret_val

或者这是否更好:

def function():
    if some_condition():
        return 2
    else:
        return 3

这是一个简单的例子,我用python风格编写它,但我正在寻找的一般原则是什么时候使用一些"累加器"变量来跟踪返回值,或者是否使用多个出口点.我知道不同的语言可能有不同的原因使用一种风格而不是另一种风格,所以我很欣赏不同的观点,为什么特定的语言可能会坚持特定的风格.(特别是在过去,我听说C中的结构化编程避免了函数的多个退出点.)