Update samples to reflect latest 1.7 changes; Update katas and stdlib to use structs

compiler/qsc/src/interpret.rs

@@ -20,6 +20,7 @@ pub use qsc_eval::{
     val::Value,
     StepAction, StepResult,
 };
+use qsc_linter::Lint;
 use qsc_lowerer::{map_fir_package_to_hir, map_hir_package_to_fir};
 use qsc_partial_eval::ProgramEntry;
 use qsc_rca::PackageStoreComputeProperties;
@@ -294,6 +295,19 @@ impl Interpreter {
     pub fn set_classical_seed(&mut self, seed: Option<u64>) {
         self.classical_seed = seed;
     }
+
+    pub fn check_source_lints(&self) -> Vec<Lint> {
+        if let Some(compile_unit) = self
+            .compiler
+            .package_store()
+            .get(self.compiler.source_package_id())
+        {
+            qsc_linter::run_lints(self.compiler.package_store(), compile_unit, None)
+        } else {
+            Vec::new()
+        }
+    }
+
     /// Executes the entry expression until the end of execution.
     /// # Errors
     /// Returns a vector of errors if evaluating the entry point fails.

katas/content/complex_arithmetic/Common.qs

@@ -1,35 +1,35 @@
 namespace Kata.Verification {
     open Microsoft.Quantum.Math;
-    open Microsoft.Quantum.Random;    
+    open Microsoft.Quantum.Random;
     open Microsoft.Quantum.Convert;
 
     operation DrawRandomComplex() : Complex {
-        // Generates a random complex number. 
+        // Generates a random complex number.
         let real = DrawRandomDouble(-10., 10.);
         let imag = DrawRandomDouble(-10., 10.);
         return Complex(real, imag);
     }
 
     function ComplexAsString(x : Complex) : String {
-        if x::Imag < 0.0 {
-            $"{x::Real} - {AbsD(x::Imag)}i"
+        if x.Imag < 0.0 {
+            $"{x.Real} - {AbsD(x.Imag)}i"
         } else {
-            $"{x::Real} + {x::Imag}i"
+            $"{x.Real} + {x.Imag}i"
         }
     }
 
     function ComplexPolarAsString(x : ComplexPolar) : String {
-        $"{x::Magnitude} * exp({x::Argument}i)"
+        $"{x.Magnitude} * exp({x.Argument}i)"
     }
 
     operation CheckTwoComplexOpsAreSame(sol : (Complex, Complex) -> Complex, ref : (Complex, Complex) -> Complex) : Bool {
-        for _ in 0 .. 24 {
+        for _ in 0..24 {
             let x = DrawRandomComplex();
             let y = DrawRandomComplex();
 
             let expected = ref(x, y);
             let actual = sol(x, y);
-        
+
             if not ComplexEqual(expected, actual) {
                 Message("Incorrect");
                 Message($"For x = {ComplexAsString(x)}, y = {ComplexAsString(y)} expected return {ComplexAsString(expected)}, actual return {ComplexAsString(actual)}.");
@@ -41,13 +41,13 @@ namespace Kata.Verification {
         return true;
     }
 
-    function ComplexEqual(x : Complex, y : Complex) : Bool { 
+    function ComplexEqual(x : Complex, y : Complex) : Bool {
         // Tests two complex numbers for equality.
-        AbsD(x::Real - y::Real) <= 0.001 and AbsD(x::Imag - y::Imag) <= 0.001
+        AbsD(x.Real - y.Real) <= 0.001 and AbsD(x.Imag - y.Imag) <= 0.001
     }
 
-    function ComplexPolarEqual(x : ComplexPolar, y : ComplexPolar) : Bool { 
+    function ComplexPolarEqual(x : ComplexPolar, y : ComplexPolar) : Bool {
         // Tests two complex polar numbers for equality.
-        AbsD(x::Magnitude - y::Magnitude) <= 0.001 and AbsD(x::Argument - y::Argument) <= 0.001
+        AbsD(x.Magnitude - y.Magnitude) <= 0.001 and AbsD(x.Argument - y.Argument) <= 0.001
     }
 }

katas/content/complex_arithmetic/cartesian_to_polar/Solution.qs

@@ -1,8 +1,8 @@
 namespace Kata {
     open Microsoft.Quantum.Math;
-    
+
     function ComplexToComplexPolar(x : Complex) : ComplexPolar {
-        let (a, b) = x!;
+        let (a, b) = (x.Real, x.Imag);
         return ComplexPolar(Sqrt(a * a + b * b), ArcTan2(b, a));
     }
 }

katas/content/complex_arithmetic/complex_addition/Placeholder.qs

@@ -1,10 +1,9 @@
-namespace Kata {    
+namespace Kata {
     open Microsoft.Quantum.Math;
-    
-    function ComplexAdd(x : Complex, y : Complex) : Complex {    
+
+    function ComplexAdd(x : Complex, y : Complex) : Complex {
         // Extract real and imaginary components of the inputs.
-        let (a, b) = x!;
-        let (c, d) = (y::Real, y::Imag);
+        let (a, b) = (y.Real, y.Imag);
         // Implement your solution here...
         return Complex(0., 0.);
     }

katas/content/complex_arithmetic/complex_addition/Solution.qs

@@ -1,9 +1,7 @@
-namespace Kata {    
+namespace Kata {
     open Microsoft.Quantum.Math;
-
-    function ComplexAdd(x : Complex, y: Complex) : Complex {        
-        let (a, b) = x!;
-        let (c, d) = y!;
-        return Complex(a + c, b + d);
+
+    function ComplexAdd(x : Complex, y : Complex) : Complex {
+        Complex(x.Real + y.Real, x.Imag + y.Imag)
     }
 }

katas/content/complex_arithmetic/complex_conjugate/Placeholder.qs

@@ -1,7 +1,7 @@
-namespace Kata {    
+namespace Kata {
     open Microsoft.Quantum.Math;
-    
-    function ComplexConjugate(x : Complex) : Complex {        
+
+    function ComplexConjugate(x : Complex) : Complex {
         // Implement your solution here...
         return Complex(0., 0.);
     }

katas/content/complex_arithmetic/complex_conjugate/Solution.qs

@@ -1,7 +1,7 @@
-namespace Kata {    
-    open Microsoft.Quantum.Math;    
+namespace Kata {
+    open Microsoft.Quantum.Math;
 
     operation ComplexConjugate(x : Complex) : Complex {
-        return Complex(x::Real, -x::Imag);
+        Complex(x.Real, -x.Imag)
     }
 }

katas/content/complex_arithmetic/complex_conjugate/Verification.qs

@@ -2,18 +2,18 @@ namespace Kata.Verification {
     open Microsoft.Quantum.Math;
 
     function ComplexConjugate_Reference(x : Complex) : Complex {
-        // Return the complex conjugate  
-        Complex(x::Real, -x::Imag)
-    }    
+        // Return the complex conjugate
+        Complex(x.Real, -x.Imag)
+    }
 
     @EntryPoint()
-    operation CheckSolution() : Bool {        
-        for _ in 0 .. 24 {
+    operation CheckSolution() : Bool {
+        for _ in 0..24 {
             let x = DrawRandomComplex();
 
             let expected = ComplexConjugate_Reference(x);
             let actual = Kata.ComplexConjugate(x);
-        
+
             if not ComplexEqual(expected, actual) {
                 Message("Incorrect");
                 Message($"For x = {ComplexAsString(x)} expected return {ComplexAsString(expected)}, actual return {ComplexAsString(actual)}.");
@@ -24,4 +24,4 @@ namespace Kata.Verification {
         Message("Correct!");
         return true;
     }
-}
+}

katas/content/complex_arithmetic/complex_division/Placeholder.qs

@@ -1,6 +1,6 @@
 namespace Kata {
-    open Microsoft.Quantum.Math;    
-    
+    open Microsoft.Quantum.Math;
+
     function ComplexDiv(x : Complex, y : Complex) : Complex {
         // Implement your solution here...
         return Complex(0., 0.);

katas/content/complex_arithmetic/complex_division/Solution.qs

@@ -1,12 +1,12 @@
-namespace Kata {    
+namespace Kata {
     open Microsoft.Quantum.Math;
-    
-    function ComplexDiv(x : Complex, y: Complex) : Complex {
-        let (a, b) = x!;
-        let (c, d) = y!;
+
+    function ComplexDiv(x : Complex, y : Complex) : Complex {
+        let (a, b) = (x.Real, x.Imag);
+        let (c, d) = (y.Real, y.Imag);
         let denominator = c * c + d * d;
         let real = (a * c + b * d) / denominator;
         let imag = (- a * d + b * c) / denominator;
         return Complex(real, imag);
     }
-}
+}

katas/content/complex_arithmetic/complex_exponents/Placeholder.qs

@@ -1,8 +1,8 @@
 namespace Kata {
     open Microsoft.Quantum.Math;
-    
+
     function ComplexExponent(x : Complex) : Complex {
         // Implement your solution here...
-        return Complex(0.0, 0.0);
+        return Complex(0., 0.);
     }
 }

katas/content/complex_arithmetic/complex_exponents/Solution.qs

@@ -1,8 +1,7 @@
-namespace Kata { 
+namespace Kata {
     open Microsoft.Quantum.Math;
 
-    function ComplexExponent (x : Complex) : Complex {
-        let (a, b) = x!;
-        return Complex(E()^a * Cos(b), E()^a * Sin(b));
+    function ComplexExponent(x : Complex) : Complex {
+        Complex(E()^x.Real * Cos(x.Imag), E()^x.Real * Sin(x.Imag))
     }
 }

katas/content/complex_arithmetic/complex_exponents/Verification.qs

@@ -1,20 +1,20 @@
 namespace Kata.Verification {
     open Microsoft.Quantum.Math;
-    open Microsoft.Quantum.Random;    
-    
+    open Microsoft.Quantum.Random;
+
     function ComplexExponent_Reference(x : Complex) : Complex {
-        let expa = E() ^ x::Real;
-        return Complex(expa * Cos(x::Imag), expa * Sin(x::Imag));
+        let expa = E()^x.Real;
+        return Complex(expa * Cos(x.Imag), expa * Sin(x.Imag));
     }
 
     @EntryPoint()
     operation CheckSolution() : Bool {
-        for _ in 0 .. 24 {
+        for _ in 0..24 {
             let x = DrawRandomComplex();
 
             let expected = ComplexExponent_Reference(x);
             let actual = Kata.ComplexExponent(x);
-        
+
             if not ComplexEqual(expected, actual) {
                 Message("Incorrect");
                 Message($"For x = {ComplexAsString(x)} expected return {ComplexAsString(expected)}, actual return {ComplexAsString(actual)}.");

katas/content/complex_arithmetic/complex_modulus/Solution.qs

@@ -1,8 +1,8 @@
-namespace Kata { 
+namespace Kata {
     open Microsoft.Quantum.Math;
 
     function ComplexModulus(x : Complex) : Double {
-        let (a, b) = x!;
+        let (a, b) = (x.Real, x.Imag);
         return Sqrt(a * a + b * b);
     }
 }

katas/content/complex_arithmetic/complex_multiplication/Placeholder.qs

@@ -1,7 +1,7 @@
 namespace Kata {
     open Microsoft.Quantum.Math;
-    
-    function ComplexMult(x : Complex, y: Complex) : Complex {
+
+    function ComplexMult(x : Complex, y : Complex) : Complex {
         // Implement your solution here...
         return Complex(0., 0.);
     }

katas/content/complex_arithmetic/complex_multiplication/Solution.qs

@@ -1,9 +1,9 @@
-namespace Kata {    
+namespace Kata {
     open Microsoft.Quantum.Math;
-    
-    function ComplexMult(x : Complex, y: Complex) : Complex {
-        let (a, b) = x!;
-        let (c, d) = y!;
+
+    function ComplexMult(x : Complex, y : Complex) : Complex {
+        let (a, b) = (x.Real, x.Imag);
+        let (c, d) = (y.Real, y.Imag);
         return Complex(a * c - b * d, a * d + b * c);
     }
 }

katas/content/complex_arithmetic/complex_powers_real/Solution.qs

@@ -1,14 +1,13 @@
-namespace Kata { 
+namespace Kata {
     open Microsoft.Quantum.Math;
 
     function ComplexExpReal(r : Double, x : Complex) : Complex {
         if AbsD(r) < 1e-9 {
-            return Complex(0.0, 0.0);
+            return Complex(0., 0.);
         }
-
-        let (a, b) = x!;        
-        let ra = r ^ a;
+
+        let ra = r^x.Real;
         let lnr = Log(r);
-        return Complex(ra * Cos(b * lnr), ra * Sin(b * lnr));
+        return Complex(ra * Cos(x.Imag * lnr), ra * Sin(x.Imag * lnr));
     }
 }

katas/content/complex_arithmetic/complex_powers_real/Verification.qs

@@ -1,33 +1,33 @@
 namespace Kata.Verification {
     open Microsoft.Quantum.Math;
-    open Microsoft.Quantum.Random;    
-    
+    open Microsoft.Quantum.Random;
+
     function ComplexExpReal_Reference(r : Double, x : Complex) : Complex {
         if AbsD(r) < 1e-9 {
-            return Complex(0.0, 0.0);
+            return Complex(0., 0.);
         }
-        let real = r ^ x::Real * Cos(x::Imag * Log(r));
-        let imaginary = r ^ x::Real * Sin(x::Imag * Log(r));
+        let real = r^x.Real * Cos(x.Imag * Log(r));
+        let imaginary = r^x.Real * Sin(x.Imag * Log(r));
         return Complex(real, imaginary);
     }
 
     @EntryPoint()
     operation CheckSolution() : Bool {
-        for ind in 0 .. 24 {
+        for ind in 0..24 {
             let x = DrawRandomComplex();
-            let r = ind == 0 ? 0.0 | DrawRandomDouble(0., 10.); 
+            let r = ind == 0 ? 0.0 | DrawRandomDouble(0., 10.);
+
+            let expected = ComplexExpReal_Reference(r, x);
+            let actual = Kata.ComplexExpReal(r, x);
 
-            let expected = ComplexExpReal_Reference(r, x); 
-            let actual = Kata.ComplexExpReal(r, x);        
-
             if not ComplexEqual(expected, actual) {
                 Message("Incorrect");
                 Message($"For x = {ComplexAsString(x)} and r = {r} expected return {ComplexAsString(expected)}, actual return {ComplexAsString(actual)}.");
                 return false;
-            }                
-        }            
+            }
+        }
 
         Message("Correct!");
-        return true;        
+        return true;
     }
 }