Scholar 101

(setq records '((:name "ChatGPT" :description ("Created by OpenAI and launched in November 2022." "The model can be accessed through OpenAI's website, mobile apps, and API services. It offers both free and premium subscription options through ChatGPT Plus."))
                (:name "Claude" :description ("Developed by Anthropic using constitutional AI principle" "Distinguished by its more direct and nuanced communication style, Claude tends to be more willing to engage in sophisticated discussions and provide detailed, thoughtful responses while maintaining appropriate boundaries." "Available through Anthropic's website and API services, Claude has evolved through several versions with improvements in capabilities and performance."))))

(setq width-list '(10 52))

(let* ((names (scholar101--get-string-list-from-records
               records :name (nth 0 width-list) t))
       (descs (scholar101--get-string-list-from-records
               records :description (nth 1 width-list)))
       (table-items (scholar101--generate-table
                     (list "name" "description")
                     (list names descs)
                     width-list)))
  (insert (mapconcat 'identity table-items "\n")))

(defun scholar101--fill-string-split (string width &optional no-bullet)
  "Convert single line string to multi-line filled content.
Output is a list of strings. Each string is corresponding line.

Param:
    string              : input string without bullet symbol
    width               : width of each line
    no-bullet (optional): whether append bullet symbol in the first line

Return:
    List of string
"
  (with-temp-buffer
     (let ((fill-column (- width 2)))
       (when no-bullet
         (setq fill-column width))
       (insert string)
       ;; fill content with specific column width
       (fill-region (point-min) (point-max))
       (unless no-bullet
         (goto-char (point-min))
         (insert "- ")
         (forward-line 1)
         (while (not (eobp))
           (insert "  ")
           (forward-line 1)))
       ;; pad space in the right when necessary
       (mapcar (lambda (x)
                 (format (concat "%-" (number-to-string width) "s") x))
               (split-string (buffer-substring (point-min)
                                               (point-max))
                             "\n")))))

(defun scholar101--get-string-list-from-record (record keyword width &optional no-bullet)
  "Transform the list of strings in record to multi-line string format.

Param:
    record : plist, each element has no bullet symbol
    keyword: the name of the list in the plist
    width  : width of each line

Return:
    List of string, if input list is empty,
        return one element list containing space.
"
  (let ((string-list (plist-get record keyword)))
    (unless (listp string-list)
      (setq string-list (list string-list)))
    (if (length string-list)
        (apply #'append
         (mapcar (lambda (item)
                   (scholar101--fill-string-split item width no-bullet))
                 string-list))
      (list (make-string width ?\ )))))

(defun scholar101--get-string-list-from-records (records keyword width &optional no-bullet)
  "Each record has a list, and all strings in the list will be formatted as multi-line.

Param:
    records: list of plists, each plist contains a list of strings without bullet symbol
    keyword: the name of the list in the plist
    width  : width of each line

Return:
    List of string list, each list corresponds to one record.
"
  (mapcar (lambda (record)
            (scholar101--get-string-list-from-record record keyword width no-bullet))
          records))

(defun scholar101--generate-table (head-list content-list width-list)
  "Generate table head and body, where body is given by
formating CONTENT-LIST according to WIDTH-LIST.

Params:
    HEAD-LIST   : a list of head strings, omit head line when setting to nil
    CONTENT-LIST: a list of columns, each column is a list of cells,
                  and each cell is a list of strings.
    WIDTH-LIST  : the width for space-padding each column's short cells.

Return:
    list of strings, each element is a line of the table.
"
  (let* ((length-column (length content-list))
         (length-cell (length (car content-list)))
         (split-line
          (concat
           "+" (mapconcat #'identity
                          (mapcar
                           (lambda (width)
                             (concat "-" (make-string width ?-) "-+"))
                           width-list)
                          "")))
         (result '()) head-line)
    (when head-list
      (setq head-line
            (concat
             "|" (mapconcat #'identity
                            (cl-mapcar
                             (lambda (head width)
                               (format (concat " %-" (number-to-string width) "s |") head))
                             head-list width-list)
                            ""))))
    (dotimes (i length-cell)
      ;; Extract the i-th row of cells across all columns
      (let ((cell-lists
             (mapcar (lambda (col) (nth i col))
                     content-list)))
        ;; Determine max length for this set of sub-lists
        (let ((max-len (apply #'max (mapcar #'length cell-lists))))
          ;; Augment shorter sub-lists
          (setq cell-lists
                ;; sublist consists lines of strings in a cell
                (cl-mapcar (lambda (sublist width)
                             (let ((len (length sublist)))
                               (if (< len max-len)
                                   (append sublist
                                           (make-list
                                            (- max-len len)
                                            (make-string width ? )))
                                 sublist)))
                           cell-lists width-list))
          ;; Now build each line for this i-th cell
          (dotimes (j max-len)
            (push
             (concat "|"
                     (mapconcat
                      #'identity
                      (mapcar
                       (lambda (col)
                         (concat " " (nth j col) " |"))
                       cell-lists)
                      ""))
             result))
          ;; Append an empty line after each cell block
          (push split-line result))))
    (if head-line
        (append
         (list split-line)
         (list head-line)
         (list split-line)
         (nreverse result))
      (append
       (list split-line)
       (nreverse result)))))