[Add info on serialization to ch5
John Goerzen <jgoerzen@complete.org>**20070619075910] {
hunk ./en/ch05-typeclasses.xml 410
+
+    <sect2 id="hs.typeclasses.wellknown.serialization">
+      <title>Serialization with Read and Show</title>
+      <para>
+        Often times, you may have a data structure in memory that you need to
+        store on disk for later retrieval or send across the network.  The
+        process of converting data in memory to a flat series of bits for
+        storage is called <emphasis>serialization</emphasis>.
+      </para>
+      <para>
+        It turns out that &read; and &show; make excellent tools for
+        serialization.  &show; produces output that is both human-readable and
+        machine-readable.  It also mostly matches Haskell syntax.
+      </para>
+      <para>
+        Let's try it out in &ghci;:
+      </para>
+      &serialization.ghci:ex1;
+      <para>
+        First, we assign <literal>d1</literal> to be a list.  Next, we print
+        out the result of <literal>show d1</literal> so we can see what it
+        generates.  Then, we write the result of <literal>show d1</literal>
+        to a file named <literal>/tmp/test</literal>.
+      </para>
+      <para>
+        Let's try reading it back.
+      </para>
+      &serialization.ghci:ex2;
+      <para>
+        First, we ask Haskell to read the file back.<footnote><para>As you will see
+          in <remark>FIXME: insert ref</remark>, Haskell doesn't actually
+          read the entire file at this point.  But for the purposes of this
+          example, we can ignore that distinction.</para></footnote>  Then,
+        we try to assign the result of <literal>read input</literal> to
+        <literal>d2</literal>.  That generates an error.  The reason is that
+        the interpreter doesn't know what type <literal>d2</literal> is meant
+        to be, so it doesn't know how to parse the input.  If we give it an
+        explicit cast, it works, and we can verify that the two sets of data
+        are equal.
+      </para>
+      <para>
+        Since so many different types are instances of &Read; and &Show; by
+        default (and others can be made instances easily; see <xref
+          linkend="hs.typeclasses.auto.derivation"/>), you can use it for
+        some really complex data structures.  Here are a few examples of
+        slightly more complex data structures:
+      </para>
+      &serialization.ghci:ex3;
+    </sect2>
addfile ./examples/ch05/serialization.ghci
hunk ./examples/ch05/serialization.ghci 1
+--# ex1
+let d1 = [Just 5, Nothing, Nothing, Just 8, Just 9]::[Maybe Int]
+putStrLn (show d1)
+writeFile "/tmp/test" (show d1)
+--# ex2
+input <- readFile "/tmp/test"
+let d2 = read input
+let d2 = (read input)::[Maybe Int]
+print d1
+print d2
+d1 == d2
+--# ex3
+putStrLn $ show [("hi", 1), ("there", 3)]
+putStrLn $ show [[1, 2, 3], [], [4, 0, 1], [], [503]]
+putStrLn $ show [Left 5, Right "three", Left 0, Right "nine"]
+putStrLn $ show [Left 0, Right [1, 2, 3], Left 5, Right []]
}