Try using [`symbol-name`](https://www.gnu.org/software/emacs/manual/html_node/elisp/Creating-Symbols.html#index-symbol_002dname-487):

    (symbol-name &#39;some-symbol)


Given a symbol name (a string), you can get the symbol&#39;s value.  Using Trey Jackson&#39;s solution:

    (setq ASymbol 10)  =&gt; 10
    (intern &quot;ASymbol&quot;)  =&gt; &#39;ASymbol (e.g. the unevaluated symbol with name &quot;ASymbol&quot;)
    (symbol-value (intern &quot;ASymbol&quot;)) =&gt; 10

This is useful if you want to get the values of symbols for which you only have names.  For instance, you read them from a string.

A few notes: `intern` returns the value of the symbol with the given name. If no symbol with such a name exists, it creates a symbol with that name. You can use `intern-soft` to avoid introducing a new symbol if one with the given name does not exists.

Multiple parameters lists, e.g. `def foo(a:Int)(b:Int) = {}` and multiple parameters per list, e.g. `def foo(a:Int, b:Int) = {}` are semantically equivalent so far as I can tell, and most functional languages have only one way of declaring multiple parameters, e.g. F#.

The only reason I can figure out for supporting both these styles of function definitions is to allow syntax-like language extensions using a parameter list that has only one parameter in it.

    def withBufferedWriter(file: File)(block: BufferedWriter =&gt; Unit)

can now be called with the syntax-looking

    withBufferedWriter(new File(&quot;myfile.txt&quot;)) { out =&gt;
      out write &quot;whatever&quot;
      ...
    }

However, there could be other ways of supporting the use of curly braces without having multiple parameter lists.

A related question: why is the use of multiple parameter lists in Scala called &quot;currying&quot;? Currying is usually defined as a technique for making an n-ary function unary for the sake of supporting partial application. However, in Scala one can partially apply a function without making a &quot;curried&quot; (multiple parameter lists with one param each) version of the function.

Why does Scala provide both multiple parameters lists and multiple parameters per list?

Can anyone explain the difference between accessing an instance attribute via `self.attribute` and by `@attribute`?


Directly accessing an instance variable vs. Using an accessor method

How can I convert a symbol type into a string in Emacs lisp? 

I wasn&#39;t able to find a `symbol-to-string` function or anything similar.

Convert Symbol to a String in Elisp

<p>How can I convert a symbol type into a string in Emacs lisp?</p>
<p>I wasn't able to find a <code>symbol-to-string</code> function or anything similar.</p>


I have a string that has two single quotes in it, the `&#39;` character. In between the single quotes is the data I want.

How can I write a regex to extract &quot;the data i want&quot; from the following text?

    mydata = &quot;some string with &#39;the data i want&#39; inside&quot;;
   


How to extract a substring using regex

Python has `string.find()` and `string.rfind()` to get the index of a substring in a string.

I&#39;m wondering whether there is something like `string.find_all()` which can return all found indexes (not only the first from the beginning or the first from the end).

For example:

    string = &quot;test test test test&quot;
    
    print string.find(&#39;test&#39;) # 0
    print string.rfind(&#39;test&#39;) # 15
    
    #this is the goal
    print string.find_all(&#39;test&#39;) # [0,5,10,15]

How to find all occurrences of a substring?

Let&#39;s say I have a string `&#39;gfgfdAAA1234ZZZuijjk&#39;` and I want to extract just the `&#39;1234&#39;` part.

I only know what will be the few characters directly before `AAA`, and after `ZZZ` the part I am interested in `1234`.

With `sed` it is possible to do something like this with a string:

    echo &quot;$STRING&quot; | sed -e &quot;s|.*AAA$.*$ZZZ.*|\1|&quot;

And this will give me `1234` as a result.

How to do the same thing in Python?


How to extract the substring between two markers?

What is the shortest way, preferably inline-able, to convert an int to a string? Answers using stl and boost will be welcomed.

Converting an int to std::string

Why would anyone use `String.Format` in C# and VB .NET as opposed to the concatenation operators (`&amp;` in VB, and `+` in C#)?

What is the main difference? Why are everyone so interested in using `String.Format`? I am very curious.

Why use String.Format?

I often want to unsplit window as follows:

    +--------------+-------------+			   +--------------+-------------+
    |              |             |			   |              |   	       	|
    |              |             |			   |              |   	       	|
    |              |             |			   |              |   	       	|
    +--------------+             |     --&gt;	   |              |   	       	|
    |              |             |			   |              |   	       	|
    |              |             |			   |              |            	|
    |              |             |			   |              |             |
    +--------------+-------------+			   +--------------+-------------+



    +--------------+--------------+			   +-----------------------------+
    |              |              |			   |                             |
    |              |              |			   |                             |
    |              |              |			   |                             |
    +--------------+--------------+    --&gt; 	   +-----------------------------+
    |                             |			   |                             |
    |                             |			   |                             |
    |                             |			   |                             |
    +-----------------------------+			   +-----------------------------+

Currently, I start with &lt;kbd&gt;ctrl&lt;/kbd&gt;-&lt;kbd&gt;x&lt;/kbd&gt; &lt;kbd&gt;1&lt;/kbd&gt; and then split vertically/horizontally. but my real qustion is how can one remove a particular window split with out disturbing the other window structure? Is there any elisp function in built?

emacs, unsplit a particular window split

What are some REPLs for Emacs Lisp?

Is there only one that is within Emacs?

Are there some that run inside terminal outside Emacs?


REPL for Emacs Lisp

Is there a builtin command to clear shell while using shell in emacs?

If not, is there an elisp function to achieve the same?

Command to clear shell while using emacs shell

I&#39;ve been updating my emacs config with the use of Rsense to allow for an autocomplete drop down box to appear whilst typing code.  This works well in most files except I&#39;ve found it doesn&#39;t allow me to select an answer from the table when I&#39;m editing some code in my ruby on rails project.

Here is my setup:
https://github.com/map7/simple_emacs

I&#39;m using this under Ubuntu 10.04.

For simple ruby script files it works great. I can open up a new file and type.

&lt;!-- language: lang-rb --&gt;

    &quot;test&quot;.up...

Just as I type the &#39;p&#39; character in up a list of options appear and I can go up and down the list with arrow keys and select one (eg: upcase) with the enter key.

What doesn&#39;t work is when I do the exact same test but within a rails project&#39;s base directory.

**Update:**

Found that the problem is with (require &#39;rails), so it&#39;s something in the emacs-rails plugin that the autocomplete doesn&#39;t like.

**Update:** 

It&#39;s within emacs-rails -&gt; rails-project.el. If I comment this macro out then autocomplete works, otherwise it doesn&#39;t:

&lt;!-- language: lang-rb --&gt;

    (defmacro* rails-project:with-root ((root) &amp;body body)
      &quot;If you use `rails-project:root&#39; or functions related on it
    several times in a block of code, you can optimize your code by
    using this macro. Also, blocks of code will be executed only if
    rails-root exist.
     (rails-project:with-root (root)
        (foo root)
        (bar (rails-core:file \&quot;some/path\&quot;)))
     &quot;
     `(let ((,root (rails-project:root)))
        (when ,root
          (flet ((rails-project:root () ,root))
            ,@body))))


Can someone explain why this breaks autocomplete?

Emacs Ruby autocomplete almost working

I have a question about Emacs Lisp. What is the difference between **setq** and **setq-default**?

Tutorials say **setq** takes effect in the *local buffer* while **setq-default** affects all buffers.  
 
For example, if I wrote **(setq a-var a-vars-value)** in **init.el**, I found after starting Emacs and opening a new buffer, the **a-var** is also there and its value is **a-vars-value**. I thought it was not supposed to be there. It seems there is no difference between **setq** and **setq-default**.  

Is there something wrong with my understanding?

For example:  

1. I wrote **(setq hello 123)** in the **init.el** file, and I run **emacs abuffer** in the shell, then I input **&quot;hello C-x C-e&quot;**, it shows &quot;123&quot;. The same happens when I run this in all new buffers.  

2. I wrote **(setq tab-width 4)** in the **init.el** file. When I run **tab-width C-x C-e**, it shows &quot;8&quot; (Current mode is &#39;Text&#39;). However, when I use **(setq-default tab-width 4)**, it show &quot;4&quot;. I can&#39;t explain this phenomenon.

The difference between setq and setq-default in Emacs Lisp

While learning Ruby I&#39;ve come across the &quot;=&gt;&quot; operator on occasion. Usually I see it in the form of 

    :symbol =&gt; value

and it *seems* to be used frequently when passing values to functions. What exactly is that operator called? What does it do/mean? Is it built into Ruby or is it something that different frameworks like Rails and DataMapper add to the symbol class? Is it only used in conjunction with the symbol class? Thanks.

In Ruby what does &quot;=&gt;&quot; mean and how does it work?

I found these symbols in a function declaration several times, but I don&#39;t know what they mean.

**Example:**

    void raccogli_dati(double **&amp; V, double **p, int N) { 
      int ultimo = 3; 
      V = new double * [N/2]; 
      for(int i=0; i &lt; N/2; i++) { 
        V[i] = new double[N/2], std :: clog &lt;&lt; &quot;digita &quot; &lt;&lt; N/2 - i
                     &lt;&lt; &quot; valori per la parte superiore della matrice V: &quot;; 
        for(int j=i; j &lt; N/2; j++) 
          std :: cin &gt;&gt; V[i][j], p[ultimo++][0] = (V[i][j] /= sqrt(p[i][0]*p[j][0]));
      } 
      for(int i=1; i &lt; N/2; i++) 
        for(int j=0; j &lt; i; j++) 
           V[i][j] = V[j][i];
    }


Meaning of *&amp; and **&amp; in C++

When I say `{ :bla =&gt; 1, :bloop =&gt; 2 }`, what exactly does the `:` do? I read somewhere about how it&#39;s similar to a string, but somehow a symbol. 

I&#39;m not super-clear on the concept, could someone enlighten me?

What is the colon operator in Ruby?

How can you remove letters, symbols such as `∞&#167;&#182;•&#170;&#186;&#186;&#171;≥≤&#247;` but leaving plain numbers 0-9, I want to be able to not allow letters or certain symbols in an input field but to leave numbers only.

[Demo][1].

If you put any symbols like `&#161; € # &#162; ∞ &#167; &#182; • &#170;` or else, it still does not remove it from the input field. How do you remove symbols too? The `\w` modifier does not work either.


  [1]: http://jsfiddle.net/4vuHN/

Regex to remove letters, symbols except numbers

One of the most important rules and best practices when writing a library, is putting all symbols of the
library into a library specific namespace. C++ makes this easy, due to the `namespace` keyword. In
C the usual approach is to prefix the identifiers with some library specific prefix.

Rules of the C standard put some constraints on those (for safe compilation): A C compiler may look at only the first
8 characters of an identifier, so `foobar2k_eggs` and `foobar2k_spam` may be interpreted as the same
identifiers validly – however every modern compiler allows for arbitrary long identifiers, so in our times
(the 21st century) we should not have to bother about this.

But what if you&#39;re facing some libraries of which you cannot change the symbol names / idenfiers? Maybe you got
only a static binary and the headers or don&#39;t want to, or are not allowed to adjust and recompile yourself.


Content Type	Original Author	Original Content on Stackoverflow
Question	Cristian	View Question on Stackoverflow
Solution 1 - String	Trey Jackson	View Answer on Stackoverflow
Solution 2 - String	Pablo A Perez-Fernandez	View Answer on Stackoverflow

Convert Symbol to a String in Elisp

String Problem Overview

String Solutions

Solution 1 - String

Solution 2 - String

Directly accessing an instance variable vs. Using an accessor method

Why does Scala provide both multiple parameters lists and multiple parameters per list?

Attributions