Re: use-package.el -> Emacs core

[phillip.lord@russet.org.uk (Phillip Lord)]

João Távora <joaotavora@gmail.com> writes:

> Pedro Silva <psilva@pedrosilva.pt> writes:
>
>> :ensure (automatic ELPA installation), :defer (lazy loading) and
>> :commands (autoloading) are the things I most use in `use-package'
>> that are not as easy to achieve with `with-eval-after-load'.
>
> Not as easy? Sure, more characters, but basically the same complexity. I
> don't think it's worth a whole new language to be able to replace:
>
>   (package-install 'foo)

> Especially given that the use-package versions force the reader (or the
> grepper) to look around for context, while the regular versions don't.

use-package introduces a single (documented) form. So, it's easy to
re-eval everything, and keeps all your code in one place. Trivial as
this sounds, this is actually pretty useful.

In your examples, you need to "progn" everything to achieve the same.


> But perhaps I'm misinterpreting what these directives actually do, or
> perhaps you can illustrate with some snippets of your own.


What use-package does is syntactic sugar for sure, but it also does add
some nice functionality. So, for example, this

(use-package foo
  :load-path "~/foo"
  :commands foo-a foo-b foo-c
  :defer 5
  )

actually does this...


(progn
  (eval-and-compile
    (push "~/foo" load-path))
  (run-with-idle-timer 5 nil #'require 'foo nil t)
  (unless
      (fboundp 'foo-a)
    (autoload #'foo-a "foo" nil t))
  (unless
      (fboundp 'foo-b)
    (autoload #'foo-b "foo" nil t))
  (unless
      (fboundp 'foo-c)
    (autoload #'foo-c "foo" nil t)))

while the apparently much simpler:

(use-package foo
  :load-path "~/foo"
  )

actually does this:

(progn
  (eval-and-compile
    (push "~/foo" load-path))
  (let
      ((now
        (current-time)))
    (message "%s..." "Loading package foo")
    (prog1
        (if
            (not
             (require 'foo nil 'noerror))
            (ignore
             (message
              (format "Could not load %s" 'foo))))
      (let
          ((elapsed
            (float-time
             (time-subtract
              (current-time)
              now))))
        (if
            (> elapsed 0.1)
            (message "%s...done (%.3fs)" "Loading package foo" elapsed)
          (message "%s...done" "Loading package foo"))))))

A useful system for working out why your .emacs is so slow to load.

*shrugs*. I really like it, and it's made my .emacs cleaner.

Phil