Function to redistribute list into columns

Question

I have a list in an org document that is rather long

- alpha a
- beta b
- gamma
- delta d
- epsilon e
- zeta z
- eta
- theta
- iota
- kappa
- lambda
- mu

I would like a function that redistributes this block of text into n columns where n is specified by me. So issuing M-x desired-function <ret> 2 <ret> would return something like

- alpha a    - eta
- beta b     - theta
- gamma      - iota
- delta d    - kappa
- epsilon e  - lambda
- zeta z     - mu

and issuing M-x desired-function <ret> 3 <ret> would return something like

- alpha a  - epsilon e  - iota
- beta b   - zeta z     - kappa
- gamma    - eta        - lambda
- delta d  - theta      - mu

Such a function would probably break the functionality of the list in the org document but that wouldn't really bother me.

Does this exist in emacs?

Answer 1

Here's something quick I could think of:

(defun my/org-partition-list (n)
  (interactive "nColumns: ")
  (let* ((struct (org-list-struct))
         (prevs (org-list-prevs-alist struct))
         (start (org-list-get-list-begin (point-at-bol) struct prevs))
         (end (org-list-get-list-end (point-at-bol) struct prevs))
         (table 
          (orgtbl-to-orgtbl
           (cl-loop with chunk = nil
                    for item in
                    (cl-loop for item in struct
                             collect (org-trim
                                      (buffer-substring-no-properties
                                       (+ (cl-first item)
                                          (cl-second item)
                                          (length (cl-third item)))
                                       (car (last item)))))
                    for i from 1
                    if (zerop (mod i n))
                    collect (nreverse (cons item chunk)) into result
                    and do (setf chunk nil)
                    else do (push item chunk) end
                    finally (cl-return
                             (if (/= 0 (mod i n))
                                 (append result (list chunk))
                               result)))
           nil)))
    (delete-region start end)
    (insert table)))

One thing to keep in mind is that Org lists can contain many other Org elements, most of which will make this function output something unpredictable / not really usable. This will only work in trivial cases, when lists contain plain text, one line per entry.