Fix needless operation

samples/algorithms/DotProductViaPhaseEstimation.qs

@@ -67,7 +67,7 @@ namespace IterativePhaseEstimation {
         return x;
     }
 
-    operation ClassicalInnerProduct(theta1 : Double, theta2 : Double) : Double {
+    function ClassicalInnerProduct(theta1 : Double, theta2 : Double) : Double {
         return Cos(theta1 / 2.0) * Cos(theta2 / 2.0) + Sin(theta1 / 2.0) * Sin(theta2 / 2.0);
     }
 

samples/language/ArithmeticOperators.qs

@@ -8,7 +8,7 @@
 namespace MyQuantumApp {
 
     @EntryPoint()
-    operation Main() : Unit {
+    function Main() : Unit {
 
         // `-`, when applied to a single value on its right, negates the value.
 

samples/language/Array.qs

@@ -19,29 +19,29 @@
 namespace MyQuantumApp {
 
     @EntryPoint()
-    operation Main() : Int[] {
+    function Main() : Int[] {
 
         // A basic Int Array literal
         let intArray : Int[] = [1, 2, 3, 4];
         Message($"Integer Array: {intArray} of length {Length(intArray)}");
 
         // A basic String Array literal
         let stringArray = ["a", "string", "array"];
-        Message($"{stringArray}");
+        Message($"String Array: {stringArray}");
 
         // A new array expression creating the array `[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]`
         let repeatedArray = [0, size = 10];
-        Message($"{repeatedArray}");
+        Message($"Repeated Array: {repeatedArray}");
         let repeatedArray = Repeated(0, 10);  // contains [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-        Message($"{repeatedArray}");
+        Message($"Repeated Array: {repeatedArray}");
 
         // Arrays can be sliced with ranges.
         let slice = intArray[1..2..4];  // contains [2,4]
-        Message($"{slice}");
+        Message($"Sliced array: {slice}");
         let slice = intArray[2..-1..0]; // contains [3,2,1]
-        Message($"{slice}");
+        Message($"Sliced array: {slice}");
         let slice = intArray[...]; // contains [1, 2, 3, 4];
-        Message($"{slice}");
+        Message($"Sliced array: {slice}");
 
         return intArray;
     }

samples/language/BigInt.qs

@@ -8,7 +8,7 @@
 namespace MyQuantumApp {
 
     @EntryPoint()
-    operation Main() : BigInt {
+    function Main() : BigInt {
         // Numbers can be declared in hex, octal, decimal, or binary.
         let foo = 0x42L;
         Message($"Hexadecimal BigInt: {foo}");

samples/language/BitwiseOperators.qs

@@ -8,7 +8,7 @@
 namespace MyQuantumApp {
 
     @EntryPoint()
-    operation Main() : Unit {
+    function Main() : Unit {
 
         // `~~~` performs a bitwise NOT on the bits of an integer.
 

samples/language/Bool.qs

@@ -7,7 +7,7 @@
 namespace MyQuantumApp {
 
     @EntryPoint()
-    operation Main() : Bool {
+    function Main() : Bool {
         // `Bool`s can be operated upon with boolean operators:
         let andOp = true and true;
         Message($"AND operation: {andOp}");

samples/language/Comments.qs

@@ -12,9 +12,9 @@ namespace MyQuantumApp {
 
     /// This is a doc-comment for the `Main` operation.
     @EntryPoint()
-    operation Main() : Result[] {
+    function Main() : Result[] {
         // Comments can go anywhere in a program, although they typically
         // preface what they refer to.
         return [];
     }
-}
+}

samples/language/ComparisonOperators.qs

@@ -8,7 +8,7 @@
 namespace MyQuantumApp {
 
     @EntryPoint()
-    operation Main() : Unit {
+    function Main() : Unit {
 
         // `==` tests if the first value is equivalent to the second value.
 

samples/language/ConditionalBranching.qs

@@ -9,7 +9,7 @@
 /// If expressions allow your code to branch, or conditionally execute parts of a Q# program.
 namespace MyQuantumApp {
     @EntryPoint()
-    operation Main() : Unit {
+    function Main() : Unit {
         let number = 5;
         // Conditionally messages "Fizz" if the `number`, in this case 5, is divisible by 3.
         // Since 5 is not divisible by 3, the message "Fizz" will not be printed.

samples/language/CopyAndUpdateOperator.qs

@@ -10,7 +10,7 @@ namespace MyQuantumApp {
     newtype Pair = (first : Int, second : Int);
 
     @EntryPoint()
-    operation Main() : Unit {
+    function Main() : Unit {
         let array = [10, 11, 12, 13];
         let pair = Pair(20, 21);
 

samples/language/Double.qs

@@ -10,7 +10,7 @@
 namespace MyQuantumApp {
 
     @EntryPoint()
-    operation Main() : Double {
+    function Main() : Double {
         // A double declared in standard notation.
         let double = 0.1973269804;
 
@@ -19,4 +19,4 @@ namespace MyQuantumApp {
 
         return double;
     }
-}
+}

samples/language/EntryPoint.qs

@@ -9,7 +9,7 @@ namespace MyQuantumApp {
 
     // The Q# compiler identifies `Main` as the entry point operation because it is marked with the `@EntryPoint()` attribute.
     @EntryPoint()
-    operation Main() : Result[] {
+    function Main() : Result[] {
         return [];
     }
-}
+}

samples/language/ForLoops.qs

@@ -8,7 +8,7 @@
 namespace MyQuantumApp {
 
     @EntryPoint()
-    operation Main() : Unit {
+    function Main() : Unit {
         // For loop over `Range`
         for i in 0..5 {}
 

samples/language/Int.qs

@@ -7,7 +7,7 @@
 namespace MyQuantumApp {
 
     @EntryPoint()
-    operation Main() : Int {
+    function Main() : Int {
         // Numbers can be declared in hex, octal, decimal, or binary.
         let foo = 0x42;
         Message($"Hexadecimal: {foo}");
@@ -34,4 +34,4 @@ namespace MyQuantumApp {
 
         return foo;
     }
-}
+}

samples/language/LambdaExpression.qs

@@ -34,4 +34,4 @@ namespace MyQuantumApp {
         let incremented = Mapped(x -> x + 1, intArray);
         Message($"Array after incrementing each element using Map: {incremented}");
     }
-}
+}

samples/language/LogicalOperators.qs

@@ -8,7 +8,7 @@
 namespace MyQuantumApp {
 
     @EntryPoint()
-    operation Main() : Unit {
+    function Main() : Unit {
 
         // `and` performs the Boolean And on two Boolean values.
 

samples/language/MultiFileProject/src/Main.qs

@@ -10,10 +10,11 @@
 namespace MyQuantumApp {
     open Particle;
     @EntryPoint()
-    operation Main() : Unit {
+    function Main() : Unit {
         let particleA = Particle(0, 0, 0);
         let particleB = Particle(1, 1, 1);
 
         let particleC = addParticles(particleA, particleB);
+        Message($"Particle C: Particle({particleC::x}, {particleC::y}, {particleC::z})")
     }
 }

samples/language/PartialApplication.qs

@@ -8,7 +8,7 @@
 namespace MyQuantumApp {
     open Microsoft.Quantum.Arrays;
     @EntryPoint()
-    operation Main() : Unit {
+    function Main() : Unit {
         // This takes our adding function and partially applies it,
         // filling the second argument with `1` and returning another
         // function that takes one argument and passes it in to `Add`.

samples/language/Range.qs

@@ -11,7 +11,7 @@
 namespace MyQuantumApp {
 
     @EntryPoint()
-    operation Main() : Range {
+    function Main() : Range {
 
         // Ranges can be captured as local variables.
 

samples/language/ReturnStatement.qs

@@ -6,7 +6,7 @@
 /// return control flow to the callee's scope with a given value.
 namespace MyQuantumApp {
     @EntryPoint()
-    operation Main() : Unit {
+    function Main() : Unit {
         // After the execution of the function `Returns42`, control flow
         // will return to this scope.
         let number42 = Returns42();
@@ -26,4 +26,4 @@ namespace MyQuantumApp {
         // If a callable is annotated to return any other type besides `Unit`, then it
         // must return a value of that type.
     }
-}
+}

samples/language/String.qs

@@ -6,7 +6,7 @@
 namespace MyQuantumApp {
 
     @EntryPoint()
-    operation Main() : String {
+    function Main() : String {
         // Strings literals are declared with double quotes:
         let myString = "Foo";
 
@@ -20,4 +20,4 @@ namespace MyQuantumApp {
 
         return myString;
     }
-}
+}

samples/language/Ternary.qs

@@ -9,7 +9,7 @@
 /// `[condition] ? [true branch] | [else branch]`
 namespace MyQuantumApp {
     @EntryPoint()
-    operation Main() : Unit {
+    function Main() : Unit {
         let fahrenheit = -40;
 
         // The below ternary expression sets the value of `fahrenheit` to its absolute value.

samples/language/Tuple.qs

@@ -11,7 +11,7 @@
 namespace MyQuantumApp {
 
     @EntryPoint()
-    operation Main() : (Int, String) {
+    function Main() : (Int, String) {
         // A tuple of type `String`, `Int`, and `Double`
         let myTuple = ("Id", 0, 1.);
         Message($"Tuple: {myTuple}");

samples/language/TypeDeclarations.qs

@@ -6,7 +6,7 @@
 /// in Q#. They are immutable but support a copy-and-update construct.
 namespace MyQuantumApp {
     @EntryPoint()
-    operation Main() : Unit {
+    function Main() : Unit {
         // UDTs are defined with the `newtype` keyword.
         newtype Point3d = (X : Double, Y : Double, Z : Double);
 

samples/language/Unit.qs

@@ -8,11 +8,10 @@
 namespace MyQuantumApp {
 
     @EntryPoint()
-    operation ExplicitReturn() : Unit {
-        // Explicitly return `Unit`.
+    function ExplicitReturn() : Unit {
         return ();
     }
     operation NoReturn() : Unit {
         // No return, thus implicitly returning `Unit`.
     }
-}
+}

samples/language/Variables.qs

@@ -5,7 +5,7 @@
 /// Variables in Q# are immutable by default and can be shadowed.
 namespace MyQuantumApp {
     @EntryPoint()
-    operation Main() : Unit {
+    function Main() : Unit {
         // Immutable variables are declared with the `let` keyword:
         let immutableInt = 42;
         Message($"Immutable Int: {immutableInt}");

samples/language/WhileLoops.qs

@@ -9,7 +9,7 @@
 namespace MyQuantumApp {
 
     @EntryPoint()
-    operation Main() : Unit {
+    function Main() : Unit {
         mutable x = 0;
         while x < 3 {
             set x += 1;