until found

[elbb.git] / code / elbb.el

* how to access a large datastructure efficiently?

To: help-gnu-emacs@gnu.org
From: Thierry Volpiatto <thierry.volpiatto@gmail.com>
Date: Thu, 04 Mar 2010 17:09:35 +0100
Subject: Re: how to access a large datastructure efficiently?

Andreas Röhler <andreas.roehler@easy-emacs.de> writes:

> Thierry Volpiatto wrote:
>> Andreas Röhler <andreas.roehler@easy-emacs.de> writes:
>> 
>>> Thierry Volpiatto wrote:
>>>> Thierry Volpiatto <thierry.volpiatto@gmail.com> writes:
>>>>
>>>>> Hi,
>>>>>
>>>>> Christian Wittern <cwittern@gmail.com> writes:
>>>>>
>>>>>> Hi there,
>>>>>>
>>>>>> Here is the problem I am trying to solve:
>>>>>>
>>>>>> I have a large list of items which I want to access.  The items are in 
>>>>>> sequential order, but many are missing in between, like:
>>>>>>
>>>>>> (1 8 17 23 25 34 45 47 50)  [in reality, there is a value associated 
>>>>>> with this, but I took it out for simplicity]
>>>>>>
>>>>>> Now when I am trying to access with a key that is not in the list, I 
>>>>>> want to have the one with the closest smaller key returned, so for 6 
>>>>>> and 7 this would be 1, but for 8 and 9 this would be 8.
>>>>>>
>>>>>> Since the list will have thousands of elements, I do not want to simply 
>>>>>> loop through it but am looking for better ways to do this in Emacs lisp.  
>>>>>> Any ideas how to achieve this?
>>>>> ,----
>>>>> | (defun closest-elm-in-seq (n seq)
>>>>> |   (let ((pair (loop with elm = n with last-elm
>>>>> |                  for i in seq
>>>>> |                  if (and last-elm (< last-elm elm) (> i elm)) return (list last-elm i)
>>>>> |                  do (setq last-elm i))))
>>>>> |     (if (< (- n (car pair)) (- (cadr pair) n))
>>>>> |         (car pair) (cadr pair))))
>>>>> `----
>>>>>
>>>>> That return the closest, but not the smaller closest, but it should be
>>>>> easy to adapt.
>>>> Case where your element is member of list, return it:
>>>>
>>>> ,----
>>>> | (defun closest-elm-in-seq (n seq)
>>>> |   (let ((pair (loop with elm = n with last-elm
>>>> |                  for i in seq
>>>> |                  if (eq i elm) return (list i)
>>>> |                  else if (and last-elm (< last-elm elm) (> i elm)) return (list last-elm i)
>>>> |                  do (setq last-elm i))))
>>>> |     (if (> (length pair) 1)
>>>> |         (if (< (- n (car pair)) (- (cadr pair) n))
>>>> |             (car pair) (cadr pair))
>>>> |         (car pair))))
>>>> `----
>>>> For the smallest just return the car...
>>>>
>>> if n is member of the seq, maybe equal-operator too
>>>
>>> (<= last-elm elm)
>>>
>>> is correct?
>> 
>> No, in this case:
>> 
>> if (eq i elm) return (list i) ==> (i) ; which is n
>> 
>> and finally (car pair) ==> n
>> 
>
> Hmm, sorry being the imprecise,
> aimed at the first form, whose result equals the the second form once implemented this "="

Ok, i understand, yes, we can do what you say and it's more elegant, i
just notice also i forget to remove a unuseful else:

,----
| (defun closest-elm-in-seq (n seq)
|   (let ((pair (loop with elm = n with last-elm
|                  for i in seq
|                  if (and last-elm (<= last-elm elm) (> i elm)) return (list last-elm i)
|                  do (setq last-elm i))))
|     (if (< (- n (car pair)) (- (cadr pair) n))
|         (car pair) (cadr pair))))
`----

That should work the same.
Thanks. ;-)

-- 
Thierry Volpiatto
Gpg key: http://pgp.mit.edu/

To: help-gnu-emacs@gnu.org
From: Andreas Politz <politza@fh-trier.de>
Date: Thu, 04 Mar 2010 17:49:54 +0100
Subject: Re: how to access a large datastructure efficiently?

[ ... ]

I don't know how hash-table could help in this case, but maybe you want
to consider binary trees, as implemented in the avl-tree.el package.
Though, there is no function for finding the closest member with respect
to some data and a distance-function, but see below.

Finding a (closest) member should be constraint in logarithmic time.

(require 'avl-tree)

(setq avl (avl-tree-create '<))

(dotimes (i 2000)
  (when (= 0 (% i 4))
    (avl-tree-enter avl i)))

(avl-tree-member avl 80)
=> 80
(avl-tree-member avl 70)
=> nil

(defun avl-tree-closest-member (tree data delta-fn)
  ;; delta-fn : data x data -> Z
  (flet ((comp-delta (node)
           (funcall delta-fn data
                    (avl-tree--node-data node))))
    (let* ((node (avl-tree--root tree))
           closest
           (delta most-positive-fixnum)
           (compare-function (avl-tree--cmpfun tree))
           found)
      (while (and node
                  (not found))
        (when (< (comp-delta node) delta)
          (setq delta (comp-delta node)
                closest node))
        (cond
         ((funcall compare-function data (avl-tree--node-data node))
          (setq node (avl-tree--node-left node)))
         ((funcall compare-function (avl-tree--node-data node) data)
          (setq node (avl-tree--node-right node)))
         (t
          (setq found t))))
      (if closest
          (avl-tree--node-data closest)
        nil))))

(mapcar 
 (lambda (data)
   (avl-tree-closest-member
    avl data (lambda (n1 n2)
               (abs (- n1 n2)))))
 '(1001 1002 1003 1004))

=> (1000 1004 1004 1004)

-ap

* cedet and auto-complete

To: help-gnu-emacs@gnu.org
From: Richard Riley <rileyrgdev@gmail.com>
Date: Tue, 02 Mar 2010 08:26:20 +0100
Subject: Re: cedet and auto-complete

Richard Riley <rileyrgdev@gmail.com> writes:

> Just another quick poll to see if anyone has got the new cedet working
> with auto-complete. cedet has developed its own completion UIs but
> ideally I would like to use auto-complete as I do in all other
> modes. Has anyone a workaround or instructions for allowing this to
> work? Unfortunately if you only enable the minimum features which then
> turns off the cedet completion mechs, it also turns off the semantic
> navigation features which kind of detracts from its usefulness.
>
> Any help or pointer appreciated,
>
> r.
>

OK, user errror to a degree - I have now moved back to company-mode
(newer version is available) and made sure it was on the load path
before the version that came with nxhtml.

Works well.

Here is my simple setup which turns on ispell support in text-mode and
so works in gnus message modes.

(add-to-list 'load-path "~/.emacs.d/company-mode")
(require 'company)
(add-hook 'text-mode-hook (lambda()(add-to-list 'company-backends 'company-ispell)))
(require 'company-ispell)
(global-company-mode)

This is with cedet 1.0pre7 and company-mode 0.5

* hide-show squash-minor-modes

From: Thien-Thi Nguyen <ttn@gnuvola.org>
To: Andreas Roehler <andreas.roehler@online.de>
Subject: Re: hideshow condensed view
Date: Thu, 25 Feb 2010 16:21:27 +0100

() Andreas Roehler <andreas.roehler@online.de>
() Thu, 25 Feb 2010 15:24:24 +0100

   thanks a lot maintaining hideshow.el.

In the last few years, i can't take any credit for its improvement.
See Emacs' ChangeLog for those who actually merit the appreciation...

   Use it as default outline-mode now.

Cool.

   Just one thing remains so far: hs displays an empty
   line between headers. Would prefer a more condensed
   view.

You must have good eyes (still); i use hideshow not
for density but for spaciousness.

   Might it be possible to introduce a function
   `hide-all-empty-lines', inclusive a variable which may
   be customized?

