Question

我经常发现自己处于这样的情况：

IN: scratchpad: TUPLE: box
                    length width height ;

IN: scratchpad { { 1 2 3 } { 4 5 6 } { 6 7 8 } }

--- Data stack:
{ ~array~ ~array~ ~array~ }
IN: scratchpad [ V{ } clone-like ] dup [ map ] dip call

--- Data stack:
V{ ~vector~ ~vector~ ~vector~ }
IN: scratchpad [ dup pop swap dup pop swap dup pop swap drop box boa ] map  

--- Data stack:
V{ ~box~ ~box~ ~box~ }
IN: scratchpad dup .
V{
    T{ box { length 3 } { width 2 } { height 1 } }
    T{ box { length 6 } { width 5 } { height 4 } }
    T{ box { length 8 } { width 7 } { height 6 } }
}

哪能达到我想要的效果，但是这个：

dup pop swap

必须复制/粘贴与我想要销毁的数组中的项目相同的次数，并且数组必须首先clone-like d到V{ }向量，并且......它＆＃ 39; s只是非常糟糕，凌乱的代码。（请注意，由于堆栈效应，3 [ dup pop swap ] times将无效。）

必须有更好的方法从数组项构造TUPLE的实例。它是什么？

Answer 1

请注意，您可以从first2中的first3，first4和sequences以及来自x firstn的{{1}}的序列中一次解包多个元素

我认为最多＆＃34; Factorish＆＃34;这样做的方法是定义一个以序列作为参数的构造函数：

sequences.generalizations

然后你可以: seq>box ( s -- box ) first3 box boa ;：

map

其他方式，更接近你正在做的事情：

{ { 1 2 3 } { 4 5 6 } } [ seq>box ] map

{ { 1 2 3 } { 4 5 6 } } [ box prefix >tuple ] map采用

形式的序列

>tuple

所以每个序列必须{ name-of-tuple-class 1st-slot-value 2nd-slot-value ... last-slot-value }。

通过解构阵列简化蟒蛇收缩？

1 个答案: