[Question]
  [
If you've ever tried to write palindromic code before, you'd know how much brackets tend to get in your way. `()()` is not a palindrome, even though it kinda looks like it should be, while `())(` and `()(` are both palindromic and both very dumb looking. Wouldn't it be convenient if it was the other way around?
A string is *conveniently palindromic* if it is equal to the string derived when its reverse has all its parentheses (`()`), brackets (`[]`), and braces (`{}`) flipped. No other characters are special and require flipping. (`<>` are sometimes paired but often not so they are left out.)
**Your task** is to write, in your language, a program (taking input on STDIN) or a function (taking a single string argument) which (a) gives a consistent true value\* when its argument is conveniently palindromic and a different, consistent false value otherwise, and (b) is *itself* conveniently palindromic.
For example, the following inputs are conveniently palindromic:
```
racecar
(a)(bb)(a)
void main(int argc, *char[] argv) {} (vgra []rahc* ,cgra tni)niam diov
```
And the following are not:
```
non-palindrome
A nut for a jar of tuna?
(old [style] parens) )snerap ]elyts[ dlo(
ingirumimusnocte)etconsumimurigni
```
You may not rely on any external state (specific filename, directory structure, other user input, web access, etc) except interpreter/compiler flags.
Also, you may not use "the comment trick" where you comment out or render unused some piece of code by taking advantage of your language's commenting facilities. For instance, all of the following are not allowed, because they contain non-functional parts that can be safely removed or destroyed (at the expense of losing conveniently-palindromic-ness):
```
{some code} // {edoc emos}
{some code} NB.BN {edoc emos}
"n\" ;{edoc emos} ;"; {some code}; "\n"
```
Obviously this might not cover every such case, but the spirit of the challenge here is not to use comments and unparsed\*\* code to achieve palindrominess, instead making use of the corrected parens and brackets. I'm looking at you, LISP, Brainfuck.
This is a [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code wins, but all lengths of code are welcome.
\* By consistent true and false values, I mean that you can return one of a pair of values, such as `1` for true and `0` for false, or `False` for true and `"no"` for false, so long as these values are different from each other, and do not change from run to run of your program. Use whatever saves you characters.
\*\* Not to be confused with *unexecuted*: code that is valid and might do weird things but never called is fine.
  
[Answer]
# GolfScript, ~~107~~ 91
```
.4:ab-1:ba=;1
%ba%{...fi@@=
c43.=;)('"([{
}])"'~?~'"([{
}])"')(;=.34c
=@@if...}%ab%
1;=ab:1-ba:4.
```
Newlines are artistic. `fi`, `c43` and `c` are noops, but **the entire code is executed.**
Prints `-3-1-1` for convenient palindromes, `-4-1-1` otherwise. [Try it online!](http://golfscript.tryitonline.net/#code=LjQ6YWItMTpiYT07MSViYSV7Li4uZmlAQD1jNDMuPTspKCciKFt7fV0pIid-P34nIihbe31dKSInKSg7PS4zNGM9QEBpZi4uLn0lYWIlMTs9YWI6MS1iYTo0Lg&input=LjQ6YWItMTpiYT07MQolYmEley4uLmZpQEA9CmM0My49OykoJyIoW3sKfV0pIid-P34nIihbewp9XSkiJykoOz0uMzRjCj1AQGlmLi4ufSVhYiUKMTs9YWI6MS1iYTo0Lg)
### Alternate version, 155 bytes
At the cost of 64 bytes, this can be improved upon:
```
0!*1{!}\;:);0:f;0:i;-1:ab;9:ba;
...=;1%ab%{....i@f@@fi@@=@.=@\)
+""'"([{}])"'~+?+~'"([{}])"'""+
(\@=.@=@@if@@f@i....}%ba%1;=...
;ab:9;ba:1-;i:0;f:0;(:;\{!}1*!0
```
As before, the entire code is executed and **every single byte affects the output.**
Prints `010` for convenient palindromes, `-100` otherwise. [Try it online!](http://golfscript.tryitonline.net/#code=MCEqMXshfVw7Oik7MDpmOzA6aTstMTphYjs5OmJhOy4uLj07MSVhYiV7Li4uLmlAZkBAZmlAQD1ALj1AXCkrIiInIihbe31dKSInfis_K34nIihbe31dKSInIiIrKFxAPS5APUBAaWZAQGZAaS4uLi59JWJhJTE7PS4uLjthYjo5O2JhOjEtO2k6MDtmOjA7KDo7XHshfTEqITA&input=MCEqMXshfVw7Oik7MDpmOzA6aTstMTphYjs5OmJhOwouLi49OzElYWIley4uLi5pQGZAQGZpQEA9QC49QFwpCisiIiciKFt7fV0pIid-Kz8rficiKFt7fV0pIiciIisKKFxAPS5APUBAaWZAQGZAaS4uLi59JWJhJTE7PS4uLgo7YWI6OTtiYToxLTtpOjA7ZjowOyg6O1x7IX0xKiEwOw)
### Tests and examples
```
$ base64 > palindrome.gs -d <<< LjQ6YWItMTpiYT07MSViYSV7Li4uZmlAQD1jNDMuPTspKCciKFt7fV0pIid+P34nIihbe31dKSInKSg7PS4zNGM9QEBpZi4uLn0lYWIlMTs9YWI6MS1iYTo0Lg==
$ wc -c palindrome.gs
91 palindrome.gs
$ rev palindrome.gs | tr '([{}])' ')]}{[(' | diff - palindrome.gs
$ echo -n 'r(a[c{"e"}c]a)r' | golfscript palindrome.gs
-3-1-1
$ echo -n 'totallynotapalindrome' | golfscript palindrome.gs
-4-1-1
$
$ base64 > pal.gs -d <<< MCEqMXshfVw7Oik7MDpmOzA6aTstMTphYjs5OmJhOy4uLj07MSVhYiV7Li4uLmlAZkBAZmlAQD1ALj1AXCkrIiInIihbe31dKSInfis/K34nIihbe31dKSInIiIrKFxAPS5APUBAaWZAQGZAaS4uLi59JWJhJTE7PS4uLjthYjo5O2JhOjEtO2k6MDtmOjA7KDo7XHshfTEqITA=
$ wc -c pal.gs
155 pal.gs
$ rev pal.gs | tr '([{}])' ')]}{[(' | diff - pal.gs
$ echo -n 'r(a[c{"e"}c]a)r' | golfscript pal.gs
010
$ echo -n 'totallynotapalindrome' | golfscript pal.gs
-100
$ for i in {1..154}; do head -c $i pal.gs > tmp.gs; tail -c +$[i+2] pal.gs >> tmp.gs
> [ "$(echo -n 'r(a[c{"e"}c]a)r' | golfscript tmp.gs 2> /dev/null)" = "010" ] && echo $i
> done; rm tmp.gs
1
for i in {1..154}; do head -c $i pal.gs > tmp.gs; tail -c +$[i+2] pal.gs >> tmp.gs
>  [ "$(echo -n '42' | golfscript tmp.gs 2> /dev/null)" = "-100" ] && echo $i
> done | grep '^1$'; rm tmp.gs
```
### How it works
```
.             # Duplicate the input string.
4:ab-1:ba     # Save 4 in “ab” and -1 in “ba”.
=;            # Compare 4 to -1 and discard the result.
1%            # Save every element from the input string in a new string.
ab%           # Reverse the input string.
{             # For each character in the input string:
  ...         # Duplicate the character thrice.
  fi          # Variable “fi” is undefined; this does nothing.
  @@=         # Verify that the character is equal to itself; push 1.
  c43         # Variable “c43” is undefined; this does nothing.
  .=;         # Verify that 1 is equal to itself and discard the result.
  )(          # Increment and decrement the character.
  '"([{}])"'~ # Push that string and evaluate it. Result: '([{}])'
  ?           # Retrieve the character's position in '([{}])'. -1 means not found.
  ~           # Negate the position.. Examples: -1 -> 0    0 -> -1    2 -> -3
  '"([{}])"') # Push that string and pop its last element. Result: '"([{}])' 34
  (;          # Decrement 34 (the ASCII code of a double quote) and discard.
  =           # Retrieve the corresponding character.
  .34         # Duplicate the character and push 34.
  c           # Variable “c” is undefined; this does nothing.
  =           # If the character is a double quote, the index was -1.
  @@if        # In that case, replace the double quote with the original character.
  ...         # Duplicate the new character thrice.
}%            #
ab%           # Save every fourth element in a new string to discard dummy values.
1;            # Push 1 and discard.
=             # Push 1 if the modified string matches the original, 0 otherwise.
ab:1-         # Save 4 in “1” and subtract.
ba:4.         # Save -1 in “4” and duplicate.
```
```
0!*           # Pop and push the input string.
1{!}\;:);     # Make “)” an alias for “!”.
0:f;0:i;      # Variables.
-1:ab;9:ba;   # Moar variables.
...=;         # Duplicate the input string.
1%ab%         # Reverse the copy.
{             # For each character in the input string:
  ....        # Duplicate the character four times.
  i@          # Push 0 and rotate a string copy on top of it.
  f@@fi@@     # Push 0 and rotate 0 on top of it.
  =@          # Push 1 and rotate a string copy on top of it.
  .=@         # Push 1 and rotate 1 on top of it.
  \)+         # Negate a 1 and add. Result: 1
  ""          # Push that string.
  '"([{}])"'  # Push that string.
   ~+         # Evaluate the second string and concatenate. Result: '([{}])'
   ?          # Retrieve the characters position in '([{}])'. -1 means not found.
   +~         # Add 1 to the position and negate. Ex.: -1 -> -1 | 0 -> -2 | 1 -> -3
  '"([{}])"'  # Push that string.
  ""          # Push that string.
  +           # Concatenate. Result: '"([{}])"' 
  (\          # Pop the first double quote and swap it with the rest of the string.
  @=.         # Retrieve the corresponding character and duplicate it.
  @=          # If the character is a double quote, the index was -1.
  @@if        # In that case, replace the double quote with the original character.
  @@          # Rotate the modified character to the bottom.
  f@i....     # Push dummy values.
  }%          #
  ba%         # Save every ninth element in a new string to discard dummy values.
  1;          # Push 1 and discard.
  =           # Push 1 if the modified string matches the original, 0 otherwise.
  ...;        # Duplicate thrice and discard the last copy.
  ab:9;ba:1-; # Variables.
  i:0;f:0;    # Moar variables.
  (:;\        # Negate, override “;” and swap.
  {!}1*!0     # Negate twice and push 0.
```
[Answer]
## J (60)
```
(|.-:'())([]][{}}{'&charsub) :: (busrahc&'}{{}][[])(()':-.|)
```
This is a function that takes an argument:
```
   (|.-:'())([]][{}}{'&charsub) :: (busrahc&'}{{}][[])(()':-.|) 'ingirumimusnocte)etconsumimurigni'
0
   (|.-:'())([]][{}}{'&charsub) :: (busrahc&'}{{}][[])(()':-.|) '(a)(bb)(a)'
1
```
Explanation:
* `f :: g` runs the function `f` over the input, and returns the result if it returns without error. If `f` fails, it runs `g` instead.
* The `f` here is `(|.-:'())([]][{}}{'&charsub)`, which does the actual work:
	+ `|.`: reverse
	+ `-:`: is equal to
	+ `'())([]][{}}{'&charsub`: replacing each bracket with its opposing bracket
* The `g` function is `(busrahc&'}{{}][[])(()':-.|)`, which is nonsense but syntactically valid. `busrahc` is not defined, but that doesn't matter because it is only resolved when it is run (and it won't run).
[Answer]
## Ruby, 110
```
(z=gets;r=z.tr *["([{}])",")]}{[("];p *z==r.reverse;1)||(1;esrever.r==z* p;[")]}{[(","([{}])"]* rt.z=r;steg=z)
```
Prints `true` if the input is a convenient palindrome and `false` if it isn't. Note that this solution assumes that the input isn't terminated by a newline, so test it with `echo -n`:
```
echo -n '(a)(bb)(a)' | ruby convpal.rb
true
echo -n '(a)(bb()a(' | ruby convpal.rb
false
# note that for this to work, the file must not contain a newline
# to remove a trailing newline, pipe it through tr -d $'\n'
cat convpal.rb | ruby convpal.rb
true
```
This is a somewhat straightforward port of [my answer](https://codegolf.stackexchange.com/a/1801/84) to [Palindromic Palindrome Checker](https://codegolf.stackexchange.com/questions/1798/palindromic-palindrome-checker) (and not really golfed so far). The main trick used is that the first parenthesised expression always returns `1`, so the second half of the boolean expression is never evaluated (but it is parsed).
The only difficulty in adapting this was figuring out how to add the call to `z.tr` so that its "convenient reverse" would also be syntactically valid - but I could simply use the same trick I already used puts: `*`, which in the first half is parsed as splat operator (use array contents as function parameters) and as array multiplication (or repitition) operator in the second half.
## Ruby, 157 ~~297~~, all code executed
```
w=tsoh=gets p
o=rt=esrever=Gem
q=tsoh.tr *["([{}])",")]}{[("]
q==esrever.host=w=tsoh.reverse==q
[")]}{[(","([{}])"]* rt.host=q
meG=reverse=tr=o
p steg=host=w
```
This (slightly longer) version executes *all* code, and all but two lines affect the output, which is printed in the last line - but all lines are parsed and executed without any errors. This version interprets any trailing newline as part of the input, so use either `echo -n` to test it, or prepend your input with a newline. It prints `true` if the input is a convenient palindrome, and `false` otherwise.
### Explanation
```
# Read the input by calling gets(nil), which is achieved by passing the return
# value of a call to Kernel#p (which returns nil if no argument is supplied) to
# gets.
w=tsoh=gets p
# Assign the global Gem module to three variables.
# The variable names are the reversed names of methods we have to call later.
# This doesn't necessarily have to be the Gem module, any global module/variable
# (or class that allows object creation through a call to the module itself,
# e.g. Hash or GC) with a writable property would do, but Gem#host was
# the shortest one I could find. This is necessary because Ruby doesn't
# allow setting previously undefined properties through the dot syntax.
o=rt=esrever=Gem
# Replace the parentheses with the corresponding flipped one.
# sserts is the reverse of the property name we're going to use later.
q=tsoh.tr *["([{}])",")]}{[("]
# Do the convinient palindrome check and assign its result to a few variables
# and Gem's host property.
q==esrever.host=w=tsoh.reverse==q
# Here, the * is parsed as array join operator.
[")]}{[(","([{}])"]* rt.host=q
# Nothing special here.
meG=reverse=tr=o
# Print the result of the palindrome check, which was stored in w.
p steg=host=w
```
[Answer]
# GolfScript, 61 chars
OK, here's a baseline solution in GolfScript. I'm sure it could be further improved:
```
{.-1%{"([{}])".2$?~@[.]@+=}%=}~{=%{=+@[.]@~?$2."([{}])"}%1-.}
```
As usual for GolfScript, this program reads its input from stdin. It outputs:
```
1{=%{=+@[.]@~?$2."([{}])"}%1-.}
```
if the input is a convenient palindrome, as defined in the challenge above, and:
```
0{=%{=+@[.]@~?$2."([{}])"}%1-.}
```
if it is not.
**Explanation:** This program relies heavily on the ruling that *unexecuted* code is OK, as long as it gets parsed. It consists of two code blocks, delimited by curly braces (`{ }`), which are mirror images of each other.
The first code block is executed by the `~` following it, and checks if the input is a convenient palindrome, outputting `1` if it is and `0` if it isn't. The second code block is *not* executed, and so simply remains on the stack until the program ends and everything on the stack gets automatically stringified and printed by the GolfScript interpreter.
It should be noted that the GolfScript interpreter does *very* few syntax checks at parse time (or ever, for that matter); a GolfScript code block literal can contain almost anything, even if it might crash when executed. Still, a few syntax errors, such as unterminated string literals, do raise an error even in unexecuted code, so I believe this solution (barely) falls within the rules.
**Ps.** Looking at the actual executed code, it contains a few conveniently palindromic elements like `@[.]@`, the string literal `"([{}])"`, and even the loop `%{ ... }%`. This offers the tantalizing suggestion that an "intrinsically palindromic" GolfScript solution, where the full palindromic program would be executed and functional, might actually be possible. As I haven't managed to produce one myself yet, I hereby offer a **+100 rep bounty** to the first person who manages to come up with one!
[Answer]
# JavaScript (ES6), 245 bytes
I wanted a JS answer that could be run in the browser, so here it is.
```
eurt=>eurt==(("",eurt))["split"||"nioj"]("")["map"||"esrever"](x=>({'{':'}','}':'{','[':']',']':'[','(':')',')':'('})[x]||x||[x]({')':'(','(':')',']':'[','[':']','}':'{','{':'}'})>=x)["reverse"||"pam"]("")["join"||"tilps"]((true,""))==true>=true
```
Removing all code that is never actually run, we get this:
```
eurt=>eurt==(("",eurt))["split"||"nioj"]("")["map"||"esrever"](x=>({'{':'}','}':'{','[':']',']':'[','(':')',')':'('})[x]||x||[x]({')':'(','(':')',']':'[','[':']','}':'{','{':'}'})>=x)["reverse"||"pam"]("")["join"||"tilps"]((true,""))==true>=true
eurt=>eurt==(("",eurt))["split"        ]("")["map"           ](x=>({'{':'}','}':'{','[':']',']':'[','(':')',')':'('})[x]||x                                                           )["reverse"       ]("")["join"         ]((true,""))==true>=true
```
Which can be simplified to this:
```
eurt=>eurt==eurt.split("").map(x=>({'{':'}','}':'{','[':']',']':'[','(':')',')':'('})[x]||x).reverse("").join("")
```
[Answer]
# Javascript (ES6) 288
Runs in the [Spidermonkey command line shell](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/Introduction_to_the_JavaScript_shell). Reads a single line from STDIN and outputs `true` or `false` depending on if the input is a convenient palindrome.
```
((print)((eval)('r=readline()')==([0]['map']['call'](r,x=>({'{':'}','}':'{','[':']',']':'[','(':')',')':'('})[x]||x)['reverse']()['join']('')))&&((('')['nioj']()['esrever'](x||[x]({')':'(','(':')',']':'[','[':']','}':'{','{':'}'})>=x,r)['llac']['pam'][0])==('()enildaer=r')(lave))(tnirp))
```
This code is syntactically valid, but everything after `&&` is not executed, as the `print` function returns a falsey value.
You can run this code in Firefox's console by running this shim first to emulate the `readline` and `print` functions. Edit the input inside `readline` as needed:
```
readline = function(){ 
    return "void main(int argc, *char[] argv) {} (vgra []rahc* ,cgra tni)niam diov"; 
}, print = console.log.bind(console);
```
And here's a quick example of the output:
![command line example](https://i.stack.imgur.com/1F55J.png)
[Answer]
# 05AB1E, 35 bytes
```
"{[()]}"DRr‡`rJ¹Q,Q¹Jr`‡rRD"{[()]}"
```
[Try it online!](http://05ab1e.tryitonline.net/#code=IntbKCldfSJEUnLigKFgckrCuVEsUcK5SnJg4oChclJEIntbKCldfSI&input=KGZkZCkoZGRmKQ)
Explanation:
```
                     # Implicit input
 "{[()]}"            # Push "{[()]}" onto the stack
         DR          # Pushes a reversed copy onto the stack
           r         # Reverse the order of the stack
            ‡        # Transliterate
             `       # Flatten array on stack
              r      # Reverse order of stack
               J     # Join stack
                ¹Q   # Check equality with first input
                  ,  # Print
                     # Everything after is still syntactically correct, but just does not print anything.
```
[Answer]
# CJam, 38 bytes
```
Q~"=re%W_@%W_q"`{[()]}`"q_W%@_W%er="~Q
```
Prints `"=re%W_@%W_q"1` if the input is conveniently palindromic and `"=re%W_@%W_q"0` otherwise.
Try it online in the [CJam interpreter](http://cjam.aditsu.net/#code=Q~%22%3Dre%25W_%40%25W_q%22%60%7B%5B()%5D%7D%60%22q_W%25%40_W%25er%3D%22~Q&input=Q~%22%3Dre%25W_%40%25W_q%22%60%7B%5B()%5D%7D%60%22q_W%25%40_W%25er%3D%22~Q).
### How it works
```
Q~                                     e# Evaluate an empty string.
  "=re%W_@%W_q"                        e# Push that string.
               `                       e# Inspect. Pushes "\"=re%W_@%W_q\"".
                {[()]}                 e# Push that block.
                      `                e# Inspect. Pushes "{[()]}".
                       "           "~  e# Push and evaluate.
                        q              e# Read from STDIN.
                         _W%           e# Push a reversed copy.
                            @          e# Rotate "{[()]}" on top of the stack.
                             _W%       e# Push a reversed copy.
                                er     e# Perform transliteration.
                                  =    e# Compare to the input string.
                                     Q e# Push an empty string.
```
After executing the program, CJam automatically prints all three items on the stack: the inspected string, the Boolean from the string comparison and the empty string.
[Answer]
# Perl, 83 + 2 = 85 bytes
Run with `-nl`
```
say$_~~reverse y-"({[]})"-")}][{("-r;exit;tixe;r-")}][{("-"({[]})"-y esrever~~_$yas
```
The code exits after printing the truthiness of the input. Everything after the semicolon is interpreted (and would crash when the script reaches that point were it not for the `exit` it encounters), but not executed. If I left `exit;tixe;` out of the code, it would still print the result correctly before it crashed.
]