diff --git a/docs/tls13-early-data.md b/docs/tls13-early-data.md
index be05743..28a8cc6 100644
--- a/docs/tls13-early-data.md
+++ b/docs/tls13-early-data.md
@@ -6,29 +6,28 @@
 TLS may plausibly look like:
 
 ```
-int write_data( mbedtls_ssl_context *ssl,
-                const unsigned char *data_to_write,
-                size_t data_to_write_len,
-                size_t *data_written )
+int write_data(mbedtls_ssl_context *ssl,
+               const unsigned char *data_to_write,
+               size_t data_to_write_len,
+               size_t *data_written)
 {
+    int ret;
     *data_written = 0;
 
-    while( *data_written < data_to_write_len )
-    {
-        ret = mbedtls_ssl_write( ssl, data_to_write + *data_written,
-                                 data_to_write_len - *data_written );
+    while (*data_written < data_to_write_len) {
+        ret = mbedtls_ssl_write(ssl, data_to_write + *data_written,
+                                data_to_write_len - *data_written);
 
-        if( ret < 0 &&
+        if (ret < 0 &&
             ret != MBEDTLS_ERR_SSL_WANT_READ &&
-            ret != MBEDTLS_ERR_SSL_WANT_WRITE )
-        {
-            return( ret );
+            ret != MBEDTLS_ERR_SSL_WANT_WRITE) {
+            return ret;
         }
 
         *data_written += ret;
     }
 
-    return( 0 );
+    return 0;
 }
 ```
 where ssl is the SSL context to use, data_to_write the address of the data
@@ -36,7 +35,7 @@
 not be completed, not even started for the SSL context ssl when the function is
 called and in that case the mbedtls_ssl_write() API takes care transparently of
 completing the handshake before to write and send data to the server. The
-mbedtls_ssl_write() may not been able to write and send all data in one go thus
+mbedtls_ssl_write() may not be able to write and send all data in one go thus
 the need for a loop calling it as long as there are still data to write and
 send.
 
@@ -45,29 +44,28 @@
 its initial phase, would look completely similar but the call to
 mbedtls_ssl_write_early_data() instead of mbedtls_ssl_write().
 ```
-int write_early_data( mbedtls_ssl_context *ssl,
-                      const unsigned char *data_to_write,
-                      size_t data_to_write_len,
-                      size_t *data_written )
+int write_early_data(mbedtls_ssl_context *ssl,
+                     const unsigned char *data_to_write,
+                     size_t data_to_write_len,
+                     size_t *data_written)
 {
+    int ret;
     *data_written = 0;
 
-    while( *data_written < data_to_write_len )
-    {
-        ret = mbedtls_ssl_write_early_data( ssl, data_to_write + *data_written,
-                                            data_to_write_len - *data_written );
+    while (*data_written < data_to_write_len) {
+        ret = mbedtls_ssl_write_early_data(ssl, data_to_write + *data_written,
+                                           data_to_write_len - *data_written);
 
-        if( ret < 0 &&
+        if (ret < 0 &&
             ret != MBEDTLS_ERR_SSL_WANT_READ &&
-            ret != MBEDTLS_ERR_SSL_WANT_WRITE )
-        {
-            return( ret );
+            ret != MBEDTLS_ERR_SSL_WANT_WRITE) {
+            return ret;
         }
 
         *data_written += ret;
     }
 
-    return( 0 );
+    return 0;
 }
 ```
 Note that compared to write_data(), write_early_data() can also return
@@ -81,18 +79,22 @@
 plausibly look like:
 
 ```
-ret = write_early_data( ssl, data_to_write, data_to_write_len,
-                        &early_data_written );
-if( ret < 0 &&
-    ret != MBEDTLS_ERR_SSL_CANNOT_WRITE_EARLY_DATA )
-{
+ret = write_early_data(ssl,
+                       data_to_write,
+                       data_to_write_len,
+                       &early_data_written);
+if (ret < 0 &&
+    ret != MBEDTLS_ERR_SSL_CANNOT_WRITE_EARLY_DATA) {
     goto error;
 }
 
-ret = write_data( ssl, data_to_write + early_data_written,
-                  data_to_write_len - early_data_written, &data_written );
-if( ret < 0 )
+ret = write_data(ssl,
+                 data_to_write + early_data_written,
+                 data_to_write_len - early_data_written,
+                 &data_written);
+if (ret < 0) {
     goto error;
+}
 
 data_written += early_data_written;
 ```
@@ -100,40 +102,44 @@
 Finally, taking into account that the server may reject early data, application
 code to write and send a buffer of data could plausibly look like:
 ```
-ret = write_early_data( ssl, data_to_write, data_to_write_len,
-                        &early_data_written );
-if( ret < 0 &&
-    ret != MBEDTLS_ERR_SSL_CANNOT_WRITE_EARLY_DATA )
-{
+ret = write_early_data(ssl,
+                       data_to_write,
+                       data_to_write_len,
+                       &early_data_written);
+if (ret < 0 &&
+    ret != MBEDTLS_ERR_SSL_CANNOT_WRITE_EARLY_DATA) {
     goto error;
 }
 
 /*
- * Make sure the handshake is completed as it is a requisite to
+ * Make sure the handshake is completed as it is a requisite of
  * mbedtls_ssl_get_early_data_status().
  */
-while( !mbedtls_ssl_is_handshake_over( ssl ) )
-{
-    ret = mbedtls_ssl_handshake( ssl );
-    if( ret < 0 &&
+while (!mbedtls_ssl_is_handshake_over(ssl)) {
+    ret = mbedtls_ssl_handshake(ssl);
+    if (ret < 0 &&
         ret != MBEDTLS_ERR_SSL_WANT_READ &&
-        ret != MBEDTLS_ERR_SSL_WANT_WRITE )
-    {
+        ret != MBEDTLS_ERR_SSL_WANT_WRITE) {
         goto error;
     }
 }
 
-ret = mbedtls_ssl_get_early_data_status( ssl );
-if( ret < 0 )
+ret = mbedtls_ssl_get_early_data_status(ssl);
+if (ret < 0) {
     goto error;
+}
 
-if( ret == MBEDTLS_SSL_EARLY_DATA_STATUS_REJECTED )
+if (ret == MBEDTLS_SSL_EARLY_DATA_STATUS_REJECTED) {
    early_data_written = 0;
+}
 
-ret = write_data( ssl, data_to_write + early_data_written,
-                  data_to_write_len - early_data_written, &data_written );
-if( ret < 0 )
+ret = write_data(ssl,
+                 data_to_write + early_data_written,
+                 data_to_write_len - early_data_written,
+                 &data_written);
+if (ret < 0) {
     goto error;
+}
 
 data_written += early_data_written;
 ```