[nongnu] elpa/geiser-chicken bc3f877 049/102: Fuzzy matching for Chicken AutoDoc and Completions

[Philip Kaludercic]

branch: elpa/geiser-chicken
commit bc3f877abd346ed3f8419ab5a06d36b03ead31a6
Author: Dan Leslie <dan@ironoxide.ca>
Commit: Dan Leslie <dan@ironoxide.ca>

    Fuzzy matching for Chicken AutoDoc and Completions
    
    Because Chicken allows symbols to be imported with prefixes, and because
    'apropos' does not provide any utility to match with the loaded
    prefixes, it is difficult to acquire information about prefixed symbols.
    
    This solution hacks around the issue by providing naive
    fuzzy-matching. If no match for a symbol can be found then the first
    character is dropped and matching is attempted again; the process is
    repeated until matches are found or the entire symbol is consumed.
    
    Also removes the (now redundant and slow) geiser-chicken-prefix-delimiters.
---
 geiser/emacs.scm | 73 +++++++++++++++++++++++++++++++++-----------------------
 1 file changed, 43 insertions(+), 30 deletions(-)

diff --git a/geiser/emacs.scm b/geiser/emacs.scm
index d5bddf5..8ec3440 100644
--- a/geiser/emacs.scm
+++ b/geiser/emacs.scm
@@ -242,13 +242,18 @@
            (apropos-information-list "" #:macros? #t)))))
 
   (define (find-symbol-information prefix)
+    (define (find-symbol-information* prefix skipped)
+      (let ((found (filter
+                   (lambda (info)
+                     (string-has-prefix? (car info) prefix))
+                   (symbol-information-list))))
+       (if (and (null? found) (< 1 (string-length prefix)))
+           (find-symbol-information* (substring/shared prefix 1) 
(string-append skipped (substring prefix 0 1)))
+           (cons found skipped))))
     (memoize
      `(find-symbol-information ,prefix)
      (lambda ()
-       (filter
-       (lambda (info)
-         (string-has-prefix? (car info) (->string prefix)))
-       (symbol-information-list)))))
+       (find-symbol-information* (->string prefix) ""))))
   
   (define debug-log (make-parameter #f))
   (define (write-to-log form)
@@ -387,37 +392,42 @@
            (any (cut eq? type <>) types)))
        (match-nodes sym)))))
 
-  (define (make-module-list sym module-sym)
-    (if (not module-sym)
-       (find-standards-with-symbol sym)
-       (cons module-sym (find-standards-with-symbol sym))))
+  (define (make-module-list sym module-sym prefix-exists)
+    (append
+     (if prefix-exists '(fuzzy-match) '())
+     (if (not module-sym)
+        (find-standards-with-symbol sym)
+        (cons module-sym (find-standards-with-symbol sym)))))
   
-  (define (fmt node)
+  (define (fmt node prefix)
     (memoize
-     `(fmt ,node)
+     `(fmt ,node ,prefix)
      (lambda ()
-       (let* ((entry (string->symbol (car node)))
+       (let* ((original-entry (string->symbol (car node)))
+             (fuzzy-entry (string->symbol (string-append prefix (car node))))
+             (prefix-exists (not (= 0 (string-length prefix))))
              (module (cadr node))
              (module (if module (string->symbol module) #f))
              (rest (cddr node))
-             (type (if (or (list? rest) (pair? rest)) (car rest) rest)))
+             (type (if (or (list? rest) (pair? rest)) (car rest) rest))
+             (module-list (make-module-list fuzzy-entry module prefix-exists)))
         (cond
          ((equal? 'macro type)
-          `(,entry ("args" (("required" <macro>)
-                            ("optional" ...)
-                            ("key")))
-                   ("module" ,@(make-module-list entry module))))
+          `(,fuzzy-entry ("args" (("required" <macro>)
+                                  ("optional" ...)
+                                  ("key")))
+                         ("module" ,@module-list)))
          ((or (equal? 'variable type)
               (equal? 'constant type))
           (if (not module)
-              `(,entry ("value" . ,(eval entry)))
+              `(,fuzzy-entry ("value" . ,(eval original-entry)))
               (let* ((original-module (current-module))
                      (desired-module (find-module module))
                      (value (begin (switch-module desired-module)
-                                   (eval entry))))
+                                   (eval original-entry))))
                 (switch-module original-module)
-                `(,entry ("value" . ,value)
-                         ("module" ,@(make-module-list entry module))))))
+                `(,fuzzy-entry ("value" . ,value)
+                               ("module" ,@module-list)))))
          (else
           (let ((reqs '())
                 (opts '())
@@ -452,22 +462,20 @@
 
             (collect-args args)
 
-            `(,entry ("args" (("required" ,@reqs)
-                              ("optional" ,@opts)
-                              ("key" ,@keys)))
-                     ("module" ,@(make-module-list entry module))))))))))
+            `(,fuzzy-entry ("args" (("required" ,@reqs)
+                                    ("optional" ,@opts)
+                                    ("key" ,@keys)))
+                           ("module" ,@module-list)))))))))
 
   ;; Builds a signature list from an identifier
   (define (find-signatures sym)
     (memoize
      `(find-signatures ,sym)
      (lambda ()
-       (let ((str (symbol->string sym)))
+       (let ((result (find-symbol-information sym)))
         (map
-         (cut fmt <>)
-         (filter
-          (lambda (lst) (string=? (car lst) str))
-          (find-symbol-information sym)))))))
+         (cut fmt <> (cdr result))
+         (car result))))))
 
   ;; Builds the documentation from Chicken Doc for a specific symbol
   (define (make-doc symbol #!optional (filter-for-type #f))
@@ -584,7 +592,12 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
   (define (geiser-completions prefix . rest)
-    (map car (find-symbol-information prefix)))
+    (let* ((result (find-symbol-information prefix))
+          (prefix (cdr result))
+          (result-list (car result)))
+      (map
+       (cut string-append prefix <>)
+       (map car result-list))))
 
   (define (geiser-module-completions prefix . rest)
     (let ((prefix (->string prefix)))