pairing: Separate associated types for MillerLoopResult and Gt

bellman/src/groth16/mod.rs

@@ -400,7 +400,7 @@ impl<E: Engine> Parameters<E> {
 
 pub struct PreparedVerifyingKey<E: Engine> {
     /// Pairing result of alpha*beta
-    alpha_g1_beta_g2: E::Fqk,
+    alpha_g1_beta_g2: E::Gt,
     /// -gamma in G2
     neg_gamma_g2: <E::G2Affine as PairingCurveAffine>::Prepared,
     /// -delta in G2

bellman/src/groth16/tests/dummy_engine.rs

@@ -335,9 +335,10 @@ impl Engine for DummyEngine {
     type G2Affine = Fr;
 
     // TODO: This should be F_645131 or something. Doesn't matter for now.
-    type Fqk = Fr;
+    type MillerLoopResult = Fr;
+    type Gt = Fr;
 
-    fn miller_loop<'a, I>(i: I) -> Self::Fqk
+    fn miller_loop<'a, I>(i: I) -> Self::MillerLoopResult
     where
         I: IntoIterator<
             Item = &'a (
@@ -358,7 +359,7 @@ impl Engine for DummyEngine {
     }
 
     /// Perform final exponentiation of the result of a miller loop.
-    fn final_exponentiation(this: &Self::Fqk) -> CtOption<Self::Fqk> {
+    fn final_exponentiation(this: &Self::MillerLoopResult) -> CtOption<Self::Gt> {
         CtOption::new(*this, Choice::from(1))
     }
 }

pairing/src/bls12_381/mod.rs

@@ -44,9 +44,10 @@ impl Engine for Bls12 {
     type G1Affine = G1Affine;
     type G2 = G2;
     type G2Affine = G2Affine;
-    type Fqk = Fq12;
+    type MillerLoopResult = Fq12;
+    type Gt = Fq12;
 
-    fn miller_loop<'a, I>(i: I) -> Self::Fqk
+    fn miller_loop<'a, I>(i: I) -> Self::MillerLoopResult
     where
         I: IntoIterator<
             Item = &'a (

pairing/src/lib.rs

@@ -42,7 +42,7 @@ pub trait Engine: ScalarEngine {
             Scalar = Self::Fr,
             Projective = Self::G1,
             Pair = Self::G2Affine,
-            PairingResult = Self::Fqk,
+            PairingResult = Self::Gt,
         > + From<Self::G1>
         + Mul<Self::Fr, Output = Self::G1>
         + for<'a> Mul<&'a Self::Fr, Output = Self::G1>;
@@ -60,16 +60,19 @@ pub trait Engine: ScalarEngine {
             Scalar = Self::Fr,
             Projective = Self::G2,
             Pair = Self::G1Affine,
-            PairingResult = Self::Fqk,
+            PairingResult = Self::Gt,
         > + From<Self::G2>
         + Mul<Self::Fr, Output = Self::G2>
         + for<'a> Mul<&'a Self::Fr, Output = Self::G2>;
 
+    /// The type returned by `Engine::miller_loop`.
+    type MillerLoopResult;
+
     /// The extension field that hosts the target group of the pairing.
-    type Fqk: Field;
+    type Gt: Field;
 
     /// Perform a miller loop with some number of (G1, G2) pairs.
-    fn miller_loop<'a, I>(i: I) -> Self::Fqk
+    fn miller_loop<'a, I>(i: I) -> Self::MillerLoopResult
     where
         I: IntoIterator<
             Item = &'a (
@@ -79,10 +82,10 @@ pub trait Engine: ScalarEngine {
         >;
 
     /// Perform final exponentiation of the result of a miller loop.
-    fn final_exponentiation(_: &Self::Fqk) -> CtOption<Self::Fqk>;
+    fn final_exponentiation(_: &Self::MillerLoopResult) -> CtOption<Self::Gt>;
 
     /// Performs a complete pairing operation `(p, q)`.
-    fn pairing<G1, G2>(p: G1, q: G2) -> Self::Fqk
+    fn pairing<G1, G2>(p: G1, q: G2) -> Self::Gt
     where
         G1: Into<Self::G1Affine>,
         G2: Into<Self::G2Affine>,

pairing/src/tests/engine.rs

@@ -30,12 +30,12 @@ pub fn engine_tests<E: Engine>() {
         let d = E::G2::random(&mut rng).to_affine().prepare();
 
         assert_eq!(
-            E::Fqk::one(),
+            E::Gt::one(),
             E::final_exponentiation(&E::miller_loop(&[(&z1, &b)])).unwrap()
         );
 
         assert_eq!(
-            E::Fqk::one(),
+            E::Gt::one(),
             E::final_exponentiation(&E::miller_loop(&[(&a, &z2)])).unwrap()
         );