list:permutations returns combinations rather than permutations

[edsrzf]

What happened?

The example for list:permutations seems incorrect, like it's giving combinations rather than permutations:

(let data [0 1 2 3])
(list:permutations data 3 (fun (perm) (print perm)))
# [0 1 2]
# [0 1 3]
# [0 2 3]
# [1 2 3]

I expect 24 results:

[0 1 2]
[0 1 3]
[0 2 1]
[0 2 3]
[0 3 1]
[0 3 2]
[1 0 2]
[1 0 3]
[1 2 0]
[1 2 3]
[1 3 0]
[1 3 2]
[2 0 1]
[2 0 3]
[2 1 0]
[2 1 3]
[2 3 0]
[2 3 1]
[3 0 1]
[3 0 2]
[3 1 0]
[3 1 2]
[3 2 0]
[3 2 1]

What ArkScript version are you seeing the problem on?

v4.3.3

Operating System

Linux

Compiler used

None

Compiler version used

No response

Relevant code & log output

Documentation

• I have read existing related documentation before submitting this report
• I have searched for an existing issue before posting

[SuperFola]

Hello, thanks for your report!

You're right, I screwed up when naming permutations and permutationsWithReplacement (which should be s/permutations/combinations).

Would this snippet do the job?

(import std.List :iota :slice :iterate :stopIteration :reverse :forEach :select)

(let perm (fun ((ref _lst) _r _f) {
  (let _len (len _lst))
  (if (and (<= _r _len) (> _r 0) (> _len 0))
    {
      (let _ind_first_r (iota 0 _r))
      (mut _indices (iota 0 _len))
      (mut _cycles (iterate _len (fun (x) (- x 1)) _r))
      (if (!= stopIteration (_f (select _lst _ind_first_r)))
        {
          (mut _continue true)
          (let _reversed_indices (reverse _ind_first_r))
          (while _continue {
            (if
              (not (forEach
                _reversed_indices
                (fun (_i) {
                  (@= _cycles _i (- (@ _cycles _i) 1))
                  (if (= 0 (@ _cycles _i))
                    {
                      (let _at_i (@ _indices _i))
                      (mut _k _i)
                      (while (< _k _len) {
                        (if (< (+ 1 _k) _len)
                          (@= _indices _k (@ _indices (+ 1 _k))))
                        (set _k (+ 1 _k)) })
                      (@= _indices -1 _at_i)
                      (@= _cycles _i (- _len _i)) }
                    {
                      (let _j (* -1 (@ _cycles _i)))
                      (let _ind_j (@ _indices _j))
                      (@= _indices _j (@ _indices _i))
                      (@= _indices _i _ind_j)
                      (if (= stopIteration (_f (select _lst (select _indices _ind_first_r))))
                        (set _continue false))
                      stopIteration }) })))
              (set _continue false)) }) }) }) }))

It should be used exactly like the current list:permutations, I'll see about renaming those two and adding some kind of warning maybe (like a deprecation warning in the next release, and deletion + new version in the version after that).