ambiguity

Consider the following function prototypes: void Remove(SomeContainer& Vec, const std::size_t Index); SomeContainer Remove(SomeContainer Vec, const std::size_t Index); The second is implemented in terms of the first. That is to say, they are functionally identical in every way except that one is pass-by-reference and the other is pass-by-value. However, GCC says these are ambiguous in cases like this, even though the first form is the only one that does not return a value: Remove(SomeContainer, 123); Is there any workaround to this, or do I have to come up with different names for each form?

The question rose in context of this answer . Consider an example: struct foo { int value; operator int&(){ return value; } operator int(){ return value; } }; int main () { int &a(foo{}); // #1 //int &b{foo{}}; // #2 -- ambiguity int &c = foo{}; // #3 //int &d = {foo{}}; // #4-- ambiguity int &d { a }; // #5 int &e = { a }; // #6 (void)a; (void)c; (void)d; (void)e; } I don't understand why does #2 and #4 cause ambiguity while #1 and #3 does not. So the question is - why does direct list initialization causes ambiguity for implicit cast to reference if cast operators to the type and reference

I have the following code written in ANTLRWorks 1.4 grammar hmm; s : (put_a_in_b)|(put_out_a)|(drop_kick)|(drop_a)|(put_on_a); put_a_in_b : (PUT_SYN)(ID)(IN_SYN)(ID); put_out_a : (PUT2_SYN)(OUT_SYN)(ID) | (E1)(ID); drop_kick : ('drop')('kick')(ID); drop_a : (DROP_SYN)(ID); put_on_a : (E2)(ID); PUT_SYN : 'put' | 'place' | 'drop'; PUT2_SYN : 'put' | 'douse'; IN_SYN : 'in' | 'into' | 'inside' | 'within'; OUT_SYN : 'out'; E1 : 'extinguish'|'douse'; DROP_SYN : 'drop' | 'throw' | 'relinquish'; WS : ( ' ' | '\t' | '\r' | '\n' ) {$channel=HIDDEN;}; ID : ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'0'..

I'm going to bootstrap this question with a previous one I asked: LINQ to SQL: Multiple joins ON multiple Columns. Is this possible? So I have a LINQ query: var query = from t1 in myTABLE1List // List<TABLE_1> join t2 in myTABLE1List on new { t1.ColumnA, t1.ColumnB } equals new { t2.ColumnA, t2.ColumnB } join t3 in myTABLE1List on new { t2.ColumnA, t2.ColumnB } equals new { t3.ColumnA, t3.ColumnB } select new {t1.ColumnA, t2.ColumnA, t3.ColumnA } // Duplicate Anon type 'ColumnA' How can I resolve this? With explicit naming of the properties of the anonymous type select new {t1A = t1.ColumnA,

I'm trying to produce a pretty simple XML schema for an XML similar to the following: <messages> <item> <important_tag></important_tag> </item> <item> <important_tag></important_tag> <tag2></tag2> </item> <item> <tag2></tag2> <tag3></tag3> </item> </messages> The idea is that <important_tag> will have a specific definition AND it may or may not appear under <item> . It may also appear more than once. Additionally, there may be other tags before or after <important_tag> that I can not name in advance. I would like to give a specific definition for <important_tag> . For example, define

I'm confused about how context-sensitivity and ambiguity influence each other. What i think is correct is: Ambiguity: An ambiguous grammar leads to the construction of more than one parse-tree using either left or right derivation. A language where all possible grammars are ambiguous is an ambiguous language. For instance C++ is an ambiguous language because x * y always can mean two different things as discussed in: Why can't C++ be parsed with a LR(1) parser? . Context-sensitivity: A context-sensitive grammar has rules where the left hand side of these rules may contain (non)terminal symbols

How is it possible that this code TaskManager.RunSynchronously<MyObject>(fileMananager.BackupItems, package); causes a compile error The call is ambiguous between the following methods or properties: 'TaskManager.RunSynchronously<MyObject>(System.Action<MyObject>, MyObject)' and 'TaskManager.RunSynchronously<MyObject>(System.Func<MyObject, bool>, MyObject)' when signature of the action is public void BackupItems(MyObject package) and "ambiguous" methods are static class TaskManager { public static void RunSynchronously<TInput>(Action<TInput> task, TInput param) { Task.Factory.StartNew(() =>