[Perf] Reduce allocs when parsing Program

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,58 +44,70 @@ 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)?;
 
-        // Return the program.
-        map_res(take(0usize), move |_| {
-            // Initialize a new program.
-            let mut program = match ProgramCore::<N, Instruction, Command>::new(id) {
-                Ok(program) => program,
+        // Initialize a new program.
+        let mut program = match ProgramCore::<N, Instruction, Command>::new(id) {
+            Ok(program) => program,
+            Err(error) => {
+                eprintln!("{error}");
+                return map_res(take(0usize), move |error| Err(error))(string);
+            }
+        };
+        // Construct the program with the parsed components.
+        for component in components {
+            let result = match component {
+                P::M(mapping) => program.add_mapping(mapping),
+                P::I(struct_) => program.add_struct(struct_),
+                P::R(record) => program.add_record(record),
+                P::C(closure) => program.add_closure(closure),
+                P::F(function) => program.add_function(function),
+            };
+
+            match result {
+                Ok(_) => (),
                 Err(error) => {
                     eprintln!("{error}");
-                    return Err(error);
-                }
-            };
-            // Construct the program with the parsed components.
-            for component in components.iter() {
-                let result = match component {
-                    P::M(mapping) => program.add_mapping(mapping.clone()),
-                    P::I(struct_) => program.add_struct(struct_.clone()),
-                    P::R(record) => program.add_record(record.clone()),
-                    P::C(closure) => program.add_closure(closure.clone()),
-                    P::F(function) => program.add_function(function.clone()),
-                };
-
-                match result {
-                    Ok(_) => (),
-                    Err(error) => {
-                        eprintln!("{error}");
-                        return Err(error);
-                    }
+                    return map_res(take(0usize), move |error| Err(error))(string);
                 }
             }
-            // Lastly, add the imports (if any) to the program.
-            for import in imports.iter() {
-                match program.add_import(import.clone()) {
-                    Ok(_) => (),
-                    Err(error) => {
-                        eprintln!("{error}");
-                        return Err(error);
-                    }
+        }
+        // Lastly, add the imports (if any) to the program.
+        for import in imports {
+            match program.add_import(import) {
+                Ok(_) => (),
+                Err(error) => {
+                    eprintln!("{error}");
+                    return map_res(take(0usize), move |error| Err(error))(string);
                 }
             }
-            // Output the program.
-            Ok::<_, Error>(program)
-        })(string)
+        }
+
+        Ok((string, program))
     }
 }