Yeah, it would be possible, but i tend to think of empty lines outside
the (top-level) blocks as also outside the scope of hideshow.  It's like
in the book GEB, there is the tree and there is the stuff outside the
tree.  Get it?

I am already troubled by hideshow straying from its conceptual (both
meanings) simplicity -- a block is between matching parens, no more no
less -- but that's just me...

All this is to say, you probably should write a "squash minor mode",
which puts the invisible property on an overlay for text that matches
the empty line regexp (which of course, could be made customizable), at
which point my advice would be to add a hook to `hs-hide-all' to enable
this mode.

Here's a quick (but tested (lightly)) sketch:

 (defvar empty-lines-rx "^\\s-*\\(\n\\s-*\\)+")
 
 (defvar empty-lines nil
   "List of empty lines (overlays).")
 
 (defvar squash-minor-mode nil)
 
 (defun squash-minor-mode () 
   (interactive)
   (setq squash-minor-mode (not squash-minor-mode))
   (if squash-minor-mode
       (save-excursion
         (goto-char (point-min))
         (while (re-search-forward empty-lines-rx nil t)
           (let ((ov (make-overlay (match-beginning 0) (match-end 0))))
             (overlay-put ov 'display "")
             (push ov empty-lines))))
     (mapc 'delete-overlay empty-lines)
     (setq empty-lines nil))
   (message "empty-lines squashing %s" (if squash-minor-mode 'on 'off)))
 
Have fun!

thi

* questioning let

Andreas Roehler <andreas.roehler@online.de> writes:

> Hi,
>
> behaviour of the example code below puzzles me. Would
> expect setting of arg by external function, but inside
> `let', recognised. But remains `1'.
>
> (defun arg-setting ()
>   (interactive)
>   (let ((arg 1))
>     (message "%s" arg)
>     (arg-extern arg)
>     (message "%s" arg)))
>
> (defun arg-extern (arg)
>   (setq arg (1- arg)))
>
> Any help?

From: David Kastrup <dak@gnu.org>
Date: Wed, 24 Feb 2010 19:10:38 +0100
To: help-gnu-emacs@gnu.org
Subject: Re: questioning let

>> The argument binding in arg-extern is the innermost one and consequently
>> the only affected one.  If you make the function argument-less, it will
>> likely work as expected by you, affecting the binding in arg-setting.
>
> That works, thanks a lot!
> However, stored in some eil.el, get a compiler warning than:
>
>
> In arg-extern:
> eil.el:9:9:Warning: reference to free variable `arg'
> eil.el:9:17:Warning: assignment to free variable `arg'
>
> Would think a useless warning, as the compiler should know being inside a let (?)

The warning is completely accurate since arg-extern can be called from
outside arg-setting, in which case it will assign to a global variable
called "arg".

Whether or not some let-binding might be effective at the point of
calling arg-extern is unknown to the compiler.

In a Lisp variant with lexical binding (like Common Lisp or Scheme),
arg-extern has no way to fiddle with the let-binding of arg-setting: it
is completely inaccessible by name outside of arg-setting itself.

-- 
David Kastrup

From: pjb@informatimago.com (Pascal J. Bourguignon)
Date: Wed, 24 Feb 2010 12:59:22 +0100
To: help-gnu-emacs@gnu.org
Subject: Re: questioning let

let is equivalent to lambda:

  (let ((a 1) (b 2)) (list a b)) <=> ((lambda (a b) (list a b)) 1 2)

