RE: [External] : Any packages using ThingAtPointPlus for activation?

[Drew Adams <drew.adams@oracle.com>]

> > > (defun hyperscope-action-button (&optional prefix)
> > >   (interactive "p")
> > >   (cond ((thing-at-point 'uuid) (rcd-db-uuid-action (thing-at-point
> > > 'uuid)))
> >
> > I suggest you don't invoke `thing-at-point' multiple
> > times needlessly.  Use `let', to do the work only once.
> 
> I would rather like to have universal thing at point that would
> identify all possible elements at once and give me list of it.

(That seems unrelated to the text you quoted.)

Feel free to code what you (think you) want. ;-)

I don't see the point of that, but that doesn't
mean it has no point.  Why would you want to
spend time gathering all (of some set, presumably)
the possible things at point?

I suppose I can imagine your wanting to try to get
THING1 first, and if there is none, then try to
get THING2, etc. That's something else again.  You
could easily write code that does that, given a
list of THINGS.  Cf. `run-hook-with-args-until-success'.

> I understand repetitions, I may consider let later, maybe not. It is
> not matter of speed now, neither style. It is thinkering stage.

Using `let', so you eval some sexp only once,
isn't only (or necessarily at all) a matter
of speed.  Among other things, it can also
make your code more readable: it becomes
clear what's already been done, and you can
give variables names that are relevant to the
current context.  E.g., you might use some
function that returns a list only for its
Boolean value (nil or not), and in the current
context that value might have a particular use
or meaning - so naming it can make your code
(especially if the defun is large) more
readable.

(Of course, this kind of thing is personal style.)

> > Don't use (`thing-at-point 'symbol) for this.
> > Perhaps unfortunately, Emacs has that return text at
> > point that has symbol syntax - in the current mode.
> > It doesn't return a Lisp symbol name at point
> > (unless you're in `emacs-lisp-mode').
> 
> > Use `symbol-at-point' (or, if you want only currently
> > defined Elisp symbols, `tap-symbol-at-point').  They
> > return a Lisp symbol - no need to intern.
> 
> Alright, but I would like to recognize only symbols which are defined,
> like functions and variables and not symbols which are not defined.
> 
> How do I recognize if function is defined?

As I said: `fboundp'.  Or if you want to include only
real functions (not macros etc.), then `functionp'.

> I use (fboundp 'system-move-file-to-trash) ➜ t

Yep.  I showed the use of `fboundp' in the example
code I sent.

> How I recognize if variable is one variable defined anywhere globally?

I don't understand the question.  Can you rephrase it?

> Judging by the inspection of command {C-h v} it is following:
> - I should use (boundp SYMBOL) to recognize if it is variable

Yes, if you want a bound variable, and not just a
var that's only declared with a vacuous defvar:
(defvar foo).

> > Bookmarks do that - you can define a bookmark type
> > for "jumping" to anything.  That's the original
> > purpose of Emacs bookmarks.  And "jump" can mean
> > whatever you like.  You can use thing-at-point
> > to get the name of a thing of a particular kind at
> > point, and then jump to it using a bookmark.
> 
> Does it mean I would need to bookmark it first before using a bookmark?

Of course.  If you don't bookmark it there's no
bookmark for it.