Can someone help me in that question:

I need a funcion that recive two  symbols and return one, that are the
resultt of concatenate the arguments. For example:

(concatenate-symb 'pedro '-pina) -> pedro-pina

I lost 2 days traing to do that can someone help me?

  (concatenate-symb 'p1::a 'p2::b) -->  ?

Beyond that: use symbol-name, (concatenate 'string ...), symbol-package,
and intern.  And remember to specify a package argument to intern.  Although
that argument is optional, leaving it off is usually wrong.

"Pedro M. C. Pina" <pp...@netcabo.pt> writes:

(defun concatenate-symb (&rest args)
    (make-symbol (apply 'concatenate
                     (cons 'string  (mapcar 'symbol-name args)))))

"Pedro M. C. Pina" <pp...@netcabo.pt> wrote in message
news:1029374394.970955@spynews3...

(defun concatenate-symbols (&rest symbols)
    (intern (apply #'concatenate
                   'string  (mapcar #'symbol-name symbols))))

This is the kind of question that makes experienced Lispers
want to ask you, "Why would you want to do that?"

It's a reasonable thing to want to do for a variety of reasons,
but if you are new enough to Lisp to not already know how to
accomplish it, it is likely that you are going down the wrong
path in wanting to do it.

However, why do you want to avoid them (i.e. cut all further
values off) in the first place? If there's really a good reason,
you could use prog1, though.

Kind regards,

   (VALUES form_1 form1_2 ...)

returns exactly one value from each of the form_i.

Thanks,

   (VALUES mvf)

or (possibly, but I don't like it)

   (NTH-VALUE 0 mvf)

Something like

   (PROG1 mvf)

I'd regard as horrible.  However this is all a taste issue, they will
all work.

* Tim Bradshaw
| No, this is wrong.

  Not to mention that it is wrong to discard these values in the first place.

--
Erik Naggum, Oslo, Norway

(defun make-atom (&rest args)
  (values ;to return only the first value returned by INTERN
   (intern (format nil "~{~A~}" args))))

A Lisp symbol is a data structure, not a string.  It carries a multitude of
properties.

One of those properties is a symbol's *name*, which is a string.

You can catenate two strings, but what does it mean to catenate two symbols?
Their names can be catenated, but what about the rest of the properties?

If you think that your Lisp program needs to pull out the names of two symbols,
catenate them, and then manufacture a new symbol whose name is the resulting
string, you are probably thinking wrongly. Symbols are not the best data
structure for your problem; it is more likely that strings are, since you are
really doing text processing, rather than symbol manipulation.

Interning lots of symbols at run time can perform poorly and waste lots of
space. Once a symbol is interned, it will stay interned until it is explicitly
uninterned, because its home package acts as a reference to it.

Unless you really know what you are doing, the only kinds of symbols you should
ever need to manufacture at run time in your Lisp program are
uninterned-symbols, which are not entered into any package and consequently
subject to storage reclamation when they become unreachable, like other
ordinary objects. You can make one of these using make-symbol:

  (make-symbol "PEDRO")
  ==> #:PEDRO

The gensym function makes uninterned symbols, whose names are derived
by converting an incrementing counter to a string, and prepending a prefix.

  (gensym)  => #:G246
  (gensym)  => #:G247
  (gensym "FOO-") => #:FOO-248

    > (defun make-atom (&rest syms)
        (intern (format nil "~{~A~}" syms)))
    make-atom

    (make-atom 'foo '- 'bar)
    |foo-bar|
    nil

Oops.  I have *PRINT-CASE* set to :DOWNCASE in my environment.

The way to fix this is to never rely on printing symbols.  This is a
better version of the same function.

    (defun make-atom (&rest syms/strings)
      (intern (format nil "~{~A~}"
                      (mapcar #'(lambda (s)
                                  (etypecase s
                                    (symbol (symbol-name s))
                                    (string s)))
                               syms/strings))))

"Tim Bradshaw" <t...@cley.com> ha scritto nel messaggio news:ey3it2bdu8d.fsf@cley.com...

(mapcar #'string syms/strings)

Instead of

It is easier and better to just ignore any additional return values.

  Because you write your function also for others who might value these
  additional values from `intern´.

| I don't program on that scale.  I've just started off.

  Additional values will never get in your way unless you look for them.  What
  you do amounts to looking for them only to discard them.  This is stupid.

--
Erik Naggum, Oslo, Norway

  (defun make-atom (&rest syms/strings)
     (intern (format nil "~{~A~}" (mapcar #'string syms/strings))))

  That it was a clueless question?

--
Erik Naggum, Oslo, Norway

As I stated I threw them out because they were irritating when the
function was newly written. After finishing it I should have done so.
I now stand corrected.

Thanks everyone for you help again,