defun is binding a lambda to a function cell:

  (defun f (a b) (list a b))
       <=> (setf (symbol-function 'f) (lambda (a b) (list a b)))

Therefore you can see that calling a function defined by defun is a let
in disguise.

If you transformed your code following these equivalences, you would
notice that you have actually TWO variables named arg, one as parameter
of the function arg-extern, and one as variable in the let in
arg-setting.

The setq in arg-extern will modify only the variable parameter of
arg-extern.  Because they have the same name, this variable hides the
one defined in the let of arg-setting.  There's no way to access it from
within arg-extern.

If they had a different name, you could modify a variable from an outer
dynamic scope from an inner dynamic scope, because in emacs all the
variables are dynamic.  But it is considered very bad form to do so:
this is a big side effect, and what's more, one that depends on the call
chain.  You should avoid side effects, to increase the readability and
debugability of your code.  Therefore you should avoid setq and setf.
Try to write pure function, never try to modify a variable.

One way to write your code would be:

(defun do-what-you-need-to-do-with (arg)
   )

(defun arg-binding ()
  (interactive)
  (let ((arg 1))
     (message "before arg = %s" arg)
     (let ((arg (arg-extern arg)))
       (message "after arg = %s" arg)
       (do-what-you-need-to-do-with arg))
     (message "original arg = %s" arg)))

(defun arg-extern (arg)
   (message "arg-extern before arg = %s" arg)
   (message "arg-extern returns = %s" (1- arg))
   (1- arg))

before arg = 1
arg-extern before arg = 1
arg-extern returns = 0
after arg = 0
original arg = 1

If you need a global variable (perhaps because you need to keep some
data across command invocations), the I would advise to distringuish it
from the other by giving it a name surrounded by stars: *var*.  Then, it
will have a different name, and won't be shadowed (inadvertantly) by
inner lets, defuns or lambdas.

(defvar *var* 42)

(defun arg-extern (arg)
   (message "arg-extern before arg = %s" arg)
   (setf *var* (1- arg))
   (message "arg-extern returns = %s" *var*)
   *var*)

(arg-binding)
 var*  --> 0

-- 
__Pascal Bourguignon__

* real tab completion in shell-mode

To: help-gnu-emacs@gnu.org
From: Andreas Politz <politza@fh-trier.de>
Date: Tue, 23 Feb 2010 19:43:58 +0100
Subject: Re: real tab completion in shell-mode

Nathaniel Flath <flat0103@gmail.com> writes:

> Hello,
> Is there any way to get shell mode to use the background shell's
> (zsh or bash) tab completion as opposed to just tab-completing
> filenames?  I know about ansi-term, but I hate how it steals a lot
> of my keybindings and so I would prefer it if I could get this to
> work in shell-mode.

There is not really a clean way to implement this for different reasons.

>
> Thanks,
> Nathaniel Flath

A while ago, I did it anyway and wrote a special mode for bash-shells
which features

+ emulation of bash completion
+ dir-tracking (local and remote)
+ tracking of history files
+ displaying dir stack in header line

I took the opportunity to comment the code somewhat, you may give it
a try, if you dare:

http://www.fh-trier.de/~politza/emacs/bash-mode-1_0.tgz

Extract it somewhere in your load-path and read the commentary, or just
M-x bash RET

-ap

* reduce repeated backslashes

From: Teemu Likonen <tlikonen@iki.fi>
Date: Mon, 15 Feb 2010 10:51:28 +0200
To: help-gnu-emacs@gnu.org
Subject: Re: reduce repeated backslashes

  2010-02-15 09:40 (+0100), Andreas Roehler wrote:

> don't know how to replace/reduce repeated backslashes from inside a
> string.
>
> Let's assume "abcdef\\\\"

What is the end result you want? I guess:

    (replace-regexp-in-string "\\\\\\\\" "\\" "abcdef\\\\" nil t)
    => "abcdef\\"

There are 8 backslashes in the regexp string because backslash is a meta
character in Lisp strings and also in regexps. 8 backslashes in a regexp
Lisp string means 2 literal backslashes. In the resulting string there
is only one backslash but it is displayed as two "\\" because it's a
printed representation of Lisp string.

* Why can't I use xargs emacs?

From: pjb@informatimago.com (Pascal J. Bourguignon)
Date: Tue, 02 Feb 2010 23:40:30 +0100
To: help-gnu-emacs@gnu.org
Subject: Re: Why can't I use xargs emacs?

Adam Funk <a24061@ducksburg.com> writes:

> The emacs command can take a list of filename arguments, so why can't
> I get xargs to work with it?
>
> $ find -name '*.txt' |xargs emacs -nw
> emacs: standard input is not a tty
>
> $ grep -rl 'foo' some/path  |xargs emacs -nw
> emacs: standard input is not a tty

emacs is an interactive program.  It expects its stdin and stdout to
be hooked to the terminal, where it can display a character matrix,
and from which it can read user input.

When you use a pipe to send paths to xargs, you disconnect the
terminal from the stdin, and replace it with a pipe.  When xargs forks
and exec emacs, emacs inherit this pipe as stdin, and cannot get user
input, but will get instead further path from grep.

% echo hello > file ; ( echo -b ; echo file ) | xargs -L 1 cat 
hello

To open several files in emacs, you could either use emacsclient, or
an emacs lisp script.

Launch emacs in a separate terminal: xterm -e emacs -nw & 
In emacs, start the server:          M-x server-start RET
In a shell, you can then type:       find -name '*.txt' | xargs emacsclient -n

Simplier would be to just open the file in emacs:

Launch emacs:  emacs -nw 
Then type: C-x C-f *.txt RET

For the second case, you could type:
M-: (map nil 'find-file (split-string (shell-command-to-string "grep -rl 'foo' some/path") "\n")) RET

-- 
__Pascal Bourguignon__

From: Harald Hanche-Olsen <hanche@math.ntnu.no>
Date: Tue, 02 Feb 2010 18:51:39 -0500
To: help-gnu-emacs@gnu.org
Subject: Re: Why can't I use xargs emacs?

+ Adam Funk <a24061@ducksburg.com>:

> The emacs command can take a list of filename arguments, so why can't
> I get xargs to work with it?
>
> $ find -name '*.txt' |xargs emacs -nw
> emacs: standard input is not a tty

$ find -name '*.txt' |xargs sh -c 'emacs -nw "$@" </dev/tty' -

(untested)

-- 
  Harald Hanche-Olsen     <URL:http://www.math.ntnu.no/~hanche/>
- It is undesirable to believe a proposition
  when there is no ground whatsoever for supposing it is true.
  -- Bertrand Russell

To: help-gnu-emacs@gnu.org
From: Thierry Volpiatto <thierry.volpiatto@gmail.com>
Date: Wed, 03 Feb 2010 08:23:52 +0100
Subject: Re: Why can't I use xargs emacs?

Why not a simple:

emacs -nw -Q $(find . -name '*.txt')

Why do you want to use xargs?

Bill Marcum <marcumbill@bellsouth.net> writes:

> ["Followup-To:" header set to comp.unix.shell.]
> On 2010-02-02, Adam Funk <a24061@ducksburg.com> wrote:
>> The emacs command can take a list of filename arguments, so why can't
>> I get xargs to work with it?
>>
>> $ find -name '*.txt' |xargs emacs -nw
>> emacs: standard input is not a tty
>>
>> $ grep -rl 'foo' some/path  |xargs emacs -nw
>> emacs: standard input is not a tty
>>
> It says: standard input is not a tty. I don't normally use emacs, so there
> may be a better way to do this, but you could write a function:
> my_emacs () { emacs "$@" </dev/tty >&0 2>&0 ; }
>
>

-- 
Thierry Volpiatto

From: Adam Funk <a24061@ducksburg.com>
Date: Wed, 03 Feb 2010 14:18:58 +0000
To: help-gnu-emacs@gnu.org
Subject: Re: Why can't I use xargs emacs?

On 2010-02-02, Bit Twister wrote:

> On Tue, 02 Feb 2010 20:22:17 +0000, Adam Funk wrote:
>> The emacs command can take a list of filename arguments, so why can't
>> I get xargs to work with it?
>>
>> $ find -name '*.txt' |xargs emacs -nw
>> emacs: standard input is not a tty
>>
>> $ grep -rl 'foo' some/path  |xargs emacs -nw
>> emacs: standard input is not a tty
>
>
> Maybe it's the -nw switch. Try
>       find -name '*.txt' |xargs emacs

Yes, it works without -nw, but I'm often logged into an ssh server so
it's faster to open emacs in the xterm.

Anyway, the solution (posted by Thierry in gnu.emacs.help) turns out
to be this:

emacs -nw $(find . -name '*.txt')

Thanks.

-- 
..the reason why so many professional artists drink a lot is not
necessarily very much to do with the artistic temperament, etc.  It is
simply that they can afford to, because they can normally take a large
part of a day off to deal with the ravages.          [Amis _On Drink_]

* getting emacs from launchpad

From: Lennart Borgman <lennart.borgman@gmail.com>
Date: Tue, 26 Jan 2010 22:46:47 +0100
To: henry atting <nsmp_01@online.de>
Subject: Re: bazaar question

On Tue, Jan 26, 2010 at 10:31 PM, henry atting <nsmp_01@online.de> wrote:
> I find it annoying that I have to grapple with bazaar if I
> want to go on building emacs from source. Do I really have to pull
> the whole emacs tree starting from the first published sources in the
> Roman Empire?
>
> Tried it with `bazaar branch http://bzr.savannah.gnu.org/r/emacs/trunk/'
> but stopped, unpatiently, after 20 minutes.
> Is this the only way to get the latest source?

You can get them from Launchpad too. That is faster since they have
installed the bazaar fast server (or what it is called).

   bzr branch lp:emacs trunk

After that updates are quick (in the trunk subdir):

  bzr update

* debug modification of a variable

From: Tassilo Horn <tassilo@member.fsf.org>
To: emacs-devel@gnu.org
Date: Tue, 26 Jan 2010 21:26:49 +0100
Subject: Re: How to debug modification to a variable value?

"alin.s" <alinsoar@voila.fr> writes:

> I suggest you to use the WATCH in gdb for modifications of the
> variable, AWATCH for reading of the variable, etc.
>
> To detect the location of the variable is easy: install a breakpoint
> in make-variable-buffer-local that stops when exactly the variable you
> are interested about is set, then see there the location of
> tg-schema-alist.  Afterward you can use the x* functions from .gdbinit
> of emacs to debug your problem...

Thanks for that explanation.  I'll try that out as soon as I find some
time.  And also thanks for volunteering on implementing a debug facility
for cases like that.

Bye,
Tassilo

* strip mail head to fit for elbb

(defun mail2elbb (&optional beg end)
  " "
  (interactive "*")
  (let ((beg (cond (beg beg)
                   ((region-active-p)
                    (region-beginning))
                   (t (point-min))))
        (end (cond (end end)
                   ((region-active-p)
                    (copy-marker (region-end)))
                   (t (point-max)))))
    (save-restriction
      (narrow-to-region beg end)
      (goto-char beg)
      (mail2elbb-intern beg end)
      (widen))))

(defun mail2elbb-intern (beg end)
  (while (search-forward "=A0" nil t 1)
    (replace-match ""))
  (goto-char beg)
  (let ((end (progn (while
                 (re-search-forward "^[[:alpha:]-]+To:" nil t 1) 't) (copy-marker (line-end-position)))))
    (goto-char beg)
    (beginning-of-line)
    (while
        (< (point) end)
      (if (looking-at "Subject:\\|From:\\|Date:\\|To:")
          (forward-line 1)
        (delete-region (line-beginning-position) (1+ (line-end-position)))))))

* testing configuration

From: pjb@informatimago.com (Pascal J. Bourguignon)
Date: Sun, 27 Dec 2009 18:53:08 +0100
To: help-gnu-emacs@gnu.org
Subject: Re: testing configuration

andrea <andrea.crotti.0@gmail.com> writes:

> I was wondering if it would be possible to automatically check if my
> emacs configuration is correct.
> This can be then put in a post-commit hook to check that whenever I add
> some new features or change I don't mess up somethin else
>
> I would only need to:
> - load my whole configuration
> - exit and returns 0 if everything goes fine, returns another number
> otherwise.
>
> Any ideas?
>
> I can already launch a new emacs with certain conf, but how can I get a
> return value?

What about:

emacs -q --eval '(condition-case err (progn (load "~/.emacs") (kill-emacs 0)) (error (kill-emacs 1)))'

?

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

* self-typing

From: pjb@informatimago.com (Pascal J. Bourguignon)
Date: Sat, 26 Dec 2009 14:32:16 +0100
To: help-gnu-emacs@gnu.org
Subject: Re: what is `self-typing' ?

waterloo <waterloo2005@gmail.com> writes:

> I can not understand a para in Elisp manual :
>
>     Lisp is unlike many other languages in that its objects are
>     "self-typing": the primitive type of each object is implicit in the
>     object itself.  For example, if an object is a vector, nothing can
>     treat it as a number; Lisp knows it is a vector, not a number.
>
> What is `self-typing' ? thanks

As mentionned by Eli.  But this require some more explaination.

Some languages are defined so that variables can hold only objects of
a given type (you declare the type of the variable, or it is infered
automatically at compilation time).  For example, C or Haskell.  

Since all the types of the objects are known at compilation time from
the variables they're stored in, the compiler doesn't need to generate
code to store the type along with the object, or along with the
variable: the type is implicity.  In C, typeof(42) or int a=42; typeof(a)
is computed at compilation time.  

Some languages are defined so that variables can hold objects of
different types, at different times.  In that case, the type is not
attached to the variable, but must be attached to the objects
themselves.  For example, Lisp or Smalltalk.

Since it is rarely possible to know what type of object a variable
will hold (some type inference can still be applied to optimize out
some function, but there remains a lot of functions where type
inference doesn't restrict much the possible types, the more so when
global analysis is not practical or possible), then the type of each
object has to be kept with the object.  In Lisp, (type-of 42) or (let
((a 42)) (type-of 42)) is computed at run-time.  Notably, you can
write: (type-of (read)) and depending on what you enter at run-time,
will get back one type or another:

M-x ielm RET
*** Welcome to IELM ***  Type (describe-mode) for help.
ELISP> (type-of (read))
Lisp expression: 42
integer
ELISP> (type-of (read))
Lisp expression: "fourty-two"
string
ELISP> (type-of (read))
Lisp expression: fourty-two
symbol
ELISP> (type-of (read))
Lisp expression: (fourty two)
cons
ELISP> 

There are also languages where both things are more or less possible,
you can have variables with pre-defined types holding only one type of
object, and variables which can hold objects of various types, but of
a same root class.  For example, C++ or Java.

These languages usually provide so called "Plain Old Data" types which
correspond to the type of objects that can only be stored in variables
with predefined types.   These objects of these POD types usually
don't have the type attached to them, these objects can only be stored
in variables with pre-defined type.   When you want to store such an
object in a variable-type variable, you have to wrap it in another
object, a typed object, instance of a class.  In Java, you have a POD
type int and an object class Integer.  

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

* Emacs uptime

From: pjb@informatimago.com (Pascal J. Bourguignon)
Date: Wed, 23 Dec 2009 20:16:03 +0100
To: help-gnu-emacs@gnu.org
Subject: Re: Some functions I hope are useful for others to

[ ... ]

For example, here is my emacs-uptime:

(defvar com.informatimago.time/*emacs-start-time*   (current-time)
   "For (emacs-uptime)")

(defun com.informatimago.time/emacs-uptime ()
  "Gives Emacs' uptime, based on global var `com.informatimago.time/*emacs-start-time*'."
  (interactive)
  (let* ((st com.informatimago.time/*emacs-start-time*)
         (cur (current-time))
         (hi-diff (- (car cur) (car st)))
         (tot-sec (+ (ash hi-diff 16) (- (cadr cur) (cadr st))))
         (days (/ tot-sec (* 60 60 24)))
         (hrs  (/ (- tot-sec (* days 60 60 24)) (* 60 60)))
         (mins (/ (- tot-sec (* days 60 60 24) (* hrs 60 60)) 60))
         (secs (/ (- tot-sec (* days 60 60 24) (* hrs 60 60) (* mins 60)) 1)))
    (message "Up %dd %dh %dm %ds (%s), %d buffers, %d files"
             days hrs mins secs
             (format-time-string "%a %Y-%m-%d %T" st)
             (length (buffer-list))
             (count t (buffer-list)
                    :test-not
                    (lambda (ignore buf)
                      (null (cdr (assoc 'buffer-file-truename
                                        (buffer-local-variables buf)))))))))

(defalias 'emacs-uptime 'com.informatimago.time/emacs-uptime)

[ .... ]

* Using Emacs Lisp for script writing

To: help-gnu-emacs@gnu.org
From: David Engster <deng@randomsample.de>
Date: Sat, 19 Dec 2009 11:02:22 +0100
Subject: Re: Using Emacs Lisp for script writing

Andreas Politz <politza@fh-trier.de> writes:
> Cecil Westerhof <Cecil@decebal.nl> writes:
>
>> I already use 'emacs -batch' for scripting where no user input is used,
>> but I would like to use it also for interactive scripting. Until now I
>> did not find any usable information about this. Anybody using Emacs for
>> interactive scripts?
>
> No, but it should be noted, that this is not very difficult :
>
> $ emacs -Q -batch -eval '(yes-or-no-p "Want some cookies ?")'

You can also use the '--script' option in a shebang line:

----------------- test.sh -----------------
#!/usr/bin/emacs --script

(if (yes-or-no-p "Choose ")
    (message "You said yes")
  (message "You said no"))
-------------------------------------------

I use emacs regularly for writing scripts, since with its thousands of
packages you have a huge library readily available.

-David

* until found

From:   Helmut Eller
Subject:        Re: until-found
Date:   Fri, 11 Dec 2009 17:10:38 +0100
User-agent:     Gnus/5.13 (Gnus v5.13) Emacs/23.1.50 (gnu/linux)

* Andreas Roehler [2009-12-10 13:50+0100] writes:

> And here my implementation so far:
>
> (defun until-found (search-string liste)
>   (let ((liste liste) element)
>     (while liste
>       (if (member search-string (car liste))
>           (setq element (car liste) liste nil))
>       (setq liste (cdr liste)))
>     element))

This seems to be the same as:

(car (member (lambda (element) (member search-string element)) liste))

or

(find-if (lambda (element) (member search-string element)) liste)

or

(find search-string liste :test #'member)

or

(loop for e in liste if (member search-string e) return e)

Helmut

* favourite directories implementation

Author: Florent Georges, source:
http://fgeorges.blogspot.com/2008/01/emacs-favourite-directories.html

Today, I have finally taken a look at one of the
simple features I always missed in Emacs: the
ability to define a set of "favourite directories."
That is, a set of named directories that one can use
in the minibuffer when prompted for instance to open
a file. Given a set of such dirs:

emacs-src -> /enter/your/path/to/emacs/sources
projects  -> /path/to/some/company/projects
now       -> @projects/the/project/I/am/working/on

one can use the following path in the minibuffer to open a file,
for instance using C-x C-f:

@emacs-src/lisp/files.el
@emacs-src/src/alloc.c
@projects/great/README
@now/src/some/stuff.txt

Doing so, completion is available for both directory names and
files under their target directories. For instance, to open the
third file above, you only have to type:

C-x C-f @ p <tab> g <tab> R <tab> <enter>

The implementation I have just written is really simple, but
useful yet. It implements all described above (including
                                               recursive defined directories, as the '@now' above.) Thanks to
Emacs, I am still suprised by the facility to implement such a
feature!

The code was written on GNU Emacs 22.1 on Windows, but should
work on any platform, and I think on Emacs 21 as well.

TODO: Make a custom variable.
(defvar drkm-fav:favourite-directories-alist
  '(("saxon-src"  . "y:/Saxon/saxon-resources9-0-0-1/source/net/sf/saxon")
    ("kernow-src" . "~/xslt/kernow/svn-2007-09-29/kernow/trunk/src/net/sf/kernow"))
  "See `drkm-fav:handler'.")

(defvar drkm-fav::fav-dirs-re
  ;; TODO: Is tehre really no other way (than mapcar) to get the list
  ;; of the keys of an alist?!?
  (concat
   "^@"
   (regexp-opt
    (mapcar 'car drkm-fav:favourite-directories-alist)
    t))
  "Internal variable that stores a regex computed from
`drkm-fav:favourite-directories-alist'.  WARNING: This is not
updated automatically if the later variable is changed.")

(defun drkm-fav:handler (primitive &rest args)
  "Magic handler for favourite directories.

With this handler installed into `file-name-handler-alist', it is
possible to use shortcuts for often used directories.  It uses
the mapping in the alist `drkm-fav:favourite-directories-alist'.

Once installed, say you have the following alist in the mapping
variable:

    ((\"dir-1\" . \"~/some/real/dir\")
     (\"dir-2\" . \"c:/other/dir/for/windows/users\"))

You can now use \"@dir-1\" while opening a file with C-x C-f for
instance, with completion for the abbreviation names themselves
as well as for files under the target directory."
  (cond
   ;; expand-file-name
   ((and (eq primitive 'expand-file-name)
         (string-match drkm-fav::fav-dirs-re (car args)))
    (replace-match
     (cdr (assoc (match-string 1 (car args))
                 drkm-fav:favourite-directories-alist))
     t t (car args)))
   ;; file-name-completion
   ((and (eq primitive 'file-name-completion)
         (string-match "^@\\([^/]*\\)$" (car args)))
    (let ((compl (try-completion
                  (match-string 1 (car args))
                  drkm-fav:favourite-directories-alist)))
      (cond ((eq t compl)
             (concat "@" (match-string 1 (car args)) "/"))
            ((not compl)
             nil)
            (t
             (concat "@" compl)))))
   ;; file-name-all-completions
   ((and (eq primitive 'file-name-all-completions)
         (string-match "^@\\([^/]*\\)$" (car args)))
    (all-completions
     (match-string 1 (car args))
     drkm-fav:favourite-directories-alist))
   ;; Handle any primitive we don't know about (from the info node
   ;; (info "(elisp)Magic File Names")).
   (t (let ((inhibit-file-name-handlers
             (cons 'drkm-fav:handler
                   (and (eq inhibit-file-name-operation primitive)
                        inhibit-file-name-handlers)))
            (inhibit-file-name-operation primitive))
        (apply primitive args)))))

;; Actually plug the feature into Emacs.
(push '("\\`@" . drkm-fav:handler) file-name-handler-alist)

* lisp interface to ispell

From: Teemu Likonen <tlikonen@iki.fi>
Date: Fri, 06 Nov 2009 22:05:53 +0200
To: help-gnu-emacs@gnu.org
Subject: Re: lisp interface to ispell ?

On 2009-11-06 20:39 (+0100), Andreas Politz wrote:

> Does someone have a hack, or know a different package, in order to allow
> elisp access to spelling functions ? E.g. like
>
> (spell word language)
>
> which at least returns t or nil.

Something like this?

(defun my-ispell-string (word lang)
  (with-temp-buffer
    (insert word)
    (call-process-region (point-min) (point-max)
                         "ispell" t t nil "-l" "-d" lang)
    (if (= (point-min) (point-max))
        t)))

* Python workflow

From: Simon <bbbscarter@gmail.com>
Date: Fri, 6 Nov 2009 03:42:44 -0800 (PST)
To: help-gnu-emacs@gnu.org
Subject: Python workflow

Hi, apologies in advance for a potentially numpty post.

I've been using Emacs for a little while now, but I've yet to settle
on a satisfactory python edit-run-debug cycle, and I was wondering
what wiser minds than mine have settled upon. So far I've tried:

- Edit code and run with emacs PDB. After fiddling the lisp code to
automatically pick up the current buffer as the default run candidate,
this is nearly okay. The main issue is that, after editing code,
there's no easy way to rerun the code, so I end up killing the gud
buffer every time. As such, entering and leaving the debugger is quite
a few key presses and accidentally leaving it running is also easy.

- Tried Pydb to similar effect.

- Run everything in a seperate shell. And debug by hand. This is a
little too low-fi, even for me.

- Use the 'import/reload file' and 'eval def/class' functions, and run
everything from the emacs python shell, using pdbtrack to help with
debugging. Problems so far:
- It's very easy to forget which modules you've modified and fail to
reload them; because the state is carried over I continually find
myself running the old versions of code I've just edited, especially
if it's across several files.
- More than that, sometimes the stuff I expect to reload simply
doesn't, and I have no indication as to why. For example, if pdb has
module open and you stick a deliberate error in the code and reload
it, the minibuffer tells you the module has been loaded, even though
it clearly can't have been.
- I have to run pdb.pm() to debug the exception. If I run *anything*
else by accident, I lose the exception context. This can be annoying
if you're incompetent enough to keep making typos (I am).

Does anyone have any tips on their workflow?

Many thanks!

Simon

* strip out UTF-8 BOMs
From: "Edward O'Connor" <hober0@gmail.com>
Date: Thu, 5 Nov 2009 16:13:27 -0800
To: emacs-devel@gnu.org
Subject: find-file-literally-at-point

Hi,

I recently found myself in need of such a function (I was going through
                                                      a bunch of files to strip out their UTF-8 BOMs, if you're curious), and
it was quick enough to put together:

(autoload 'ffap-guesser "ffap")
(defun find-file-literally-at-point ()
  "Open the file at point (like `ffap') with `find-file-literally'."
  (interactive)
  (find-file-literally (ffap-guesser)))

* xml and n3

From: "Eric Schulte" <schulte.eric@gmail.com>
Subject: Re: [Orgmode] org-babel-tangle xml text
Date: Tue, 03 Nov 2009 09:18:34 -0700

"Martin G. Skjæveland" <martige@ifi.uio.no> writes:

> Is there a way I can add xml and n3 to the list of supported
> languages? These languages does not need interpretation, so I'm
> thinking it should be quite easy to add. I have fumblingly tried
>
>   (add-to-list 'org-babel-tangle-langs '("xml"))
>
> and
>
>   (add-to-list 'org-babel-tangle-langs '("css" "xml"))
>
> but it as no effect.
>

Hi Martin,

The attached org-mode file contains instructions for adding xml and n3
to org-babel and org-babel-tangle.  Note that there may be another step
if the major mode for n3 is not n3-mode.  Best -- Eric

introduce org-babel to =xml= and =n3=

#+begin_src emacs-lisp :results silent
  (org-babel-add-interpreter "xml")
  (org-babel-add-interpreter "n3")
#+end_src

if say =n3= should be edited using =xml-mode=, then evaluate the
following adding this pair to =org-src-lang-modes=

#+begin_src emacs-lisp :results silent
  (add-to-list 'org-src-lang-modes '("n3" . xml))
#+end_src

;; inform org-babel-tangle of their existence and file extensions
#+begin_src emacs-lisp :results silent
  (add-to-list 'org-babel-tangle-langs '("xml" "xml" nil t))
  (add-to-list 'org-babel-tangle-langs '("n3" "n3" nil t))
#+end_src

#+begin_src xml :tangle example
  <first>
  </first>
#+end_src

#+begin_src n3 :tangle example
  n3 stuff
#+end_src

* How to check regexp for syntax-errors?

From: Kevin Rodgers <kevin.d.rodgers@gmail.com>
Date: Tue, 20 Oct 2009 01:54:56 -0600
Subject: Re: How to check regexp for syntax-errors?  
David Combs wrote:
> Isn't there some .el that that will try to parse a regexp, and tell
> me where it got confused, and what to look for for errors?
                                                            
(defun valid-regexp-p (regexp)
   (interactive "sRegexp: ")
   (with-temp-buffer
     (condition-case error-data
        (progn
          (re-search-forward regexp nil t)
          t)
       (invalid-regexp
        (when (interactive-p) (message "Invalid regexp: %s" (cdr error-data)))
        nil))))

-- 
Kevin Rodgers
Denver, Colorado, USA

* prefer cond over case?

From: David Kastrup <dak@gnu.org>
Date: Mon, 12 Oct 2009 10:03:39 +0200
To: help-gnu-emacs@gnu.org
Subject: Re: Perferr cond over case?

pjb@informatimago.com (Pascal J. Bourguignon) writes:

> Nordlöw <per.nordlow@gmail.com> writes:
>
>> Does the use of the cl macro case() incurr some loss of performance
>> compare to using cond() instead?
>
> (macroexpand '(case (* 2 2 2 2 3)
                  >                 (10      'one)
                  >                 ((24 42) 'two)
                  >                 ((3 33)  'three)
                  >                 (otherwise 'unknown)))
> -->
> (let ((--cl-var-- (* 2 2 2 2 3)))
    >     (cond ((eql --cl-var-- (quote 10)) (quote one))
                >           ((member* --cl-var-- (quote (24 42))) (quote two))
                >           ((member* --cl-var-- (quote (3 33))) (quote three))
                >           (t (quote unknown))))
>
> What do you think?

Before or after byte compilation?

-- 
David Kastrup

* batch-mode

From: Decebal <cldwesterhof@gmail.com>
Newsgroups: gnu.emacs.help
Date: Sat, 10 Oct 2009 11:33:17 -0700 (PDT)
To: help-gnu-emacs@gnu.org
Envelope-To: andreas.roehler@easy-emacs.de

In a Bash script I changed:

local i
local length=${#1}

       for i in $(seq ${1}) ; do
         printf "       Regel %${length}d voor de test\n" ${i}
       done  >${2}
to:

emacs -batch -nw --eval='
        (let (
              (i)
              (nr-of-lines '${1}')
              (nr-of-lines-length)
              (output-file "'"${2}"'"))
          (setq nr-of-lines-length (length (number-to-string nr-of-lines)))
          (dotimes (i nr-of-lines t)
           (insert (format (format "       Regel %%%dd voor de test\n" nr-of-lines-length) (1+ i))))
          (write-file output-file))
       ' 2>/dev/null

The Bash version took 293 seconds and the Emacs Lisp version 59
seconds. So it is about 5 times as fast.
The Emacs batch gives output like:
Saving file /home/cecil/temp/inputEmacs...
Wrote /home/cecil/temp/inputEmacs
That is why I use the 2>/dev/null.
Is there a way to circumvent the generation of the above output?
Because when there is an error it is also thrown away and that is not
nice.

From: Vassil Nikolov <vnikolov@pobox.com>
Newsgroups: gnu.emacs.help
Date: Sat, 10 Oct 2009 16:55:31 -0400
To: help-gnu-emacs@gnu.org
Envelope-To: andreas.roehler@easy-emacs.de

On Sat, 10 Oct 2009 11:33:17 -0700 (PDT), Decebal <cldwesterhof@gmail.com> said:
> ...
>       local i
>       local length=${#1}
>       for i in $(seq ${1}) ; do
>         printf "       Regel %${length}d voor de test\n" ${i}
>       done  >${2}

translates to

emacs -Q -batch -eval '
(dotimes (i '"${1}"')
        (princ (format "       Regel %'"${#1}"'d voor de test\n" (1+ i))))
' > "${2}"

---Vassil.

From: Decebal <cldwesterhof@gmail.com>
Newsgroups: gnu.emacs.help
Date: Sat, 10 Oct 2009 13:57:07 -0700 (PDT)
To: help-gnu-emacs@gnu.org
Envelope-To: andreas.roehler@easy-emacs.de

On Oct 10, 10:06pm, Andreas R=F6hler <andreas.roeh...@easy-emacs.de>
wrote:
> > The Emacs batch gives output like:
> >   Saving file /home/cecil/temp/inputEmacs...
>
> it's in files.el, save-buffer, AFAIS
>
>   (if (and modp (buffer-file-name))
        >     (message "Saving file %s..." (buffer-file-name)))
>
> commenting out these lines should cancel the message

The problem with that is that it only works for me. But I found a way.
I replaced:

(write-file output-file))

with:

(set-visited-file-name output-file)
    (basic-save-buffer))

But maybe there should be more consideration for the possibility that
Emacs is used as a batch program.

> >   Wrote /home/cecil/temp/inputEmacs

I still have to find something for this.

That is not possible I am afraid. In the C-source there is a call to
message_with_string.

* vectors and lists

From: pjb@informatimago.com (Pascal J. Bourguignon)
Newsgroups: gnu.emacs.help
Date: Fri, 09 Oct 2009 19:19:49 +0200
To: help-gnu-emacs@gnu.org
Envelope-To: andreas.roehler@easy-emacs.de

Nordlöw <per.nordlow@gmail.com> writes:

> If I have an association list say,
>
> '(
>   ("key" sym1 val1 num1)
>   ("key2" sym2 val2 num2)
> )
>
> , where each entry is a fixed sequence of various objects. 

If this is an a-list, then you could write it as:

   (("key1" . (sym1 val1 num1))
    ("key2" . (sym2 val2 numb2)))

to show that it is a list of cons cells.  

(a . (b c d)) <=> (a b c d), but the first notation shows that you
consider it as a list of cons, and notably that you don't expect nil
ie. () to be in the toplevel of the a-list.

Also, if we write the a-list properly like this, we can better answer
the following question:

> I might
> aswell use a vector to represent an entry in this alist, right?

You cannot use a vector instead of the cons cells of the a-list, but
you can use a vector as a value of an a-list entry.  Values can be of
any type.  In the case of emacs lisp, you could also easily use
vectors (or any other type) as keys in an a-list, since it uses equal
to compare keys.  

   (("key1" . [sym1 val1 num1])
    ("key2" . [sym2 val2 num2])
    ([?k ?e ?y ?3] . [sym3 val3 num3]))

> In this case, what do I gain by using a vector instead of list?

In general, vectors take half the space of lists, and access to the
nth element is done in O(1) instead of O(n) with lists.  However,
adding or removing an element in a vector is O(n) while in the case of
lists, it may be O(1) (prepending an element or removing the first
                                  element or one of the few firsts elements) or O(n) (inserting,
                                                                                      appending an element or removing the nth element).

> What about performance?: aref() faster than nth() only for large
> vectors?

aref has to compute a multiplication and a sum, before doing one
memory load to get the element.  In the case of emacs lisp, the
multiplication is always by the same fixed factor AFAIK.

nth has to do n memory loads to get the element.

So indeed, aref will probably be faster than nth, even for indices as
small as 1 or 0.

> Is there vector-variant of assoc()? 

No.  Unless you count hash-tables as a vector variant.

> If not, why? 

Because there's no point. The advantage of using a list for a-list,
apart from the historical simplicity, is that you can easily prepend
the a-list with new associations, and therefore use the a-list in a
purely functional way.

   (defun f (bindings)
      (let ((val (cdr (assoc 'x bindings))))
         (if (zerop val)
             (list val)
             (cons val (f (cons (cons 'x (1- val)) bindings))))))

   (let ((bindings '((y . 0) (x . 1))))
      (list (f (cons (cons 'x 2) bindings))
            (cdr (assoc 'x bindings))))
   ;; --> ((2 1 0) 1)

Note: you could use (require 'cl)  (acons key value a-list) 
instead of (cons (cons key value) a-list).

> Has any one already written such a function?

Not AFAIK, but you can write it.  However, the semantics of assoc
require a sequential search of the keys in the list, so there would be
no gain.  On the contrary, we would now have O(n) complexity to
prepend a new entry to the a-vector.

-- 
__Pascal Bourguignon__