From 82754c1766650d762d5c785e89272b6bc7d5362a Mon Sep 17 00:00:00 2001
From: Phil Nash <github@philnash.me>
Date: Fri, 12 Dec 2014 08:29:21 +0000
Subject: [PATCH] tweaked formatting

---
 docs/tostring.md | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/docs/tostring.md b/docs/tostring.md
index b9766494..ab2a1377 100644
--- a/docs/tostring.md
+++ b/docs/tostring.md
@@ -7,10 +7,12 @@ Most built-in or std types are supported out of the box but there are two ways t
 
 This is the standard way of providing string conversions in C++ - and the chances are you may already provide this for your own purposes. If you're not familiar with this idiom it involves writing a free function of the form:
 
-```std::ostream& operator << ( std::ostream& os, T const& value ) {
+```
+std::ostream& operator << ( std::ostream& os, T const& value ) {
 	os << convertMyTypeToString( value );
 	return os;
-}```
+}
+```
 
 (where ```T``` is your type and ```convertMyTypeToString``` is where you'll write whatever code is necessary to make your type printable - it doesn't have to be in another function).
 
@@ -18,21 +20,25 @@ You should put this function in the same namespace as your type.
 
 Alternatively you may prefer to write it as a member function:
 
-```std::ostream& T::operator << ( std::ostream& os ) const {
+```
+std::ostream& T::operator << ( std::ostream& os ) const {
 	os << convertMyTypeToString( *this );
 	return os;
-}```
+}
+```
 
 ## Catch::toString overload
 
 If you don't want to provide an ```operator <<``` overload, or you want to convert your type differently for testing purposes, you can provide an overload for ```Catch::toString()``` for your type.
 
-```namespace Catch {
+```
+namespace Catch {
 	std::string toString( T const& value ) {
 		return convertMyTypeToString( value );
 	}
 }
-}```
+}
+```
 
 Again ```T``` is your type and ```convertMyTypeToString``` is where you'll write whatever code is necessary to make your type printable. Note that the function must be in the Catch namespace, which itself must be in the global namespace.