Rebol: block 字的动态绑定(bind)

Question

在 Rebol 中，有像 foreach 这样的单词，允许对给定单词和一系列进行“ block 参数化”，例如，foreach w [1 2 3] [print w].因为我发现这种语法非常方便(而不是传递 func block )，所以我想将它用于我自己在惰性列表上操作的单词，例如 map/stream x s [... x ... ] 。这个语法习语怎么称呼？如何正确实现？

我正在搜索文档，但找不到直接答案，所以我尝试自己实现 foreach。基本上，我的实现分为两部分。第一部分是一个函数，它将 block 中的特定单词绑定(bind)到给定值，并使用绑定(bind)的单词生成一个新 block 。

bind-var: funct [block word value] [
  qw: load rejoin ["'" word]
  do compose [
      set (:qw) value
      bind [(block)] (:qw)
      [(block)] ; This shouldn't work? see Question 2
  ]
]

使用它，我实现了 foreach，如下所示:

my-foreach: func ['word s block] [
    if empty? block [return none]
    until [
        do bind-var block word first s
        s: next s 
        tail? s
    ]
]

我发现这种方法相当笨拙(可能确实如此)，所以我想知道如何更优雅地解决这个问题。无论如何，在想出我的装置后，我留下了两个问题:

1. 在bind-var中，我必须在bind [(block)] (:qw)中进行一些包装，因为(block)会“溶解” 。为什么？

2. 因为 (?) of 2，绑定(bind)操作是在一个新 block (由 [(block)] 表达式创建的)上执行的，而不是在传递给 my-foreach 的原始 block 上执行的，有单独的绑定(bind)，所以我必须对其进行操作。我错误地添加了 [(block)] 并且它仍然有效。但为什么？

Answer 1

很好的问题。 :-) 在 Rebol2 和 R3-Alpha 中编写您自己的自定义循环结构(现在，历史在 Red 中重演)有许多 Unresolved 问题。 Rebol3 开发人员和 considered blocking bugs 都知道此类问题。 .

( Ren-C 启动的原因是为了解决这些问题。 Progress has been made 中的 several areas ，尽管在撰写本文时仍然存在许多突出的设计问题。我将尝试在下回答您的问题然而，历史假设。)

In bind-var, I had to do some wrapping in bind [(block)] (:qw) because (block) would "dissolve". Why?

这就是 COMPOSE 默认的工作方式……而且它通常是首选行为。如果您不想这样做，请使用 COMPOSE/ONLY， block 将不会被拼接，而是按原样插入。

qw: load rejoin ["'" word]

你可以转换WORD!到 LIT-WORD!通过 到 lit-word!词。您还可以将引用责任转移到您的样板中，例如设置引号(单词)值，并完全避免 qw。

避免 LOAD 通常也是更好的选择，因为默认情况下它总是将内容带入用户上下文中 - 因此它会失去原始单词的绑定(bind)。进行 TO 转换将保留原始 WORD 的绑定(bind)!在生成的 LIT-WORD 中!

do compose [
    set (:qw) value
    bind [(block)] (:qw)
    [(block)] ; This shouldn't work? see Question 2
 ]

想必您在这里指的是 COMPOSE/DEEP，否则这根本不起作用...使用常规 COMPOSE 嵌入的 PAREN!s _{咳，GROUP! [(block)] 的 s} 将不会被替换。

By mistake, I added [(block)] and it still works. But why?

如果您进行类似 my-foreach x [1] [print xprobebind? 'x] bind? 的输出将显示它已绑定(bind)到“全局”用户上下文中。

从根本上来说，你没有任何 MAKE OBJECT!或使用创建一个新的上下文来将正文绑定(bind)到其中。因此，您在这里可能要做的就是剥离 x 代码中的任何现有绑定(bind)，并确保它们位于用户上下文中。

但最初你确实有一个用途，即你edited to remove 。这更符合正确的轨道:

bind-var: func [block word value /local qw] [
    qw: load rejoin ["'" word]
    do compose/deep [
        use [(qw)] [
            set (:qw) value
            bind [(block)] (:qw)
            [(block)] ; This shouldn't work? see Question 2
        ]
    ]
]

您怀疑您的绑定(bind)方式有问题，这是正确的。但这之所以有效，是因为您的 BIND 只是重做 USE 本身所做的工作。使用已经很深的遍历来确保调整任何单词绑定(bind)。所以你可以完全省略绑定(bind):

do compose/deep [
    use [(qw)] [
        set (:qw) value
        [(block)]
    ]
]

the bind operation is performed on a new block (created by the [(block)] expression), not the original one passed to my-foreach, with separate bindings

让我们通过取出深度行走 USE 来调整您的代码，以演示您认为遇到的问题。我们将使用一个简单的 MAKE OBJECT!相反:

bind-var: func [block word value /local obj qw] [
    do compose/deep [
        obj: make object! [(to-set-word word) none]
        qw: bind (to-lit-word word) obj
        set :qw value
        bind [(block)] :qw
        [(block)] ; This shouldn't work? see Question 2
    ]
]

现在，如果你尝试 my-foreach x [1 2 3] [print x]你会得到你怀疑的结果......“x没有值”(假设你没有它拾取 x 的一些潜在全局定义，这只会打印相同的潜在值 3 次)。

但是为了让您对您的提问感到非常抱歉:-)，我要提到 my-foreach x [1 2 3] [loop 1 [print x]] 实际上有效.这是因为，虽然您说过去的绑定(bind)不应该影响新 block 是正确的，但此 COMPOSE 仅创建一个新 block !。最顶层是新的，源 Material 中引用的任何“更深”的嵌入 block 都将是原始 Material 的别名:

>> original: [outer [inner]]
== [outer [inner]]

>> composed: compose [<a> (original) <b>]
== [<a> outer [inner] <b>]

>> append original/2 "mutation"
== [inner "mutation"]

>> composed
== [<a> outer [inner "mutation"] <b>]

因此，如果您对组合结果执行变异 BIND，它可能会严重影响源代码的某些。

until [
    do bind-var block word first s
    s: next s 
    tail? s
]

就效率而言，您将在循环的每次迭代中运行 COMPOSE 和 BIND 操作。无论针对此类问题的新解决方案多么有创意(Ren-C 中有很多新技术会影响您的此类问题)，您仍然可能只想只做一次并在迭代中重用它。