about common lisp library for using external package locally

1. WITH-PACKAGE
Common lisp library
for using
external package locally

2. Goal
(with-use-package(alexandria)
(iota 3))
=> (0 1 2)

3. Goal
(with-import(alexandria iota)
(iota 3))
=>(0 1 2)

4. Index
●
Utilities
●
Strategy
●
Implementation
●
Restrections
●
TODO

5. Utilities
(defun ensure-list(arg)
(if(listp arg)
arg
(list arg)))

6. Utilities
(defun efind-package(arg &rest format-args)
(let((temp(find-package arg)))
(if temp
temp
(if format-args
(apply #'error format-args)
(error "Can not find package ~S" arg)))))

7. Utilities
(defun pairp(arg)
(and(consp arg)
(atom(cdr arg))
(not(null(cdr arg)))))

8. Utilities
(defun mapleaf (fn tree)
(cond
((null tree) nil)
((atom tree)(funcall fn tree))
((pairp tree)(cons(funcall fn (car tree))
(funcall fn (cdr tree))))
(t (cons(mapleaf fn (car tree))
(mapleaf fn (cdr tree))))))

9. Strategy
(let((*package*(find-package :alexandria)))
(iota 3))

10. Strategy
(cl:let((cl:*package*(cl:find-package keyword:alexandria)))
(example::iota 3))

11. Strategy
Reintern
specified symbols
into
specified package bofore eval.

12. Implementation
(defun treatment(black-list tree)
(mapleaf #'(lambda(leaf)
(if(and(not(keywordp leaf))
(symbolp leaf)
(symbol-package leaf))
(if(member leaf black-list :test #'string=)
(intern(string leaf))
leaf)
leaf))
tree))

13. Implementation
(defmacro with-import((package &rest commands)&body body)
(let((*package*(efind-package package
"WITH-PACKAGE:WITH-IMPORT signaled!~&~
Can not find package ~S."package)))
`(progn ,@(treatment commands body))))

14. Implementation
(defmacro with-use-package((package &key(except nil)(with-internal nil))&body body)
(let((*package*(efind-package package
"WITH-PACKAGE:WITH-USE-PACKAGE signaled!~&~
Can not find package ~S"package)))
`(progn ,@(treatment
(loop for symbol being each external-symbol in package
collect symbol into black-list
finally (return(nconc(ensure-list with-internal)
(set-exclusive-or black-list(ensure-list except) :test #'string=))))
body))))

15. Restrictions
●
Only one package can
use.
●
Force shadowing.
●
Name separation.

16. Only one package can use.
●
You can nest command.

17. Force shadowing.
●
Already we know about it.
(flet((car(arg)
"Which do you like cl:car or me?"
(declare(ignore arg))
(princ "You chose me! I loveyou!")))
(cl:car '(a b c)))
=> You chose me! I love you!
"You chose me! I love you!"

18. Force Shadowing.
●
Similar FLET
(defun iota(arg)
(declare(ignore arg))
(princ "I am iota."))
(with-use-package(alexandria)
(example::iota 3))
=> (0 1 2)

19. Name separation.
(defun foo (png)
(with-use-package(zpng)
(start-png png)
(write-png png)
(finish-png png)))

20. Name separation.
(cl:defun example::foo (example::png)
(zpng:start-png zpng:png)
(zpng:write-png zpng:png)
(zpng:finish-png zpng:png))

21. Alternatives
(with-use-package(zpng)
(defun foo (png)
(start-png png)
(write-png png)
(finish-png png)))

22. Alternatives
(defun foo(png)
(with-use-package(zpng :except (png))
(start-png png)
(write-png png)
(finish-png png)))

23. Alternatives
(defun foo(png)
(with-import(zpng start-png write-png finish-png))
(start-png png)
(write-png png)
(finish-png png)))

24. TODO
Probably
nothing

25. If dare to propose...
(defun treatment(black-list tree)
(mapleaf #'(lambda(leaf)
(if(and(not(keywordp leaf))
(symbolp leaf))
(if(member leaf black-list :test #'string=)
(intern(string leaf))
leaf)
leaf))
tree))

26. Completely no pollutions
(with-use-package(#:alexandria)
(#:iota 3))
=> (0 1 2)
(with-import(#:alexandria #:iota)
(#:iota 3))
=> (0 1 2)