[Question]
  [
In particular, use each of these symbols at least once in your source code:
```
! " # $ % & ' () * + , - .  / : ; < = > ? @ [ \ ] ^ _ ` { | } ~
```
Symbols inside comments, string literals, regexps (or any other kinds of literals etc.) don't count (but their delimiters such as `/**/` or `""` do count).
The program should not perform any action. It just has to compile and do nothing when run.
If for some reason some of the symbols cannot be used in the language of your choice, explain that rigorously (what and why must be excluded).
**Update:** A few answers used symbols withing regular expressions. I'd consider this a bit problematic, it's the same thing as putting them into string literals or comments (that's why I put *etc.* in that requirement). Please try without this. I also updated the requirement above.
**Update:** Shortest code wins (tagged as *code-golf*). As suggested, we'll most likely need some tie-breaker criteria. I suggest that if there is a tie, the winning one is the one in which the ASCII symbols appear as much ordered as possible. Formally: Filter out the first occurrence of each of the listed symbols from a program. This will result in a permutation on the listed symbols. The program with less [inversion number](http://en.wikipedia.org/wiki/Inversion_%28discrete_mathematics%29#Definitions) of its permutation wins.
**Update:** I'd be happy to see some/more solutions in regular/mainstream languages, such as C(++), Java, Scala, Haskell, etc.
  
[Answer]
## Perl, 32 chars
no hiding symbols in comments, string literals, or regular expressions. uses all symbols precisely once.
```
$`<@"^[(\{_},)]/+-~%'?&|:!*.=>;#
```
### Description
i have tried to indicate operator precedence with indentation: the right-most expressions are evaluated before those to their left
```
        $`            # scalar variable $ named `
      <               # numeric less-than inequality <
        @"            # array variable @ named "
                      #   (array evaluated in scalar context)
    ^                 # bitwise XOR ^
        [(\{_},)]     # array reference [] 
                      #   containing array () 
                      #     containing reference \
                      #       to anonymous hash reference {}
                      #         with one key "_" 
                      #           and no value (nothing following comma ,)
                      #             (reference evaluated in scalar context)
      /               # numeric division /
        +-~%'         # unary addition +
                      #   and unary negation -
                      #     and bitwise complement ~
                      #       on hash variable % named '
                      #         (hash evaluated in scalar context)
  ?                   # ternary conditional operator ?:
    &|                # code reference variable & named |
  :                   # ternary conditional operator ?:
    ! *.              # logical negation !
                      #   on typeglob variable * named .
                      #     (typeglob evaluated in scalar context)
  =>                  # fat comma => for compound expression
                      #   (evaluates LHS as string, RHS is empty)
;                     # end of expression ;
#                     # start of comment #
```
[Answer]
## Brainf\*ck, 32 characters
```
!"#$%&'()*+.-/:;>=<?@[\]^_`{|}~,
```
Prints a smiley face (if your console can output ASCII symbol 1)
Yay, a Branf\*ck solution that beats Golfscript! :P
If you insist on no output, just exchange the `+` and `.` :
```
!"#$%&'()*.+-/:;>=<?@[\]^_`{|}~,
```
[Answer]
## Whitespace, 32
```
!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
```
all non whitespace characters are ignored, so this is actually an empty program
[Answer]
## Python 65
```
a=lambda x:0.
@a#
def _():{[`'"$?'`,]};a<a!=a+a%a&a^a-a*a|~a>a/a\
```
I used the characters `?` and `$` inside a string literal. These characters are [not legal](http://docs.python.org/2/reference/lexical_analysis.html#delimiters) outside string literals or comments.
[Answer]
# PHP, 32 chars
Probably a bit of a troll, this PHP program is also a **QUINE**, and uses all symbols in the exact order they are listed.
```
!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
```
Executed from the command line, the output will simply be the contents of the file, as there is no `<?php` to invoke the interpretor.
```
$ cat > a.php
!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
$ php a.php
!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
```
[Answer]
# Perl 6 (43 chars)
Let's define a infix operator with a rather unusual name:
```
sub infix:<!"#$%&'()*+,-./:;=?@[]^_´\|~>{}
```
It's not a literal nor a literal in a RE or anything hidden in a comment. You don't believe me? Running the following program will output "2":
```
sub infix:<!"#$%&'()*+,-./:;=?@[]^_´\|~>($a, $b){ $a + $b }
say 1 !"#$%&'()*+,-./:;=?@[]^_´\|~ 1;
```
But I'm quite sure you nitpickers will extend the rules further to exclude redefinition of the language itself to make us perl lubbers unhappy. :(
[Answer]
## Haskell, 53
```
a@""#%&*+/?^b|a'<-a!!0=(\_->a`b`[]);main=do{print$1}
```
We can make this a bit shorter
## 45
```
a'@""#%&*+/?!<|^b=(\_->1`b`[]);main=do{main}
```
however this program doesn't terminate, and uses more characters (`'!'`,`'<'`,`'|'`) in the newly-defined infix.
[Answer]
# k (33 chars)
Very easy in k. Unfortunately `"` must be paired.
```
(@:'!""#$%&*+-\./;<=>?^_{}[`]|,~)
```
[Answer]
## GolfScript (33 chars)
```
{!""$%&()*+,-./<=>?@[\]^_`|~};:'#
```
`"` has to be paired. It took a bit of trial and error to get it to output nothing - most other positions of the `:'` result in some output.
[Answer]
## J, 33 characters
```
''&][?!"$>{}:<;,|^~*/\%+`-@.#(=_)
```
`'` needs to be doubled to avoid syntax errors.
My first answer was missing some symbols.
[Answer]
## C, 48 chars
Kind of cheating.
```
#define _ ~''*+,-./:<=>?[]`|\
@%^$&!
main(){"";}
```
[Answer]
# Postscript - 32 chars
```
{!"#$&'()*+,-./:;=<>?@[\]^_`|~}%
```
Results in an object on the stack, but otherwise has no effects. Postscript allows almost any char in an identifier except for `<>()[]{}/` which are special syntax forms and `%` which introduces a comment. The program is tokenized as
```
{                  % start a procedure object
!"#$&'             % an identifier
()                 % an empty string
*+,-.              % an identifier
/:;=               % a symbol
<>                 % an empty hex string
?@                 % an identifier
[\]                % an array
^_`~|              % an identifier
}                  % close the procedure object
%                  % a comment
```
[Answer]
## **C# (91 characters)**
```
#define a 
class a{static int @Main(){return(char)1.1*""[0]/1%1-1+1!=1?1:~1^1>>1<<1&1+'\0';}}
```
As far as I know, The **$** character is not a valid character outside string literals, so I didn't use it in my answer.
**EDIT** : Thanks to [Peter Taylor](https://codegolf.stackexchange.com/users/194/peter-taylor), I shortened the code.
[Answer]
## PowerShell (52 characters)
```
$_+=(@(1.1,1)[0]-1)*1/1%'1'::ToInt|&{!"">~\1}<#^#>`;
```
I had to put the **^** character as a string literal because as far as I know, the **^** character is not a legal PowerShell character outside string literals. Correct me if I am wrong.
The only way I have found to fit in the **:** character is to use the **:: operator** to make a call to a static method.
[Answer]
### Scheme, 41 characters
```
(define !$%&*+,-./:<=>?@[\]^_`{|}~ "#'");
```
This takes advantage of Scheme's incredible tolerance for characters in variable names. In this program I create a variable with the name !$%&\*+,-./:<=>?@[]^\_`{|}~ which Scheme happily accepts.
[Answer]
# Tcl 37 chars
```
set {!#$%&'()*+,-./:<=>?@[]^\_`|~} ""
```
Defines a variable `!#$%&'()*+,-./:<=>?@[]^\_`|~` with an empty string
[Answer]
# C: 83 56 characters
```
#undef a
_;main($){$/=-+~!0|0^0%1,1<.0>0?'`':*&"@"[0];}\
```
At-signs and backticks are not a part of the allowed C-syntax, so I have put them between quotation marks.
[Answer]
### Common Lisp, 33 characters
```
#+()'|!"$%&*,-./:;<=>?@[\]^_`{}~|
```
The main part of the above evaluates (or rather, would evaluate if not for the `#+()` in front of it) to the symbol named:
```
!#$%&()*+,-./:;<=>?@[\]^_`{}~
```
The `#+()` is to avoid output. I'm not sure if the `|foo|` syntax for symbols counts as a literal, but symbols are used as variable/function names in Common Lisp, and there are a few answers already using the necessary characters in those.
[Answer]
**Smalltalk** (Squeak 4.x dialect) **38** chars
Implement this method in Object, the syntax is valid if Preferences *Allow underscore assignment* (which is the default setting)
```
%&*+/<=>?@\!~y""^Z_([:z|{#'',$`;-y}]).
```
declare Z as global var in pop-up menu if interactive
Explanations:
* %&\*+/<=>?@!~ is a binary selector (an operator)
* y is the parameter (the operand)
* "" is an empty comment
* ^ means return
* Z is a global variable
* \_ is an assignment
* () delimits a sub-expression
* [:z|] delimits a block of code with one parameter z
* {} delimits an Array
* #'' is a Symbol literal made of an empty String (first element of the Array)
* , is a binary message sent to above Symbol
* $` is a Character literal used as argument of above message
* ; is for chaining a second message sent to the same Symbol receiver #''
* the second message is -
* y is used as the second message argument
* . is for separating next instruction (here it's a final period)
Damn, who said Smalltalk was readable?
Note that I didn't cheat, the only non valid character ` is put into a literal Character. **EDIT** see below, this was a false assertion (at least in Squeak)
---
But we can make it down to **34** chars with this trick
```
%&*+,-/<=>?@\!~|y""^[{#(:_;`$')}].
```
This time:
* #() delimits a literal Array
* which contains 4 literal Symbols : \_ ; ` and 1 literal Character $'
Strictly speaking, we can consider this as cheating... It's not a literal String, but it is still a non empty literal...
I still have to double comment quote "" (unless I make a literal Character with it $", but then I need to double the String quote '')  
I still have to use a letter for the parameter (\_ is not accepted even if we set Preferences *allow underscore in selector* to true).
What is nice is that we can even run the method, for example send the message to 1 with argument 2:
```
1%&*+,-/<=>?@\!~|2
```
---
**EDIT** Finally in **35** chars without cheating
```
!%&*+,-/<=>?@`y""^[:x_|#()~$';\{}].
```
Notes:
* Preferences *allow underscore in selector* enable using a block parameter named x\_
* ` is a valid character for binary selector contrarily to what I said
* I also use $' to avoid doubling a quote
[Answer]
## R: 108 characters
```
a=new(setClass("a",representation(b="list")));a@b=list(c_d=1:2);if(1!='\t'&.1%*%1^1>a@b$c[1]/1|F){`~`<-`?`}#
```
Clearly the longest submission, but to be able to use symbols `@` and `$` in R, we need to create an object that has slots (indexed using `@`) and named elements (indexed using `$`).  
The shortest solution I could think of was to create a new class of object (`a=new(setClass("a",representation(b="list")))`), which takes its toll. 
Otherwise, appart from the classics that don't need explanations (such as `!=`, `#` or `1:2`),
```
`~`<-`?` 
```
creates a new operator that does the same as operator `?` (i. e. it calls the help page of the element it precedes).
`%*%` computes the inner product of two matrices (here of `1^1` and `.1`).  
Symbol `_` does nothing (AFAIK) in R but is routinely used in variable or function names, as it is the case here.
[Answer]
## TI-Basic, 36
```
:End:#$%&'()*+.-/;>=<?@[\]^_`{|}~,!"
```
[Answer]
# [Rust](https://www.rust-lang.org/), 45 bytes
```
macro_rules!a{[r"`\"#%&'_*+-./:<?@^|~]=>{()}}
```
[Try it online!](https://tio.run/##KyotLvn/PzcxuSg/vqg0J7VYMbE6ukgpIUZJWVVNPV5LW1dP38rG3iGupi7W1q5aQ7O29n9ankJuYmaehmY1F2eiogZ21Zpctf8B "Rust – Try It Online")
Creates a macro that matches when you call it with the tokens r"`\"#%&'\_\*+-./:<?@^|~ and returns the unit type. Do note that the backtick and backslash are inside of a string literal because that is the only valid place they can go. Also, apparently whatever stack exchange uses for syntax highlighting can't handle rust's raw strings.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 32 bytes
```
!"#$%&')*+,-./:;<=>?@[\]^_`{|}~(
```
[Try it online!](https://tio.run/##y0rNyan8/19RSVlFVU1dU0tbR1dP38raxtbO3iE6JjYuPqG6prZO4/9/AA "Jelly – Try It Online")
This technically outputs `0`, but given that the [empty program](https://tio.run/##y0rNyan8DwQA) does that as well, I didn't see an issue with that (especially as there is no way to "output nothing" in Jelly, aside from outputting the empty string. In this case, [~~34~~ 33 bytes](https://tio.run/##y0rNyan8/19RSVlFVU1dU0tbR1dP38raxtbO3iE6JjYuPqG6prZO41Hjjv//AQ) (-1 byte thanks to xigoi)).
## How it works
Jelly works by splitting its program into "links", which are compositions of "chains", which are collections of "atoms" and "quicks". 31 of the 32 characters used above are either atoms or quicks (or syntax characters), `(` is the only non-implemented character. When Jelly encounters an unimplemented character outside of a string literal, it breaks the chain, essentially ignoring everything before it. So the `(` breaks the program's chain, ignoring all the previous (erroring) characters. At this point, the new chain is made up of the characters after the breaking character, which in this case, is the "empty" program.
For the 33 byte version, the last byte - `⁸` - is the new chain, and is an empty list, which is then implicitly output at the end of the program as nothing
[Answer]
# [CJam](https://sourceforge.net/projects/cjam/), 34 bytes
```
""`'5~*:+{i[}%-/#~|<=!$\?@,^>()_];
```
[Try it online!](https://tio.run/##S85KzP3/X0kpQd20TstKuzozulZVV1@5rsbGVlElxt5BJ85OQzM@1vr/fwA)
Explanation:
```
""`                 Push an empty string and get the string representation of that ("\"\"")
'5~*                Push a 5 character, convert it to a number, and multiply the previous string 5 times. We spend a alphanumeric char here because there's no way to use ' without wasting a char, as ' will simply accept the next character as a character and cannot be otherwise used (except in a string/char literal)
:+                  Over our string, try to do some concatenation. This doesn't really do much.
{i[}%               Convert all the characters in out string to their codepoints (34s for "). We now have a bunch of numbers on the stack. This is really nice, because CJam is strict with types but just about everything accepts numbers in some way. It's so nice that we spend a character on it.
-/#~|<=!$\?@,^>()_  Lots of meaningless operations. I just threw them in randomly and fiddled around with them so that everything would have enough operands, and we would be left with a small stack at the end
];                  Discard what we have left
```
]