         func encode(_ value: Double) throws { try represent(value) }
 
         func encode(_ value: String) throws {
-            assertCanEncodeSingleValue()
+            assertCanEncodeNewValue()
             node = Node(value)
         }
 
         func encode<T>(_ value: T) throws where T : Encodable {
+            assertCanEncodeNewValue()
             if let date = value as? Date {
                 node = date.representedForCodable()
             } else if let representable = value as? ScalarRepresentable {

        // MARK: - SingleValueEncodingContainer Methods

        func encodeNil() throws {
            assertCanEncodeSingleValue()
            node = Node("null", Tag(.null))
        }


        /// `preconditionFailure()`s if one cannot be encoded.
        ///
        /// This is similar to assertCanRequestNewContainer above.
        fileprivate func assertCanEncodeNewValue() {
            precondition(
                canEncodeNewValue,
                "Attempt to encode value through single value container when previously value already encoded."
            )
        }

        /// Encode ScalarRepresentable
        func represent<T: ScalarRepresentable>(_ value: T) throws {
            assertCanEncodeNewValue()
            node = try Node(value)
        }
    }
