as-list

Update: Now part of brev-separate.

Here is a functional combinator for Scheme that lets its arguments treat their arguments as if they were lists.

((as-list (c filter odd?)) 130752)

⇒ 1375

((as-list cdr reverse) 23311358)

⇒ 5311332

((as-list delete-duplicates) 23311358)

⇒ 23158

((as-list append) 11 22)

⇒ 1122

(define (vowel? l) ((as-list (c member l)) "aeiou"))
((as-list (c filter vowel?)) "magnetic mountaintop")

⇒ “aeiouaio”

Together with over:

((as-list (over (if (vowel? x) x (char-upcase x)))) "fleet foxes")

⇒ “FLeeT FoXeS”

Here is the implementation for Chicken. It uses c from define-curry, and match-define.

(define (record? x)
  (and
   (not (##sys#immediate? x))
   (##sys#structure? x (##sys#slot x 0))))

(match-define
 ((list-> (? integer? x))
   (o string->number list->string
      (c map (o (cut string-ref <> 0) number->string))))
 ((list-> (? string? x)) list->string)
 ((list-> (? vector? x)) list->vector)
 ((list-> (? hash-table? x)) alist->hash-table)
 ((list-> (? record? r)) (fn (apply ##sys#make-structure (##sys#slot r 0) x)))
 ((list-> (? list? x)) identity))

(match-define
 ((->list (? integer? x))
   (map (o string->number string) (string->list (number->string x))))
 ((->list (? string? x)) (string->list x))
 ((->list (? vector? x)) (vector->list x))
 ((->list (? hash-table? x)) (hash-table->alist x))
 ((->list (? record? x)) (map (cut ##sys#slot x <>) (iota (sub1 (##sys#size x)) 1)))
 ((->list (? list? x)) x))

(define ((as-list . procs) . xs)
  (let ((ret (apply (apply compose procs) (map ->list xs))))
    (if (list? ret)
	 ((list-> (car xs)) ret)
	 ret)))