Simplified Peano-based Nop generator by just using const expressions.

This change was able to be done after the release of
Rust Nightly 2022-08-12 that fixed
rust-lang/rust#84669.

Author: devcexx

README.md

@@ -5,11 +5,11 @@ Rust.
 
 This project was done for fun as a part of a Rust learning process. It
 uses extremely unstable features from the nigthly compiler, such as
-`const_generic_exprs`, or `specialization` because it is more
-entertaining and useful for me to using them than not doing so. This
-library may be used as long as you keep that in mind.
+`const_generic_exprs` because it is more entertaining and useful for
+me to using them than not doing so. This library may be used as long
+as you keep that in mind.
 
-Tested on Rust nightly 2022-07-03.
+Tested on Rust nightly 2022-08-12 (Minimum version required).
 
 ## Usage
 

rust-toolchain.toml

@@ -1,4 +1,4 @@
 [toolchain]
-channel = "nightly-2022-07-10"
+channel = "nightly-2022-08-12"
 components = ["rust-src"]
 profile = "minimal"

ws2812-avr/src/lib.rs

@@ -22,7 +22,6 @@ along with ws2812-avr. If not, see <https://www.gnu.org/licenses/>.
 #![feature(generic_const_exprs)]
 #![feature(never_type)]
 #![feature(const_mut_refs)]
-#![feature(specialization)]
 #![feature(adt_const_params)]
 #![feature(const_trait_impl)]
 #![feature(const_slice_index)]
@@ -38,7 +37,7 @@ use core::marker::PhantomData;
 use core::mem::size_of;
 use ports::{StaticPin, StaticPort};
 use util::time::TimeVal;
-use util::{time, IntoNopPeano, NopGen, Num};
+use util::{time, NopBlock, NopGen};
 
 mod consts {
     use arduino_hal::{clock::Clock, DefaultClock};
@@ -220,13 +219,13 @@ impl<Ts: Timings> CalculatedTimings for Ts {
 
 impl<Ts: Timings> TypedTimings for Ts
 where
-    Num<{ Ts::S1_NOPS }>: IntoNopPeano,
-    Num<{ Ts::S2_NOPS }>: IntoNopPeano,
-    Num<{ Ts::S3_NOPS }>: IntoNopPeano,
+    NopBlock<{ Ts::S1_NOPS }>: NopGen,
+    NopBlock<{ Ts::S2_NOPS }>: NopGen,
+    NopBlock<{ Ts::S3_NOPS }>: NopGen,
 {
-    type S1Nops = <Num<{ Ts::S1_NOPS }> as IntoNopPeano>::Peano;
-    type S2Nops = <Num<{ Ts::S2_NOPS }> as IntoNopPeano>::Peano;
-    type S3Nops = <Num<{ Ts::S3_NOPS }> as IntoNopPeano>::Peano;
+    type S1Nops = NopBlock<{ Ts::S1_NOPS }>;
+    type S2Nops = NopBlock<{ Ts::S2_NOPS }>;
+    type S3Nops = NopBlock<{ Ts::S3_NOPS }>;
 }
 
 /**

ws2812-avr/src/util/nop_block.rs

@@ -14,21 +14,10 @@ General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with ws2812-avr. If not, see <https://www.gnu.org/licenses/>.
  */
-use core::{arch::asm, marker::PhantomData};
-
-// This file allows to generate block of NOP instructions based on the
-// value of a const generic type. It is done by using a simple
-// implementation of Peano numbers, for being able to count how many
-// NOPs should be generated using type recursion. Then, the
-// "IntoNopPeano" trait is provided along with the "Num" struct that
-// allows to convert between common numbers and Peano ones.
-
-// This could have been done using const expressions and const
-// generics directly, but due to an opened in the Rust compiler it was
-// giving me a lot of headaches to actually make this to be able to
-// link successfully, so this is just a workaround for that issue:
-// https://github.com/rust-lang/rust/issues/84669.
+use core::arch::asm;
 
+// This code requires Rust Nightly 2022-08-12 to compile because of
+// https://github.com/rust-lang/rust/issues/84669
 pub trait IsTrue {}
 pub struct BExpr<const B: bool> {}
 impl IsTrue for BExpr<true> {}
@@ -37,54 +26,26 @@ pub trait NopGen {
     fn gen();
 }
 
-pub struct Num<const V: u8> {}
-pub struct Zero {}
-pub struct Succ<N> {
-    _n: PhantomData<N>,
-}
-
-// This trait is specialized on returning Peano numbers that are
-// verified that return instances that can generate NOP blocks,
-// instead of using a generic definition, because some issues I've
-// encountered while trying to apply this type restriction in other
-// places in the code.
-pub trait IntoNopPeano {
-    type Peano: NopGen;
-}
-
-impl IntoNopPeano for Num<0> {
-    type Peano = Zero;
-}
-
-impl<const X: u8> IntoNopPeano for Num<X>
-where
-    BExpr<{ X > 0 }>: IsTrue,
-    Num<{ X - 1 }>: IntoNopPeano,
-{
-    type Peano = Succ<<Num<{ X - 1 }> as IntoNopPeano>::Peano>;
-}
+pub struct NopBlock<const SIZE: u8> {}
 
-impl NopGen for Zero {
+impl NopGen for NopBlock<0> {
+    #[inline(always)]
     fn gen() {}
 }
 
-impl<X> NopGen for Succ<X>
-where
-    X: NopGen,
-{
+impl NopGen for NopBlock<1> {
     #[inline(always)]
-    default fn gen() {
+    fn gen() {
         unsafe {
             asm!("nop");
         }
-
-        <X as NopGen>::gen();
     }
 }
 
-impl<X> NopGen for Succ<Succ<X>>
+impl<const N: u8> NopGen for NopBlock<N>
 where
-    X: NopGen,
+    BExpr<{ N > 1 }>: IsTrue,
+    NopBlock<{ N - 1 }>: NopGen,
 {
     #[inline(always)]
     fn gen() {
@@ -97,6 +58,6 @@ where
             asm!("rjmp +0");
         }
 
-        <X as NopGen>::gen();
+        <NopBlock<{ N - 1 }> as NopGen>::gen();
     }
 }