Remove unnecessary is_first field

Now that the buffers are owned and therefore guaranteed to be non-empty
on creation.

src/ref_serializer.rs

@@ -53,10 +53,8 @@ impl<T: BufferHolder> RefParameterSerializer<T> {
     }
 }
 
-fn write_separator(buffer: &mut String, is_first: &mut bool) {
-    if *is_first {
-        *is_first = false;
-    } else {
+fn write_separator(buffer: &mut String) {
+    if !buffer.is_empty() {
         buffer.push_str(", ");
     }
 }
@@ -90,39 +88,37 @@ fn write_separator(buffer: &mut String, is_first: &mut bool) {
 #[derive(Debug)]
 pub struct RefListSerializer {
     buffer: String,
-    is_first: bool,
 }
 
 impl RefListSerializer {
     pub fn new() -> Self {
         RefListSerializer {
             buffer: String::new(),
-            is_first: true,
         }
     }
 
     pub fn bare_item(mut self, bare_item: impl AsRefBareItem) -> SFVResult<Self> {
-        write_separator(&mut self.buffer, &mut self.is_first);
+        write_separator(&mut self.buffer);
         Serializer::serialize_bare_item(bare_item, &mut self.buffer)?;
         Ok(self)
     }
 
     pub fn parameter(mut self, name: &str, value: impl AsRefBareItem) -> SFVResult<Self> {
-        if self.is_first {
+        if self.buffer.is_empty() {
             return Err("parameters must be serialized after bare item or inner list");
         }
         Serializer::serialize_parameter(name, value, &mut self.buffer)?;
         Ok(self)
     }
 
     pub fn open_inner_list(mut self) -> RefInnerListSerializer<Self> {
-        write_separator(&mut self.buffer, &mut self.is_first);
+        write_separator(&mut self.buffer);
         self.buffer.push('(');
         RefInnerListSerializer { buffer: self }
     }
 
     pub fn finish(self) -> SFVResult<String> {
-        if self.is_first {
+        if self.buffer.is_empty() {
             return Err("serializing empty list is not allowed");
         }
         Ok(self.buffer)
@@ -164,19 +160,17 @@ impl RefListSerializer {
 #[derive(Debug)]
 pub struct RefDictSerializer {
     buffer: String,
-    is_first: bool,
 }
 
 impl RefDictSerializer {
     pub fn new() -> Self {
         RefDictSerializer {
             buffer: String::new(),
-            is_first: true,
         }
     }
 
     pub fn bare_item_member(mut self, name: &str, value: impl AsRefBareItem) -> SFVResult<Self> {
-        write_separator(&mut self.buffer, &mut self.is_first);
+        write_separator(&mut self.buffer);
         Serializer::serialize_key(name, &mut self.buffer)?;
         let value = value.as_ref_bare_item();
         if value != RefBareItem::Boolean(true) {
@@ -187,22 +181,22 @@ impl RefDictSerializer {
     }
 
     pub fn parameter(mut self, name: &str, value: impl AsRefBareItem) -> SFVResult<Self> {
-        if self.is_first {
+        if self.buffer.is_empty() {
             return Err("parameters must be serialized after bare item or inner list");
         }
         Serializer::serialize_parameter(name, value, &mut self.buffer)?;
         Ok(self)
     }
 
     pub fn open_inner_list(mut self, name: &str) -> SFVResult<RefInnerListSerializer<Self>> {
-        write_separator(&mut self.buffer, &mut self.is_first);
+        write_separator(&mut self.buffer);
         Serializer::serialize_key(name, &mut self.buffer)?;
         self.buffer.push_str("=(");
         Ok(RefInnerListSerializer { buffer: self })
     }
 
     pub fn finish(self) -> SFVResult<String> {
-        if self.is_first {
+        if self.buffer.is_empty() {
             return Err("serializing empty dictionary is not allowed");
         }
         Ok(self.buffer)