2. sub METAOP_ASSIGN(\op) {
3. -> Mu \a, Mu \b { a = op.( ( a.DEFINITE ?? a !! op.() ), b) }
4. }
6. sub METAOP_TEST_ASSIGN:<//>(\lhs, $rhs) is raw { lhs // (lhs = $rhs()) }
7. sub METAOP_TEST_ASSIGN:<||>(\lhs, $rhs) is raw { lhs || (lhs = $rhs()) }
8. sub METAOP_TEST_ASSIGN:<&&>(\lhs, $rhs) is raw { lhs && (lhs = $rhs()) }
9. sub METAOP_TEST_ASSIGN:<or>(\lhs, $rhs) is raw { lhs or (lhs = $rhs()) }
10. sub METAOP_TEST_ASSIGN:<and>( \lhs, $rhs) is raw { lhs and (lhs = $rhs()) }
11. sub METAOP_TEST_ASSIGN:<andthen>( \lhs, $rhs) is raw { lhs andthen (lhs = $rhs()) }
12. sub METAOP_TEST_ASSIGN:<notandthen>(\lhs, $rhs) is raw { lhs notandthen (lhs = $rhs()) }
13. sub METAOP_TEST_ASSIGN:<orelse>( \lhs, $rhs) is raw { lhs orelse (lhs = $rhs()) }
15. sub METAOP_NEGATE(\op) {
16. -> |c { c.elems > 1 ?? !op.(|c) !! True }
17. }
19. sub METAOP_REVERSE(\op) {
20. -> |args { op.(|args.reverse) }
21. }
23. sub METAOP_CROSS(\op, &reduce) {
24. nqp::if(op.prec('thunky').starts-with('.'),
25. -> +lol {
26. my $rop = lol.elems == 2 ?? op !! &reduce(op);
27. my $laze = False;
28. my @loi = eager for lol -> \elem {
29. if nqp::iscont(elem) {
30. $laze = False;
31. (elem,).iterator
32. }
33. else {
34. $laze = True if elem.is-lazy;
35. elem.iterator
36. }
37. }
38. my Mu $cache := nqp::list();
39. my int $i = 0;
40. for ^lol.elems {
41. $i = $_;
42. my Mu $rpa := nqp::list();
43. nqp::bindpos($cache, $i, $rpa);
44. }
45. my int $n = lol.elems - 1;
46. my $j = 0;
47. my @j;
48. my @v;
50. $i = 0;
51. gather {
52. while $i >= 0 {
53. my Mu $sublist := nqp::atpos($cache, $i);
54. if $j < nqp::elems($sublist) {
55. my Mu $o := nqp::atpos($sublist, $j);
56. @v[$i] := $o;
57. $j = $j + 1;
58. if $i >= $n { take lol.elems == 2 ?? $rop(|@v) !! $rop(@v); }
59. else { $i = $i + 1; @j.push($j); $j = 0; }
60. }
61. elsif nqp::not_i(nqp::eqaddr((my \value = @loi[$i].pull-one),IterationEnd)) {
62. nqp::bindpos($sublist, $j, value);
63. redo;
64. }
65. else {
66. $i = $i - 1;
67. if $i { $j = @j.pop if $i > 0 } # continue previous dimension where we left off
68. else {
69. $j = 0;
70. my Mu $sublist := nqp::atpos($cache,$i);
71. nqp::pop($sublist); # don't cache 1st dimension (could be infinite)
72. }
73. }
74. }
75. }.lazy-if($laze);
76. },
77. -> +lol {
78. Seq.new(Rakudo::Iterator.CrossIterablesOp(lol,op))
79. }
80. )
81. }
83. sub METAOP_ZIP(\op, &reduce) {
84. nqp::if(op.prec('thunky').starts-with('.'),
85. -> +lol {
86. my $arity = lol.elems;
87. my $rop = $arity == 2 ?? op !! &reduce(op);
88. my $laze = True;
89. my @loi = eager for lol -> \elem {
90. if nqp::iscont(elem) {
91. $laze = False;
92. Rakudo::Iterator.OneValue(elem)
93. }
94. else {
95. $laze = False unless elem.is-lazy;
96. Rakudo::Iterator.Whatever(elem.iterator)
97. }
98. }
99. gather {
100. loop {
101. my \z = @loi.map: {
102. my \value = .pull-one;
103. last if nqp::eqaddr(value,IterationEnd);
104. value
105. };
106. my $z = List.from-iterator(z.iterator);
107. $z.eager;
108. last if $z.elems < $arity;
109. take-rw $arity == 2 ?? $rop(|$z) !! $rop(@$z);
110. }
111. }.lazy-if($laze)
112. },
113. -> +lol {
114. Seq.new(Rakudo::Iterator.ZipIterablesOp(lol,op))
115. }
116. )
117. }
119. proto sub METAOP_REDUCE_LEFT(|) {*}
120. multi sub METAOP_REDUCE_LEFT(\op, \triangle) {
121. if op.count > 2 and op.count < Inf {
122. my $count = op.count;
123. sub (+values) {
124. my \source = values.iterator;
126. my \first = source.pull-one;
127. return () if nqp::eqaddr(first,IterationEnd);
129. my @args.push: first;
130. GATHER({
131. take first;
132. until nqp::eqaddr((my \current = source.pull-one),IterationEnd) {
133. @args.push: current;
134. if @args.elems == $count {
135. my \val = op.(|@args);
136. take val;
137. @args = ();
138. @args.push: val; # use of push allows op to return a Slip
139. }
140. }
141. }).lazy-if(source.is-lazy);
142. }
143. }
144. else {
145. sub (+values) {
146. my \source = values.iterator;
148. my \first = source.pull-one;
149. return () if nqp::eqaddr(first,IterationEnd);
151. my $result := first;
152. GATHER({
153. take first;
154. until nqp::eqaddr((my \value = source.pull-one),IterationEnd) {
155. take ($result := op.($result, value));
156. }
157. }).lazy-if(source.is-lazy);
158. }
159. }
160. }
162. multi sub METAOP_REDUCE_LEFT(\op) {
163. if op.count > 2 and op.count < Inf {
164. my $count = op.count;
165. sub (+values) {
166. my \iter = values.iterator;
167. my \first = iter.pull-one;
168. return op.() if nqp::eqaddr(first,IterationEnd);
170. my @args.push: first;
171. my $result := first;
172. until nqp::eqaddr((my \value = iter.pull-one),IterationEnd) {
173. @args.push: value;
174. if @args.elems == $count {
175. my \val = op.(|@args);
176. @args = ();
177. @args.push: val; # use of push allows op to return a Slip
178. $result := val;
179. }
180. }
181. $result;
182. }
183. }
184. else {
185. nqp::eqaddr(op,&infix:<+>)
186. ?? &sum
187. !! sub (+values) {
188. nqp::stmts(
189. (my $iter := values.iterator),
190. nqp::if(
191. nqp::eqaddr((my $result := $iter.pull-one),IterationEnd),
192. op.(), # identity
193. nqp::if(
194. nqp::eqaddr((my $value := $iter.pull-one),IterationEnd),
195. nqp::if(
196. nqp::isle_i(op.arity,1),
197. op.($result), # can call with 1 param
198. $result # what we got
199. ),
200. nqp::stmts(
201. ($result := op.($result,$value)),
202. nqp::until(
203. nqp::eqaddr(($value := $iter.pull-one),IterationEnd),
204. ($result := op.($result,$value))
205. ),
206. $result # final result
207. )
208. )
209. )
210. )
211. }
212. }
213. }
215. proto sub METAOP_REDUCE_RIGHT(|) {*}
216. multi sub METAOP_REDUCE_RIGHT(\op, \triangle) {
217. nqp::if(
218. op.count < Inf && nqp::isgt_i((my int $count = op.count),2),
219. sub (+values) {
220. Seq.new(nqp::if(
221. nqp::isge_i((my int $i = (my $v :=
222. nqp::if(nqp::istype(values,List),values,values.List)
223. ).elems), # reifies
224. $count
225. ), # reifies
226. class :: does Iterator {
227. has $!op;
228. has $!reified;
229. has $!result;
230. has int $!count;
231. has int $!i;
232. method !SET-SELF(\op,\list,\count,\index) {
233. nqp::stmts(
234. ($!op := op),
235. ($!reified := nqp::getattr(list,List,'$!reified')),
236. ($!count = count),
237. ($!i = index),
238. self
239. )
240. }
241. method new(\op,\list,\count,\index) {
242. nqp::create(self)!SET-SELF(op,list,count,index)
243. }
244. method pull-one() is raw {
245. nqp::if(
246. nqp::attrinited(self,self.WHAT,'$!result'),
247. nqp::stmts(
248. (my $args := nqp::list($!result)),
249. nqp::until(
250. nqp::iseq_i(nqp::elems($args),$!count)
251. || nqp::islt_i(($!i = nqp::sub_i($!i,1)),0),
252. nqp::unshift($args,nqp::atpos($!reified,$!i))
253. ),
254. nqp::if(
255. nqp::isgt_i(nqp::elems($args),1),
256. ($!result := op.(|nqp::hllize($args))),
257. IterationEnd
258. )
259. ),
260. ($!result := nqp::atpos(
261. $!reified,
262. ($!i = nqp::sub_i($!i,1))
263. ))
264. )
265. }
266. method bool-only(--> True) { };
267. method count-only() { nqp::p6box_i($!i) }
268. }.new(op,$v,$count,$i),
269. Rakudo::Iterator.OneValue(
270. nqp::if(
271. $i,
272. op.(|nqp::getattr($v,List,'$!reified')),
273. op.()
274. )
275. )
276. ))
277. },
278. sub (+values) {
279. Seq.new(nqp::if(
280. nqp::isgt_i((my int $i = (my $v :=
281. nqp::if(nqp::istype(values,List),values,values.List)
282. ).elems), # reifies
283. 1
284. ),
285. class :: does Iterator {
286. has $!op;
287. has $!reified;
288. has $!result;
289. has int $!i;
290. method !SET-SELF(\op,\list,\count) {
291. nqp::stmts(
292. ($!op := op),
293. ($!reified := nqp::getattr(list,List,'$!reified')),
294. ($!i = count),
295. self
296. )
297. }
298. method new(\op,\li,\co) { nqp::create(self)!SET-SELF(op,li,co) }
299. method pull-one() is raw {
300. nqp::if(
301. nqp::attrinited(self,self.WHAT,'$!result'),
302. nqp::if(
303. nqp::isge_i(($!i = nqp::sub_i($!i,1)),0),
304. ($!result := $!op.(nqp::atpos($!reified,$!i),$!result)),
305. IterationEnd
306. ),
307. ($!result := nqp::atpos(
308. $!reified,
309. ($!i = nqp::sub_i($!i,1))
310. ))
311. )
312. }
313. method bool-only(--> True) { };
314. method count-only() { nqp::p6box_i($!i) }
315. }.new(op,$v,$i),
316. Rakudo::Iterator.OneValue(
317. nqp::if(
318. $i,
319. op.(nqp::atpos(nqp::getattr($v,List,'$!reified'),0)),
320. op.()
321. )
322. )
323. ))
324. }
325. )
326. }
327. multi sub METAOP_REDUCE_RIGHT(\op) {
328. nqp::if(
329. op.count < Inf && nqp::isgt_i((my int $count = op.count),2),
330. sub (+values) {
331. nqp::if(
332. nqp::isge_i((my int $i = (my $v :=
333. nqp::if(nqp::istype(values,List),values,values.List)
334. ).elems), # reifies
335. $count
336. ), # reifies
337. nqp::stmts(
338. (my $args := nqp::list(
339. my $result := nqp::atpos(
340. (my $reified := nqp::getattr($v,List,'$!reified')),
341. ($i = nqp::sub_i($i,1))
342. )
343. )),
344. nqp::until(
345. nqp::islt_i(($i = nqp::sub_i($i,1)),0),
346. nqp::stmts(
347. nqp::unshift($args,nqp::atpos($reified,$i)),
348. nqp::if(
349. nqp::iseq_i(nqp::elems($args),$count),
350. nqp::stmts(
351. ($result := op.(|nqp::hllize($args))),
352. nqp::bindpos(nqp::setelems($args,1),0,$result)
353. )
354. )
355. )
356. ),
357. nqp::if(
358. nqp::isgt_i(nqp::elems($args),1),
359. op.(|nqp::hllize($args)), # something left to process
360. $result
361. )
362. ),
363. nqp::if(
364. $i,
365. op.(|nqp::getattr($v,List,'$!reified')),
366. op.()
367. )
368. )
369. },
370. sub (+values) {
371. nqp::if(
372. nqp::isgt_i((my int $i = (my $v :=
373. nqp::if(nqp::istype(values,List),values,values.List)
374. ).elems), # reifies
375. 1
376. ),
377. nqp::stmts(
378. (my $result := nqp::atpos(
379. nqp::getattr($v,List,'$!reified'),
380. ($i = nqp::sub_i($i,1))
381. )),
382. nqp::while(
383. nqp::isge_i(($i = nqp::sub_i($i,1)),0),
384. ($result := op.(
385. nqp::atpos(nqp::getattr($v,List,'$!reified'),$i),
386. $result
387. ))
388. ),
389. $result
390. ),
391. nqp::if(
392. $i,
393. op.(nqp::atpos(nqp::getattr($v,List,'$!reified'),0)),
394. op.()
395. )
396. )
397. }
398. )
399. }
401. proto sub METAOP_REDUCE_LIST(|) {*}
402. multi sub METAOP_REDUCE_LIST(\op, \triangle) {
403. sub (+values) {
404. GATHER({
405. my @list;
406. for values -> \v {
407. @list.push(v);
408. take op.(|@list);
409. }
410. }).lazy-if(values.is-lazy);
411. }
412. }
413. multi sub METAOP_REDUCE_LIST(\op) {
414. sub (+values) { op.(|values) }
415. }
417. proto sub METAOP_REDUCE_LISTINFIX(|) {*}
418. multi sub METAOP_REDUCE_LISTINFIX(\op, \triangle) {
419. sub (|values) {
420. my \p = values[0];
421. return () unless p.elems;
423. my int $i;
424. GATHER({
425. my @list;
426. while $i < p.elems {
427. @list.push(p[$i++]);
428. take op.(|@list.map({nqp::decont($_)}));
429. }
430. }).lazy-if(p.is-lazy);
431. }
432. }
433. multi sub METAOP_REDUCE_LISTINFIX(\op) {
434. sub (+values) {
435. op.(|values.map({nqp::decont($_)}));
436. }
437. }
439. proto sub METAOP_REDUCE_CHAIN(|) {*}
440. multi sub METAOP_REDUCE_CHAIN(\op, \triangle) {
441. sub (+values) {
442. my $state = True;
443. my \iter = values.iterator;
444. my Mu $current = iter.pull-one;
445. gather {
446. take $state;
447. while $state && nqp::not_i(nqp::eqaddr((my $next := iter.pull-one),IterationEnd)) {
448. $state = op.($current, $next);
449. take $state;
450. $current := $next;
451. }
452. unless $state {
453. take False until nqp::eqaddr(iter.pull-one,IterationEnd);
454. }
455. }.lazy-if(values.is-lazy);
456. }
457. }
458. multi sub METAOP_REDUCE_CHAIN(\op) {
459. sub (+values) {
460. nqp::if(
461. nqp::eqaddr(
462. (my $current := (my $iter := values.iterator).pull-one),
463. IterationEnd
464. ),
465. True,
466. nqp::stmts(
467. nqp::while(
468. nqp::not_i(nqp::eqaddr((my $next := $iter.pull-one),IterationEnd))
469. && op.($current,$next),
470. $current := $next
471. ),
472. nqp::p6bool(nqp::eqaddr($next,IterationEnd))
473. )
474. )
475. }
476. }
478. sub METAOP_REDUCE_XOR(\op, $triangle?) {
479. X::NYI.new(feature => 'xor reduce').throw;
480. }
482. sub METAOP_HYPER(\op, *%opt) {
483. -> Mu \a, Mu \b { HYPER(op, a, b, |%opt) }
484. }
486. proto sub METAOP_HYPER_POSTFIX(|) {*}
487. multi sub METAOP_HYPER_POSTFIX(\op) {
488. nqp::if(
489. nqp::can(op,"nodal"),
490. (-> \obj { nodemap(op, obj) }),
491. (-> \obj { deepmap(op, obj) })
492. )
493. }
495. # no indirection for subscripts and such
496. proto sub METAOP_HYPER_POSTFIX_ARGS(|) {*}
497. multi sub METAOP_HYPER_POSTFIX_ARGS(\obj,\op) {
498. nqp::if(
499. nqp::can(op,"nodal"),
500. nodemap(op, obj),
501. deepmap(op, obj)
502. )
503. }
504. multi sub METAOP_HYPER_POSTFIX_ARGS(\obj, @args, \op) {
505. nqp::if(
506. nqp::can(op,"nodal"),
507. nodemap( -> \o { op.(o,@args) }, obj ),
508. deepmap( -> \o { op.(o,@args) }, obj )
509. )
510. }
511. multi sub METAOP_HYPER_POSTFIX_ARGS(\obj, \args, \op) {
512. nqp::if(
513. nqp::can(op,"nodal"),
514. nodemap( -> \o { op.(o,|args) }, obj ),
515. deepmap( -> \o { op.(o,|args) }, obj )
516. )
517. }
519. sub METAOP_HYPER_PREFIX(\op) {
520. nqp::if(
521. nqp::can(op,"nodal"), # rarely true for prefixes
522. (-> \obj { nodemap(op, obj) }),
523. (-> \obj { deepmap(op, obj) })
524. )
525. }
527. sub METAOP_HYPER_CALL(\list, |args) { deepmap(-> $c { $c(|args) }, list) }
529. proto sub HYPER(|) {*}
531. multi sub HYPER(&op, \left, \right, :$dwim-left, :$dwim-right) {
532. op(left, right);
533. }
535. multi sub HYPER(&op, Associative:D \left, Associative:D \right, :$dwim-left, :$dwim-right) {
536. my %keyset;
537. if !$dwim-left {
538. %keyset{$_} = 1 for left.keys;
539. }
540. else {
541. %keyset{$_} = 1 if right.EXISTS-KEY($_) for left.keys;
542. }
543. if !$dwim-right {
544. %keyset{$_} = 1 for right.keys;
545. }
546. my @keys = %keyset.keys;
547. my $type = left.WHAT;
548. my \result := $type.new;
549. result = quietly @keys Z=> HYPER(&op, left{@keys}, right{@keys}, :$dwim-left, :$dwim-right);
550. nqp::iscont(left) ?? result.item !! result;
551. }
553. multi sub HYPER(&op, Associative:D \left, \right, :$dwim-left, :$dwim-right) {
554. my @keys = left.keys;
555. my $type = left.WHAT;
556. my \result := $type.new;
557. result = @keys Z=> HYPER(&op, left{@keys}, right, :$dwim-left, :$dwim-right);
558. nqp::iscont(left) ?? result.item !! result;
559. }
561. multi sub HYPER(&op, \left, Associative:D \right, :$dwim-left, :$dwim-right) {
562. my @keys = right.keys;
563. my $type = right.WHAT;
564. my \result := $type.new;
565. result = @keys Z=> HYPER(&op, left, right{@keys}, :$dwim-left, :$dwim-right);
566. nqp::iscont(right) ?? result.item !! result;
567. }
569. multi sub HYPER(&operator, Positional:D \left, \right, :$dwim-left, :$dwim-right) {
570. my @result;
571. X::HyperOp::Infinite.new(:side<left>, :&operator).throw if left.is-lazy;
572. my int $elems = left.elems;
573. X::HyperOp::NonDWIM.new(:&operator, :left-elems($elems), :right-elems(1), :recursing(callframe(3).code.name eq 'HYPER')).throw
574. unless $elems == 1 or $elems > 1 and $dwim-right or $elems == 0 and $dwim-left || $dwim-right;
575. my \lefti := left.iterator;
576. my int $i = 0;
577. until nqp::eqaddr((my \value := lefti.pull-one),IterationEnd) {
578. @result[$i++] := HYPER(&operator, value, right, :$dwim-left, :$dwim-right);
579. }
580. # Coerce to the original type if it's a subtype of List
581. my $type = nqp::istype(left, List) ?? left.WHAT !! List;
582. nqp::iscont(left) ?? $type(|@result.eager).item !! $type(|@result.eager)
583. }
585. multi sub HYPER(&operator, \left, Positional:D \right, :$dwim-left, :$dwim-right) {
586. my @result;
587. X::HyperOp::Infinite.new(:side<right>, :&operator).throw if right.is-lazy;
588. my int $elems = right.elems;
589. X::HyperOp::NonDWIM.new(:&operator, :left-elems(1), :right-elems($elems), :recursing(callframe(3).code.name eq 'HYPER')).throw
590. unless $elems == 1 or $elems > 1 and $dwim-left or $elems == 0 and $dwim-left || $dwim-right;
591. my \righti := right.iterator;
592. my int $i = 0;
593. until nqp::eqaddr((my \value := righti.pull-one),IterationEnd) {
594. @result[$i++] := HYPER(&operator, left, value, :$dwim-left, :$dwim-right);
595. }
596. # Coerce to the original type if it's a subtype of List
597. my $type = nqp::istype(right, List) ?? right.WHAT !! List;
598. nqp::iscont(right) ?? $type(|@result.eager).item !! $type(|@result.eager)
599. }
601. multi sub HYPER(&operator, Iterable:D \left, Iterable:D \right, :$dwim-left, :$dwim-right) {
602. my \left-iterator = left.iterator;
603. my \right-iterator = right.iterator;
605. # Check whether any side is lazy. They must not be to proceed.
606. if left-iterator.is-lazy {
607. X::HyperOp::Infinite.new(:side<both>, :&operator).throw if right-iterator.is-lazy;
608. X::HyperOp::Infinite.new(:side<left>, :&operator).throw if not $dwim-left or $dwim-right;
609. }
610. X::HyperOp::Infinite.new(:side<right>, :&operator).throw if right-iterator.is-lazy and
611. (not $dwim-right or $dwim-left);
613. my \lefti := Rakudo::Iterator.DWIM(left-iterator);
614. my \righti := Rakudo::Iterator.DWIM(right-iterator);
616. my \result := IterationBuffer.new;
617. loop {
618. my \leftv := lefti.pull-one;
619. my \rightv := righti.pull-one;
621. X::HyperOp::NonDWIM.new(:&operator, :left-elems(lefti.count-elems), :right-elems(righti.count-elems), :recursing(callframe(3).code.name eq 'HYPER')).throw
622. if !$dwim-left and !$dwim-right and (lefti.ended != righti.ended);
624. last if ($dwim-left and $dwim-right) ?? (lefti.ended and righti.ended) !!
625. (($dwim-left or lefti.ended) and ($dwim-right or righti.ended));
626. last if $++ == 0 and ($dwim-left and lefti.ended or $dwim-right and righti.ended);
628. nqp::push(result,HYPER(&operator, leftv, rightv, :$dwim-left, :$dwim-right));
629. }
631. # Coerce to the original type
632. my $type = nqp::istype(left, List) ?? left.WHAT !! List; # keep subtypes of List
633. my \retval = $type.new;
634. nqp::bindattr(retval, List, '$!reified', result);
635. nqp::iscont(left) ?? retval.item !! retval;
636. }
638. multi sub HYPER(\op, \obj) {
639. nqp::if(
640. nqp::can(op,"nodal"),
641. nodemap(op, obj),
642. deepmap(op,obj)
643. )
644. }
646. proto sub deepmap(|) {*}
648. multi sub deepmap(\op, \obj) {
649. Rakudo::Internals.coremap(op, obj, :deep)
650. }
652. multi sub deepmap(\op, Associative \h) {
653. my @keys = h.keys;
654. hash @keys Z deepmap(op, h{@keys})
655. }
657. proto sub nodemap(|) {*}
658. multi sub nodemap(\op, \obj) {
659. my Mu $rpa := nqp::create(IterationBuffer);
660. my \objs := obj.list;
661. # as a wanted side-effect is-lazy reifies the list
662. fail X::Cannot::Lazy.new(:action<nodemap>) if objs.is-lazy;
663. my Mu $items := nqp::getattr(objs, List, '$!reified');
664. my Mu $o;
665. # We process the elements in two passes, end to start, to
666. # prevent users from relying on a sequential ordering of hyper.
667. # Also, starting at the end pre-allocates $rpa for us.
668. my int $i = nqp::elems($items) - 1;
669. nqp::while(
670. nqp::isge_i($i, 0),
671. nqp::stmts(
672. nqp::bindpos($rpa, $i, op.(nqp::atpos($items, $i))),
673. $i = nqp::sub_i($i, 2)
674. )
675. );
676. $i = nqp::elems($items) - 2;
677. nqp::while(
678. nqp::isge_i($i, 0),
679. nqp::stmts(
680. nqp::bindpos($rpa, $i, op.(nqp::atpos($items, $i))),
681. $i = nqp::sub_i($i, 2)
682. )
683. );
684. nqp::p6bindattrinvres(nqp::create(List), List, '$!reified', $rpa)
685. }
687. multi sub nodemap(\op, Associative \h) {
688. my @keys = h.keys;
689. hash @keys Z nodemap(op, h{@keys})
690. }
692. proto sub duckmap(|) {*}
693. multi sub duckmap(\op, \obj) {
694. Rakudo::Internals.coremap(sub (\arg) { CATCH { return arg ~~ Iterable:D ?? duckmap(op,arg) !! arg }; op.(arg); }, obj);
695. }
697. multi sub duckmap(\op, Associative \h) {
698. my @keys = h.keys;
699. hash @keys Z duckmap(op, h{@keys})
700. }