Google Groups no longer supports new Usenet posts or subscriptions. Historical content remains viewable.
Dismiss

(asdf:oos 'asdf:unload-op 'cl-spont)

43 views
Skip to first unread message

JohnFredCee

unread,
Oct 30, 2006, 10:32:16 AM10/30/06
to

Suppose I make such a mess of loading and compiling my asdf package
(It's unsder
active development) that I wish to scracth the whole thing and start
again. Drastic,
I know - but sometimes it happens. (delete-package 'cl-spont) followed
by
(asdf:oos 'asdf:load-op 'cl-spont) doesn't seem to work...is it
actually possible, or does
the whole REPL have to be junked and restarted..?

Zach Beane

unread,
Oct 30, 2006, 10:36:49 AM10/30/06
to
"JohnFredCee" <jo...@yagc.ndo.co.uk> writes:

> Suppose I make such a mess of loading and compiling my asdf package
> (It's unsder active development) that I wish to scracth the whole
> thing and start again. Drastic, I know - but sometimes it
> happens. (delete-package 'cl-spont) followed by (asdf:oos
> 'asdf:load-op 'cl-spont) doesn't seem to work...

In what way does this strategy fail to work for you?

> is it actually possible, or does the whole REPL have to be junked
> and restarted..?

It's not always necessary to resort to this.

Zach

bradb

unread,
Oct 30, 2006, 11:40:47 AM10/30/06
to

Slightly offtopic - but why are ASDF calls of the form
(asdf:oos something package) ?

Surely something like
(asdf:load-op 'package) is nicer looking?

Cheers
Brad

Pascal Bourguignon

unread,
Oct 30, 2006, 12:22:53 PM10/30/06
to
"bradb" <brad.be...@gmail.com> writes:

But see here. I prefer: (asdf-load :package)
and somebody else might prefer: (asdf:load :package)
and somebody else might prefer to click on a GUI button,
and etc...

That's why there's no user interface in ASDF.
Just define in your ~/.clisprc.lisp file the one you want.

--
__Pascal Bourguignon__ http://www.informatimago.com/

"Remember, Information is not knowledge; Knowledge is not Wisdom;
Wisdom is not truth; Truth is not beauty; Beauty is not love;
Love is not music; Music is the best." -- Frank Zappa

Ralph Allan Rice

unread,
Oct 30, 2006, 2:30:13 PM10/30/06
to


I did do something similar to what Pascal suggested, but I always
wondered about REQUIRE. The CLHS states that REQUIRE is implementation
defined. CLISP has REQUIRE, but it does not hook into ASDF. So, I
attempted to redefine REQUIRE in two different ways, one way was to
redefine as a function:

; SLIME 2006-04-20
CL-USER> (defun require (symbol) (asdf:oos 'asdf:load-op symbol))
WARNING: DEFUN/DEFMACRO: redefining function REQUIRE in top-level, was
defined
in D:\gnu\clisp\current\build-O-mingw\defs1.fas
REQUIRE
CL-USER> (require 's-xml)
; loading system definition from C:\lisp\registry\s-xml.asd into
#<PACKAGE ASDF0>
;; Loading file C:\lisp\registry\s-xml.asd ...
; registering #<SYSTEM :S-XML #x19F4F251> as S-XML
;; Loaded file C:\lisp\registry\s-xml.asd
;; Loading file C:\lisp\packages\s-xml\src\package.fas ...
;; Loaded file C:\lisp\packages\s-xml\src\package.fas
;; Loading file C:\lisp\packages\s-xml\src\xml.fas ...
;; Loaded file C:\lisp\packages\s-xml\src\xml.fas
;; Loading file C:\lisp\packages\s-xml\src\dom.fas ...
;; Loaded file C:\lisp\packages\s-xml\src\dom.fas
;; Loading file C:\lisp\packages\s-xml\src\lxml-dom.fas ...
;; Loaded file C:\lisp\packages\s-xml\src\lxml-dom.fas
;; Loading file C:\lisp\packages\s-xml\src\sxml-dom.fas ...
;; Loaded file C:\lisp\packages\s-xml\src\sxml-dom.fas
;; Loading file C:\lisp\packages\s-xml\src\xml-struct-dom.fas ...
;; Loaded file C:\lisp\packages\s-xml\src\xml-struct-dom.fas
0 errors, 0 warnings
NIL


The second way was a macro:

; SLIME 2006-04-20
CL-USER> (defmacro require (symbol) `(asdf:oos 'asdf:load-op ,symbol))
WARNING: DEFUN/DEFMACRO: redefining function REQUIRE in top-level, was
defined
in D:\gnu\clisp\current\build-O-mingw\defs1.fas
REQUIRE
CL-USER> (require 's-xml)
; loading system definition from C:\lisp\registry\s-xml.asd into
#<PACKAGE ASDF0>
;; Loading file C:\lisp\registry\s-xml.asd ...
; registering #<SYSTEM :S-XML #x19F8AA9D> as S-XML
;; Loaded file C:\lisp\registry\s-xml.asd
;; Loading file C:\lisp\packages\s-xml\src\package.fas ...
;; Loaded file C:\lisp\packages\s-xml\src\package.fas
;; Loading file C:\lisp\packages\s-xml\src\xml.fas ...
;; Loaded file C:\lisp\packages\s-xml\src\xml.fas
;; Loading file C:\lisp\packages\s-xml\src\dom.fas ...
;; Loaded file C:\lisp\packages\s-xml\src\dom.fas
;; Loading file C:\lisp\packages\s-xml\src\lxml-dom.fas ...
;; Loaded file C:\lisp\packages\s-xml\src\lxml-dom.fas
;; Loading file C:\lisp\packages\s-xml\src\sxml-dom.fas ...
;; Loaded file C:\lisp\packages\s-xml\src\sxml-dom.fas
;; Loading file C:\lisp\packages\s-xml\src\xml-struct-dom.fas ...
;; Loaded file C:\lisp\packages\s-xml\src\xml-struct-dom.fas
0 errors, 0 warnings
NIL

Barring the fact that I created a non-standard redefinition of REQUIRE,
I think this has some value. However, the warning about the
redefinition of REQUIRE makes me think that this solution has other
consequences that are not clear to me. That's why I never actually used
this solution. Can anyone shed some light on this subject?

TIA
--
Ralph

Pascal Bourguignon

unread,
Oct 30, 2006, 2:54:45 PM10/30/06
to
"Ralph Allan Rice" <ralph...@gmail.com> writes:
> I did do something similar to what Pascal suggested, but I always
> wondered about REQUIRE. The CLHS states that REQUIRE is implementation
> defined. CLISP has REQUIRE, but it does not hook into ASDF. So, I
> attempted to redefine REQUIRE in two different ways, one way was to
> redefine as a function:
>
> ; SLIME 2006-04-20
> CL-USER> (defun require (symbol) (asdf:oos 'asdf:load-op symbol))
> WARNING: DEFUN/DEFMACRO: redefining function REQUIRE in top-level, was
> defined
> in D:\gnu\clisp\current\build-O-mingw\defs1.fas
> REQUIRE
> CL-USER> (require 's-xml)
> ; loading system definition from C:\lisp\registry\s-xml.asd into
> #<PACKAGE ASDF0>
> ;; Loading file C:\lisp\registry\s-xml.asd ...
> ; registering #<SYSTEM :S-XML #x19F4F251> as S-XML
> [...]

> 0 errors, 0 warnings
> NIL
>
> The second way was a macro:

Better to keep it a function. Somebody might be doing:

(map nil (function require) '(:cl-x :cl-y :cl-z))

> Barring the fact that I created a non-standard redefinition of REQUIRE,
> I think this has some value. However, the warning about the
> redefinition of REQUIRE makes me think that this solution has other
> consequences that are not clear to me. That's why I never actually used
> this solution. Can anyone shed some light on this subject?

REQUIRE takes an optional second argument, and when it's given, it's
portable and relatively precisely defined (only the result is not
defined). If you override it, you should keep this sematics.

(REQUIRE "MODULE" '(#P"/some/module/file1.lisp"
#P"/some/module/file2.lisp"
;; ...
#P"/some/module/fileN.lisp"))

When it's not given, I've no idea what REQUIRE does. We'd have to
read the implementation notes or source code.

(defun ensure-list (list-designator)
(if (listp list-designator)
list-designator
(list list-designator)))

(defvar *original-require* (symbol-function 'require))


(#+clisp ext:without-package-lock #+clisp ("COMMON-LISP")
#-clisp progn

;; A minimal conformant implementation of REQUIRE would be:
(defun require (module-name &optional pathname-list)
(check-type module-name (or string symbol character))
(unless (member (string module-name) *modules* :test (function string=))
(let ((pathname-list (ensure-list pathname-list)))
(if pathname-list
(dolist (path pathname-list) (load path))
(implementation-dependant-part-of-require module-name))))))

;; So you can modify the implementation dependant part as you want:

(defun implementation-dependant-part-of-require (module-name)
;; Do whatever you want here.
;; For example, if module-name is not a loadable asdf-system,
;; we could fallback to the original REQUIRE:
;; http://clisp.cons.org/impnotes/system-dict.html#require
(or (and (ignore-errors (asdf:oos 'asdf:load-op module-name))
;; PROVIDE is normally done by one of the loaded files.
;; I don't know if ASDF does it.
(provide (intern (string module-name) "KEYWORD")))
(funcall *original-require* module-name)))

--
__Pascal Bourguignon__ http://www.informatimago.com/

NOTE: The most fundamental particles in this product are held
together by a "gluing" force about which little is currently known
and whose adhesive power can therefore not be permanently
guaranteed.

JohnFredCee

unread,
Oct 31, 2006, 8:34:41 AM10/31/06
to

Zach Beane wrote:

Asdf simply fails to re-load the package. Here's the logs:

; SLIME 2006-10-28
CL-USER> (asdf:oos 'asdf:load-op 'cl-screen)
; loading system definition from
/home/johnc/.sbcl/systems/cl-screen.asd
; into #<PACKAGE "ASDF0">
; registering #<SYSTEM :CL-SCREEN {A9B0DB9}> as CL-SCREEN
; loading system definition from
; /home/johnc/.sbcl/systems/trivial-gray-streams.asd into
; #<PACKAGE "ASDF0">
; registering #<SYSTEM :TRIVIAL-GRAY-STREAMS {AB0A041}> as
; TRIVIAL-GRAY-STREAMS
; loading system definition from /home/johnc/.sbcl/systems/cffi.asd
into
; #<PACKAGE "ASDF0">
; registering #<SYSTEM CFFI {AC8A581}> as CFFI
; compiling file
"/home/johnc/projects/cl-screen/cl-screen-window-stream.lisp" (written
28 OCT 2006 09:56:32 PM):
; compiling (IN-PACKAGE :CL-SCREEN)
; compiling (DEFCLASS HISTORY-LINE ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFGENERIC ADD-SPACE-TO-HISTORY-LINE ...)
; compiling (DEFGENERIC ADD-CHAR-TO-HISTORY-LINE ...)
; compiling (DEFGENERIC REMOVE-CHAR-FROM-HISTORY-LINE ...)
; compiling (DEFGENERIC PRINT-HISTORY-LINE-TO-WINDOW ...)
; compiling (DEFMETHOD ADD-SPACE-TO-HISTORY-LINE ...)
; compiling (DEFMETHOD ADD-CHAR-TO-HISTORY-LINE ...)
; compiling (DEFUN TRIM-LAST-CHAR ...)
; compiling (DEFMETHOD REMOVE-CHAR-FROM-HISTORY-LINE ...)
; compiling (DEFMETHOD PRINT-HISTORY-LINE-TO-WINDOW ...)
; compiling (DEFCLASS CL-SCREEN-WINDOW-STREAM ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFGENERIC LAST-LINE-OF ...)
; compiling (DEFGENERIC ADD-CHAR ...)
; compiling (DEFGENERIC ADD-LINE ...)
; compiling (DEFMETHOD LAST-LINE-OF ...)
; compiling (DEFMETHOD ADD-CHAR ...)
; compiling (DEFMETHOD ADD-LINE ...)
; compiling (DEFMETHOD STREAM-WRITE-CHAR ...)
; compiling (DEFMETHOD STREAM-LINE-COLUMN ...)
; compiling (DEFMETHOD STREAM-START-LINE-P ...)
; compiling (DEFMETHOD STREAM-TERPRI ...)
; compiling (DEFMETHOD STREAM-ADVANCE-TO-COLUMN ...)
; compiling (DEFMETHOD STREAM-CLEAR-OUTPUT ...)
; compiling (DEFMETHOD STREAM-FINISH-OUTPUT ...)
; compiling (DEFMETHOD STREAM-FORCE-OUTPUT ...)

; /home/johnc/projects/cl-screen/cl-screen-window-stream.fasl written
; compilation finished in 0:00:01
NIL
CL-USER> (delete-package 'cl-screen)
T
CL-USER> (asdf:oos 'asdf:load-op 'cl-screen)
NIL
CL-USER>

Here's my package.lisp

(in-package :cl-user)

(eval-when (:execute :load-toplevel :compile-toplevel)
(defpackage :cl-screen (:use :cl :cffi :trivial-gray-streams)
(:nicknames :screen)
(:export
:tty-screen
:encode-key
:decode-key
:get-decoded-key
:initialize-screen
:release-screen
:set-cursor
:get-cursor
:clear-screen
:finish-screen
:write-string-at-cursor
:erase-from-cursor-to-eol
:erase-from-cursor-to-eos
:draw-line-at-cursor
:valid-color-p
:valid-colors
:set-color
:set-to-default-color
:get-screen-size
:screen-resize-hook)))

(in-package :cl-screen)

Bill Atkins

unread,
Oct 31, 2006, 9:31:56 AM10/31/06
to
"JohnFredCee" <jo...@yagc.ndo.co.uk> writes:

(asdf:oos 'asdf:load-op :BLACH :force t)

Bill Atkins

unread,
Oct 31, 2006, 11:33:38 AM10/31/06
to
"bradb" <brad.be...@gmail.com> writes:

> Slightly offtopic - but why are ASDF calls of the form
> (asdf:oos something package) ?
>
> Surely something like
> (asdf:load-op 'package) is nicer looking?
>
> Cheers
> Brad

I never understood this either. Even if there are good technical
reasons for having a generic OPERATE function that takes an op and
argument (like being able to have ops inherit behavior from other
ops), I don't see the harm in having a convenience layer on top of
this.

It's always embarassing when showing Lisp to people and inevitably
getting asked why such an unwieldy and intimidating expression as
(asdf:oos 'asdf:load-op :system) has to be used to load systems. I
don't have any good explanation for it. Personally, I use the (asdf
:system) function that comes with Edi Weitz's lw-add-ons, but I don't
see why the user of ASDF should have to bring his or her own
interface.

Pascal Bourguignon

unread,
Oct 31, 2006, 12:24:51 PM10/31/06
to
Bill Atkins <atk...@rpi.edu> writes:
> It's always embarassing when showing Lisp to people and inevitably
> getting asked why such an unwieldy and intimidating expression as
> (asdf:oos 'asdf:load-op :system) has to be used to load systems. I
> don't have any good explanation for it. Personally, I use the (asdf
> :system) function that comes with Edi Weitz's lw-add-ons, but I don't
> see why the user of ASDF should have to bring his or her own
> interface.

For the same reason a X user has to bring his own window manager.

They implement mechanism, but force no policy.


Users may want something more interactive. And I won't even evoke McCLIM...

[58]> (collect-asdf-systems)
240
[59]> (asdf)


1: albert
2: alpaca
3: anaphora
4: araneida
5: arnesi
:
...: ...
:
237: xrender
238: yaclml
239: zip
240: zlib

What system should I load (number, name or :abort)? 239
; loading system definition from /usr/local/asdf-install/site-systems/zip.asd into #<PACKAGE ASDF0>
;; Loading file /usr/local/asdf-install/site-systems/zip.asd ...
; registering #<SYSTEM :ZIP #x2053EECE> as ZIP
...



(defun number-list (list)
(loop
:for n :from 1
:for item :in list
:collect (cons n item)))

(defun collect-asdf-systems ()
(setf *asdf-systems*
(number-list
(sort
(delete-duplicates
(mapcar (function pathname-name)
(mapcan (lambda (path)
(let ((dir (typecase path
((or symbol cons) (eval path))
(otherwise (pathname path)))))
(ignore-errors
(directory
(merge-pathnames
(make-pathname
:directory '(:relative :wild-inferiors)
:name :wild :type "ASD" :version :wild
:case :common :defaults dir)
dir nil)))))
asdf:*central-registry*))
:test (function equal))
(function string<=))))
(length *asdf-systems*))

(defparameter *asdf-systems* nil)

(defun asdf ()
(format *query-io* "~2%")
(format *query-io* "~:{~3D: ~A~%~}"
(mapcar (lambda (item)
(list (car item) (pathname-name (cdr item))))
*asdf-systems*))
(format *query-io* "~%What system should I load (number, name or :abort)? ")
(let ((sys (read *query-io*)))
(asdf:oos
'asdf:load-op
(cond
((let ((ass (assoc sys *asdf-systems*))) (and ass (cdr ass))))
((let ((ass (rassoc sys *asdf-systems*))) (and ass (cdr ass))))
((string-equal :abort sys) (return-from asdf (values)))
(t (return-from asdf (progn (format *query-io* "~&~S invalid. Abort.")
(return-from asdf (values)))))))))

--
__Pascal Bourguignon__ http://www.informatimago.com/

"This statement is false." In Lisp: (defun Q () (eq nil (Q)))

Bill Atkins

unread,
Oct 31, 2006, 12:36:19 PM10/31/06
to
Pascal Bourguignon <p...@informatimago.com> writes:

> Bill Atkins <atk...@rpi.edu> writes:
>> It's always embarassing when showing Lisp to people and inevitably
>> getting asked why such an unwieldy and intimidating expression as
>> (asdf:oos 'asdf:load-op :system) has to be used to load systems. I
>> don't have any good explanation for it. Personally, I use the (asdf
>> :system) function that comes with Edi Weitz's lw-add-ons, but I don't
>> see why the user of ASDF should have to bring his or her own
>> interface.
>
> For the same reason a X user has to bring his own window manager.
>
> They implement mechanism, but force no policy.

No policy would be forced. ASDF:OOS still exists underneath, so you
can write any extensions you'd like on top of it. But if 99.9% of
ASDF use follows the same pattern, why not make an interface to it so
that users can easily load systems from the REPL?

Pascal Bourguignon

unread,
Oct 31, 2006, 12:57:05 PM10/31/06
to
Bill Atkins <atk...@rpi.edu> writes:

I forgot to put a ;-)

--
__Pascal Bourguignon__ http://www.informatimago.com/

Nobody can fix the economy. Nobody can be trusted with their finger
on the button. Nobody's perfect. VOTE FOR NOBODY.

Thomas A. Russ

unread,
Oct 31, 2006, 5:38:29 PM10/31/06
to
"bradb" <brad.be...@gmail.com> writes:

>
> Slightly offtopic - but why are ASDF calls of the form
> (asdf:oos something package) ?

I would guess that it is mainly so that you have an extensible mechanism
for adding new operations. That allows additional operations to be
provided besides the standard load or compile options. Perhaps a
'my-doc:generate-documentation operation instead.

This is a worthy goal, but...

> Surely something like
> (asdf:load-op 'package) is nicer looking?

it also doesn't preclude convenience operations like the above being
defined for the most common operations. That would be a nice
enhancement to have, even if the entire implementation were

(defun load-op (package-name)
(oos 'load-op package-name))

--
Thomas A. Russ, USC/Information Sciences Institute

Maciek Pasternacki

unread,
Oct 31, 2006, 7:44:44 PM10/31/06
to

Because ASDF:LOAD-OP is a class. All ASDF operations are classes,
which allows one to define own operations with different input/output
files, different routines for checking if component did change and
needs recompiling/reloading, etc. Systems and components (NOT
packages, packages are different part of ANSI CL) are also classes;
this way it's possible to very flexibly extend ASDF without need to
hack on asdf.lisp itself.

This way you can compile, load, test, pack tarballs, count number of
lines, clean up, and more -- using different operation on the same
system.

Nothing prevents you from writing yourself a macro or function with
shortcut form for invoking LOAD-OP. Or using comma-l in SLIME REPL.
Or making CL:REQUIRE call ASDF:OPERATE 'ASDF:LOAD-OP, as it already
does in SBCL. But ASDF design is there for a reason.

--
__ Maciek Pasternacki <mac...@japhy.fnord.org> [ http://japhy.fnord.org/ ]
`| _ |_\ / { ...I will wear you white feather, I will carry
,|{-}|}| }\/ your white flag, I will swear I have no nation,
\/ |____/ but I'm proud to own my heart... } ( Fish ) -><-

grackle

unread,
Oct 31, 2006, 10:35:43 PM10/31/06
to
Maciek Pasternacki wrote:
> Nothing prevents you from writing yourself a macro or function with
> shortcut form for invoking LOAD-OP. Or using comma-l in SLIME REPL.
> Or making CL:REQUIRE call ASDF:OPERATE 'ASDF:LOAD-OP, as it already
> does in SBCL. But ASDF design is there for a reason.

If nothing prevents the creation of a shortcut form, then what is the
reason? The reason for the lack of a standard shortcut, that is, not
the reason for the design of ASDF.

-David

Rob Warnock

unread,
Nov 1, 2006, 12:06:54 AM11/1/06
to
Bill Atkins <atk...@rpi.edu> wrote:
+---------------
| But if 99.9% of ASDF use follows the same pattern...
+---------------

What, you mean something like this? ;-}

(defun asdf (&rest systems) ;save a bunch of typing
(if systems
(dolist (system systems)
(asdf:operate 'asdf:load-op system))
(let ((all-asd (directory "/usr/local/lib/cmucl/lib/local/systems/")))
(format t "Available systems:~%~a~%"
(sort (mapcar #'pathname-name all-asd) #'string<)))))


-Rob

-----
Rob Warnock <rp...@rpw3.org>
627 26th Avenue <URL:http://rpw3.org/>
San Mateo, CA 94403 (650)572-2607

Maciek Pasternacki

unread,
Nov 1, 2006, 12:36:27 PM11/1/06
to

There is a shortcut, comma-l in SLIME REPL. And (REQUIRE) in SBCL.
ASDF itself doesn't give one, because UI sugar isn't its task. User
(i.e. you in your initialization files) or vendor (like SLIME or SBCL
guys, probably there are other short forms that I'm not aware of) does
this as he or her see fit.

--
__ Maciek Pasternacki <mac...@japhy.fnord.org> [ http://japhy.fnord.org/ ]

`| _ |_\ / { Any road followed to its end leads precisely nowhere. Climb
,|{-}|}| }\/ the mountain just a little to test it's a mountain. From the top
\/ |____/ of the mountain you cannot see the mountain. } ( F.Herbert ) -><-

Bill Atkins

unread,
Nov 1, 2006, 2:17:23 PM11/1/06
to
rp...@rpw3.org (Rob Warnock) writes:

> Bill Atkins <atk...@rpi.edu> wrote:
> +---------------
> | But if 99.9% of ASDF use follows the same pattern...
> +---------------
>
> What, you mean something like this? ;-}
>
> (defun asdf (&rest systems) ;save a bunch of typing
> (if systems
> (dolist (system systems)
> (asdf:operate 'asdf:load-op system))
> (let ((all-asd (directory "/usr/local/lib/cmucl/lib/local/systems/")))
> (format t "Available systems:~%~a~%"
> (sort (mapcar #'pathname-name all-asd) #'string<)))))

Yep. :-) And that's more or less what I have in my .lispworks. I
still think it would be a good idea to include it in ASDF by default.

Thomas A. Russ

unread,
Nov 6, 2006, 11:45:15 AM11/6/06
to
Maciek Pasternacki <mac...@japhy.fnord.org> writes:

> On Setting Orange, The Aftermath 13, 3172 YOLD, grackle wrote:
>
> >> Nothing prevents you from writing yourself a macro or function with
> >> shortcut form for invoking LOAD-OP. Or using comma-l in SLIME REPL.
> >> Or making CL:REQUIRE call ASDF:OPERATE 'ASDF:LOAD-OP, as it already
> >> does in SBCL. But ASDF design is there for a reason.
> >
> > If nothing prevents the creation of a shortcut form, then what is the
> > reason? The reason for the lack of a standard shortcut, that is, not
> > the reason for the design of ASDF.
>
> There is a shortcut, comma-l in SLIME REPL. And (REQUIRE) in SBCL.
> ASDF itself doesn't give one, because UI sugar isn't its task. User
> (i.e. you in your initialization files) or vendor (like SLIME or SBCL
> guys, probably there are other short forms that I'm not aware of) does
> this as he or her see fit.

I don't buy this argument.

The problem with various vendor-specific shortcuts is that they are not
portable. If there is general agreement that some set of shortcuts is
reasonable, then having them part of the standard code-base is a good
thing, so that they will work on whatever platforms ASDF works on.
Otherwise, they aren't really that useful as shortcuts.

0 new messages