parentheses

I have an idea for a simple program to make that will help me with operator precedence in languages like C. The most difficult part of this is parenthesizing the expression. For example, I want this: *a.x++ = *b.x++ Converted to this: ((*(((a).(x))++)) = (*(((b).(x))++))) Which I did manually in these steps: *a.x++ = *b.x++ *(a).(x)++ = *(b).(x)++ *((a).(x))++ = *((b).(x))++ *(((a).(x))++) = *(((b).(x))++) (*(((a).(x))++)) = (*(((b).(x))++)) ((*(((a).(x))++)) = (*(((b).(x))++))) What is the best way to accomplish this? Is there already a solution out there that I could use? I'd prefer to do

I'm a beginner to Python and programming in general. Right now, I'm having trouble understanding the function of empty parentheses at the end of method names, built-in or user-created. For example, if I write: print "This string will now be uppercase".upper() ...why is there an empty pair of parentheses after "upper?" Does it do anything? Is there a situation in which one would put something in there? Thanks! the parentheses indicate that you want to call the method upper() returns the value of the method applied to the string if you simply say upper , then it returns a method, not the value

I often find myself doing things like: println(foo) when I'd like to do: println foo The compiler does not allow this. Also, println is a mouthful, I really just want to say: echo foo So, in a base package object I created the echo version of println: def echo(x: Any) = Console.println(x) Easy enough, have echo application wide, great. Now, how do I invoke echo without needing to wrap the Any to print in parens? object ∊ {def cho(s: Any) {println(s)}} ∊cho "Hello world" will save your fingers. It works because ∊ is a math-symbol in the Unicode Sm set, hence counts as an operator in Scala , so

I am working on translating an expression tree to a format that resembles infix notation; I am not evaluating the tree or executing its operations. The tree contains both logical and relational operations, and I would like to emit parentheses in an intelligent manner during the translation. To illustrate, consider the following contrived expression: a < x & (a < y | a == c) & a != d If I walk the expression tree produced by this expression in-order, then I will print out the following expression, which is incorrect. a < x & a < y | a == c & a != d // equivalent to (a < x & a < y) | (a == c & a