operator-keyword

I am trying to verify something for myself about operator and function precedence in Haskell. For instance, the following code list = map foo $ xs can be rewritten as list = (map foo) $ (xs) and will eventually be list = map foo xs My question used to be, why the first formulation would not be rewritten as list = (map foo $) xs since function precedence is always higher than operator precedence, but I think that I have found the answer: operators are simply not allowed to be arguments of functions (except of course, if you surround them with parentheses). Is this right? If so, I find it odd,

I know it is a common issue, but looking for references and other material I don't find a clear answer to this question. Consider the following code: #include <string> // ... // in a method std::string a = "Hello "; std::string b = "World"; std::string c = a + b; The compiler tells me it cannot find an overloaded operator for char[dim] . Does it mean that in the string there is not a + operator? But in several examples there is a situation like this one. If this is not the correct way to concat more strings, what is the best way? Your code, as written, works. You’re probably trying to achieve

Say I have a string, $char. $char == "*". I also have two variables, $a and $b, which equal "4" and "5" respectively. How do I get the result of $a $char $b, ie 4 * 5 ? Thanks :) You can use eval() as suggested by @konforce, however the safest route would be something like: $left = (int)$a; $right = (int)$b; $result = 0; switch($char){ case "*": $result = $left * $right; break; case "+"; $result = $left + $right; break; // etc } safest method is a switch construct: function my_operator($a, $b, $char) { switch($char) { case '=': return $a = $b; case '*': return $a * $b; case '+': return $a + $b

I am using a library that defines output stream operators (operator<<) in the global namespace. In my own namespace, I was always declaring such operators in the global namespace, and never had problems with them. But now for various reasons I need to declare those operators in my own namespace, and suddenly, the compiler can't seem to find the operators declared in the library anymore. Here's a simple example that illustrates my problem: #include <iostream> namespace A { struct MyClass {}; } std::ostream & operator<<( std::ostream & os, const A::MyClass & ) { os << "namespace A"; return os; }