perf: avoid using alt when parsing Program

Signed-off-by: ljedrz <[email protected]>

console/network/environment/src/lib.rs

@@ -126,8 +126,10 @@ pub mod prelude {
         bytes::{complete::tag, streaming::take},
         character::complete::{alpha1, alphanumeric1, char, one_of},
         combinator::{complete, fail, map, map_res, opt, recognize},
+        error::{make_error, ErrorKind},
         multi::{count, many0, many0_count, many1, separated_list0, separated_list1},
         sequence::{pair, terminated},
+        Err,
     };
     pub use num_traits::{AsPrimitive, One, Pow, Zero};
     pub use rand::{

console/program/src/data_types/record_type/parse.rs

@@ -45,8 +45,6 @@ impl<N: Network> Parser for RecordType<N> {
             Ok((string, (identifier, value_type)))
         }
 
-        // Parse the whitespace and comments from the string.
-        let (string, _) = Sanitizer::parse(string)?;
         // Parse the type name from the string.
         let (string, _) = tag(Self::type_name())(string)?;
         // Parse the whitespace from the string.

console/program/src/data_types/struct_type/parse.rs

@@ -45,8 +45,6 @@ impl<N: Network> Parser for StructType<N> {
             Ok((string, (identifier, plaintext_type)))
         }
 
-        // Parse the whitespace and comments from the string.
-        let (string, _) = Sanitizer::parse(string)?;
         // Parse the type name from the string.
         let (string, _) = tag(Self::type_name())(string)?;
         // Parse the whitespace from the string.

synthesizer/program/src/closure/parse.rs

@@ -18,8 +18,6 @@ impl<N: Network, Instruction: InstructionTrait<N>> Parser for ClosureCore<N, Ins
     /// Parses a string into a closure.
     #[inline]
     fn parse(string: &str) -> ParserResult<Self> {
-        // Parse the whitespace and comments from the string.
-        let (string, _) = Sanitizer::parse(string)?;
         // Parse the 'closure' keyword from the string.
         let (string, _) = tag(Self::type_name())(string)?;
         // Parse the whitespace from the string.

synthesizer/program/src/function/parse.rs

@@ -20,8 +20,6 @@ impl<N: Network, Instruction: InstructionTrait<N>, Command: CommandTrait<N>> Par
     /// Parses a string into a function.
     #[inline]
     fn parse(string: &str) -> ParserResult<Self> {
-        // Parse the whitespace and comments from the string.
-        let (string, _) = Sanitizer::parse(string)?;
         // Parse the 'function' keyword from the string.
         let (string, _) = tag(Self::type_name())(string)?;
         // Parse the whitespace from the string.

synthesizer/program/src/lib.rs

@@ -48,13 +48,13 @@ mod serialize;
 
 use console::{
     network::prelude::{
-        alt,
         anyhow,
         bail,
         de,
         ensure,
         error,
         fmt,
+        make_error,
         many0,
         many1,
         map,
@@ -65,7 +65,9 @@ use console::{
         Deserialize,
         Deserializer,
         Display,
+        Err,
         Error,
+        ErrorKind,
         Formatter,
         FromBytes,
         FromBytesDeserializer,

synthesizer/program/src/mapping/parse.rs

@@ -18,8 +18,6 @@ impl<N: Network> Parser for Mapping<N> {
     /// Parses a string into a mapping.
     #[inline]
     fn parse(string: &str) -> ParserResult<Self> {
-        // Parse the whitespace and comments from the string.
-        let (string, _) = Sanitizer::parse(string)?;
         // Parse the 'mapping' keyword from the string.
         let (string, _) = tag(Self::type_name())(string)?;
         // Parse the whitespace from the string.

synthesizer/program/src/parse.rs

@@ -44,14 +44,29 @@ impl<N: Network, Instruction: InstructionTrait<N>, Command: CommandTrait<N>> Par
         // Parse the semicolon ';' keyword from the string.
         let (string, _) = tag(";")(string)?;
 
+        fn intermediate<N: Network, Instruction: InstructionTrait<N>, Command: CommandTrait<N>>(
+            string: &str,
+        ) -> ParserResult<P<N, Instruction, Command>> {
+            // Parse the whitespace and comments from the string.
+            let (string, _) = Sanitizer::parse(string)?;
+
+            if string.starts_with(Mapping::<N>::type_name()) {
+                map(Mapping::parse, |mapping| P::<N, Instruction, Command>::M(mapping))(string)
+            } else if string.starts_with(StructType::<N>::type_name()) {
+                map(StructType::parse, |struct_| P::<N, Instruction, Command>::I(struct_))(string)
+            } else if string.starts_with(RecordType::<N>::type_name()) {
+                map(RecordType::parse, |record| P::<N, Instruction, Command>::R(record))(string)
+            } else if string.starts_with(ClosureCore::<N, Instruction>::type_name()) {
+                map(ClosureCore::parse, |closure| P::<N, Instruction, Command>::C(closure))(string)
+            } else if string.starts_with(FunctionCore::<N, Instruction, Command>::type_name()) {
+                map(FunctionCore::parse, |function| P::<N, Instruction, Command>::F(function))(string)
+            } else {
+                Err(Err::Error(make_error(string, ErrorKind::Alt)))
+            }
+        }
+
         // Parse the struct or function from the string.
-        let (string, components) = many1(alt((
-            map(Mapping::parse, |mapping| P::<N, Instruction, Command>::M(mapping)),
-            map(StructType::parse, |struct_| P::<N, Instruction, Command>::I(struct_)),
-            map(RecordType::parse, |record| P::<N, Instruction, Command>::R(record)),
-            map(ClosureCore::parse, |closure| P::<N, Instruction, Command>::C(closure)),
-            map(FunctionCore::parse, |function| P::<N, Instruction, Command>::F(function)),
-        )))(string)?;
+        let (string, components) = many1(intermediate)(string)?;
         // Parse the whitespace and comments from the string.
         let (string, _) = Sanitizer::parse(string)?;