diff --git a/bindings/rust/src/lib.rs b/bindings/rust/src/lib.rs
index 3cfa6edf..2652f450 100644
--- a/bindings/rust/src/lib.rs
+++ b/bindings/rust/src/lib.rs
@@ -95,11 +95,16 @@ impl blst_fp12 {
         if n_elems != p.len() || n_elems == 0 {
             panic!("inputs' lengths mismatch");
         }
-        let qs: [*const _; 2] = [&q[0], ptr::null()];
-        let ps: [*const _; 2] = [&p[0], ptr::null()];
+        let qs = [q.as_ptr(), ptr::null()];
+        let ps = [p.as_ptr(), ptr::null()];
         let mut out = MaybeUninit::<blst_fp12>::uninit();
         unsafe {
-            blst_miller_loop_n(out.as_mut_ptr(), &qs[0], &ps[0], n_elems);
+            blst_miller_loop_n(
+                out.as_mut_ptr(),
+                qs.as_ptr(),
+                ps.as_ptr(),
+                n_elems,
+            );
             out.assume_init()
         }
     }
@@ -121,12 +126,17 @@ impl blst_fp12 {
             .zip(q.par_chunks(stride).zip(p.par_chunks(stride)))
             .map(|(start_offset, (q, p))| {
                 let mut tmp = MaybeUninit::<blst_fp12>::uninit();
-                let qs: [*const _; 2] = [q.as_ptr(), ptr::null()];
-                let ps: [*const _; 2] = [p.as_ptr(), ptr::null()];
+                let qs = [q.as_ptr(), ptr::null()];
+                let ps = [p.as_ptr(), ptr::null()];
 
                 let n = core::cmp::min(n_elems - start_offset, stride);
                 unsafe {
-                    blst_miller_loop_n(tmp.as_mut_ptr(), &qs[0], &ps[0], n);
+                    blst_miller_loop_n(
+                        tmp.as_mut_ptr(),
+                        qs.as_ptr(),
+                        ps.as_ptr(),
+                        n,
+                    );
                     tmp.assume_init()
                 }
             })
diff --git a/bindings/rust/src/pippenger-no_std.rs b/bindings/rust/src/pippenger-no_std.rs
index a9a60579..1ef78af4 100644
--- a/bindings/rust/src/pippenger-no_std.rs
+++ b/bindings/rust/src/pippenger-no_std.rs
@@ -52,8 +52,10 @@ macro_rules! pippenger_mult_impl {
                     points: vec![Default::default(); npoints],
                 };
 
-                let p: [*const $point; 2] = [&points[0], ptr::null()];
-                unsafe { $to_affines(&mut ret.points[0], &p[0], npoints) };
+                let p = [points.as_ptr(), ptr::null()];
+                unsafe {
+                    $to_affines(ret.points.as_mut_ptr(), p.as_ptr(), npoints)
+                };
                 ret
             }
 
@@ -65,9 +67,8 @@ macro_rules! pippenger_mult_impl {
                     panic!("scalars length mismatch");
                 }
 
-                let p: [*const $point_affine; 2] =
-                    [&self.points[0], ptr::null()];
-                let s: [*const u8; 2] = [&scalars[0], ptr::null()];
+                let p = [self.points.as_ptr(), ptr::null()];
+                let s = [scalars.as_ptr(), ptr::null()];
 
                 let mut scratch =
                     vec![0u64; unsafe { $scratch_sizeof(npoints) } / 8];
@@ -75,11 +76,11 @@ macro_rules! pippenger_mult_impl {
                 unsafe {
                     $multi_scalar_mult(
                         &mut ret,
-                        &p[0],
+                        p.as_ptr(),
                         npoints,
-                        &s[0],
+                        s.as_ptr(),
                         nbits,
-                        &mut scratch[0],
+                        scratch.as_mut_ptr(),
                     );
                 }
                 ret
@@ -88,9 +89,9 @@ macro_rules! pippenger_mult_impl {
             pub fn add(&self) -> $point {
                 let npoints = self.points.len();
 
-                let p: [*const _; 2] = [&self.points[0], ptr::null()];
+                let p = [self.points.as_ptr(), ptr::null()];
                 let mut ret = <$point>::default();
-                unsafe { $add(&mut ret, &p[0], npoints) };
+                unsafe { $add(&mut ret, p.as_ptr(), npoints) };
 
                 ret
             }
diff --git a/bindings/rust/src/pippenger.rs b/bindings/rust/src/pippenger.rs
index b0dee5a3..eb7eccbc 100644
--- a/bindings/rust/src/pippenger.rs
+++ b/bindings/rust/src/pippenger.rs
@@ -205,11 +205,11 @@ macro_rules! pippenger_mult_impl {
                             unsafe {
                                 $tile_mult(
                                     grid[work].1.as_ptr(),
-                                    &p[0],
+                                    p.as_ptr(),
                                     grid[work].0.dx,
-                                    &s[0],
+                                    s.as_ptr(),
                                     nbits,
-                                    &mut scratch[0],
+                                    scratch.as_mut_ptr(),
                                     y,
                                     window,
                                 );
@@ -263,7 +263,7 @@ macro_rules! pippenger_mult_impl {
                 if ncpus < 2 || npoints < 384 {
                     let p = [self.points.as_ptr(), ptr::null()];
                     let mut ret = <$point>::default();
-                    unsafe { $add(&mut ret, &p[0], npoints) };
+                    unsafe { $add(&mut ret, p.as_ptr(), npoints) };
                     return ret;
                 }
 
@@ -292,7 +292,7 @@ macro_rules! pippenger_mult_impl {
                             }
                             unsafe {
                                 let mut t = MaybeUninit::<$point>::uninit();
-                                $add(t.as_mut_ptr(), &p[0], chunk);
+                                $add(t.as_mut_ptr(), p.as_ptr(), chunk);
                                 $add_or_double(&mut acc, &acc, t.as_ptr());
                             };
                             processed += 1;