Replace a few references to platform to the now more specific projects.

Author: teh

_includes/footer.html

@@ -5,18 +5,18 @@
             - <a href="http://twitter.com/CloudHaskell" target="_blank">CloudHaskell</a>
             - <a href="https://github.com/hyperthunk" target="_blank">Tim Watson</a>
         </p>
-        <p class="pull-right" style="clear: right"><iframe class="github-btn" src="http://ghbtns.com/github-btn.html?user=haskell-distributed&repo=distributed-process-platform&type=fork&count=true" allowtransparency="true" frameborder="0" scrolling="0" width="102px" height="20px"></iframe></p>
+        <p class="pull-right" style="clear: right"><iframe class="github-btn" src="http://ghbtns.com/github-btn.html?user=haskell-distributed&repo=distributed-process&type=fork&count=true" allowtransparency="true" frameborder="0" scrolling="0" width="102px" height="20px"></iframe></p>
         <p><a href="http://github.com/haskell-distributed">Code</a> licensed under <a href="https://github.com/haskell-distributed/distributed-process/blob/master/LICENSE" target="_blank">BSD-3</a>,
         </p>
         <p>
-            Website design shamelessly derived from <a href="https://twitter.com/kmett">Edward Kmett's'</a> 
+            Website design shamelessly derived from <a href="https://twitter.com/kmett">Edward Kmett's'</a>
             <a href="http://lens.github.com/">lens library github pages</a> under <a href="http://creativecommons.org/licenses/by/3.0/">CC BY 3.0</a>.
         </p>
         <p class="pull-right" style="clear: right; margin-right: -2px">
             <a href="https://twitter.com/CloudHaskell" class="twitter-follow-button" data-link-color="#0069D6" data-show-count="true">Follow @CloudHaskell</a>
         </p>
         <p><a href="http://glyphicons.com">Glyphicons</a> and <a href="http://www.vectorportal.com/">Vectorportal</a> images reproduced with permission.</p>
-        <p class="pull-right" style="clear: right"><!-- TODO: build status 
+        <p class="pull-right" style="clear: right"><!-- TODO: build status
         --></p>
 
         <ul class="footer-links">

documentation.md

@@ -31,7 +31,7 @@ Cloud Haskell comprises the following components, some of which are complete,
 others experimental.
 
 * [distributed-process][distributed-process]: Base concurrency and distribution support
-* [distributed-process-platform][distributed-process-platform]: The Cloud Haskell Platform - APIs
+* [distributed-process-client-server][distributed-process-client-server]: Common client/server patterns like Erlang's `gen_server`
 * [distributed-static][distributed-static]: Support for static values
 * [rank1dynamic][rank1dynamic]: Like `Data.Dynamic` and `Data.Typeable` but supporting polymorphic values
 * [network-transport][network-transport]: Generic `Network.Transport` API
@@ -319,19 +319,19 @@ is managed in the *process layer*, whilst a higher level API described as the
 * data centric processing model
 * a promise (or *future*) abstraction, representing the result of a calculation that may or may not have yet completed
 
-The [distributed-process-platform][distributed-process-platform] library implements parts of the
+The [distributed-process-task][distributed-process-task] library implements parts of the
 *task layer*, but takes a very different approach to that described
 in the original paper and implemented by the [remote][remote] package. In particular,
 we diverge from the original design and defer to many of the principles
 defined by Erlang's [Open Telecom Platform][OTP], taking in some well established
 Haskell concurrency design patterns along the way.
 
-In fact, [distributed-process-platform][distributed-process-platform] does not really consider the
+In fact, [distributed-process-async][distributed-process-async] does not really consider the
 *task layer* in great detail. We provide an API comparable to remote's
 `Promise` in `Control.Distributed.Process.Platform.Async`. This API however,
 is derived from Simon Marlow's [Control.Concurrent.Async][async] package, and is not
 limited to blocking queries on `Async` handles in the same way. Instead our
-[API][d-p-platform-async] handles both blocking and non-blocking queries, polling
+[API][d-p-async-async] handles both blocking and non-blocking queries, polling
 and working with lists of `Async` handles. We also eschew throwing exceptions
 to indicate asynchronous task failures, instead handling *task* and connectivity
 failures using monitors. Users of the API need only concern themselves with the
@@ -388,7 +388,7 @@ Work is also underway to provide abstractions for managing asynchronous tasks
 at a higher level, focussing on workload distribution and load regulation.
 
 The kinds of task that can be performed by the async implementations in
-[distributed-process-platform][distributed-process-platform] are limited only by their return type:
+[distributed-process-async][distributed-process-async] are limited only by their return type:
 it **must** be `Serializable` - that much should've been obvious by now.
 The type of asynchronous task definitions comes in two flavours, one for
 local nodes which require no remote-table or static serialisation dictionary,
@@ -427,14 +427,14 @@ domain was more *haskell-ish* than working with bare send and receive primitives
 The `Async` sub-package also provides a type safe interface for receiving data,
 although it is limited to running a computation and waiting for its result.
 
-The [Control.Distributed.Processes.Platform.ManagedProcess][d-p-platform-ManagedProcess] API provides a
+The [Control.Distributed.Processes.Platform.ManagedProcess][d-p-client-server-ManagedProcess] API provides a
 number of different abstractions that can be used to achieve similar benefits
 in your code. It works by introducing a standard protocol between your process
 and the *world outside*, which governs how to handle request/reply processing,
 exit signals, timeouts, sleeping/hibernation with `threadDelay` and even provides
 hooks that terminating processes can use to clean up residual state.
 
-The [API documentation][d-p-platform-ManagedProcess] is quite extensive, so here we will simply point
+The [API documentation][d-p-client-server-ManagedProcess] is quite extensive, so here we will simply point
 out the obvious differences. A process implemented with `ManagedProcess`
 can present a type safe API to its callers (and the server side code too!),
 although that's not its primary benefit. For a very simplified example:
@@ -487,7 +487,7 @@ configurable task pools and task supervision strategy part of its API.
 
 More complex examples of the `ManagedProcess` API can be seen in the
 [Managed Processes tutorial](tutorials/tutorial3.html). API documentation for HEAD is available
-[here][d-p-platform-ManagedProcess].
+[here][d-p-client-server-ManagedProcess].
 
 ### Supervision Trees
 
@@ -500,7 +500,8 @@ TBC
 [cloud-haskell]: http://haskell-distributed.github.io/documentation.html
 [fun201202-coutts]: http://sneezy.cs.nott.ac.uk/fun/2012-02/coutts-2012-02-28.pdf
 [distributed-process]: https://github.com/haskell-distributed/distributed-process
-[distributed-process-platform]: https://github.com/haskell-distributed/distributed-process-platform
+[distributed-process-client-server]: https://github.com/haskell-distributed/distributed-process-client-server
+[distributed-process-async]: https://github.com/haskell-distributed/distributed-process-async
 [distributed-static]: http://hackage.haskell.org/package/distributed-static
 [rank1dynamic]: http://hackage.haskell.org/package/rank1dynamic
 [network-transport]: http://hackage.haskell.org/package/network-transport
@@ -513,6 +514,6 @@ TBC
 [haskell11-ch]: http://research.microsoft.com/en-us/um/people/simonpj/papers/parallel/remote.pdf
 [OTP]: http://en.wikipedia.org/wiki/Open_Telecom_Platform
 [remote]: http://hackage.haskell.org/package/remote
-[d-p-platform-async]: http://hackage.haskell.org/package/distributed-process-platform/Control-Distributed-Process-Platform-Async.html
+[d-p-async-async]: https://hackage.haskell.org/package/distributed-process-async/docs/Control-Distributed-Process-Async.html
 [async]: http://hackage.haskell.org/package/async
-[d-p-platform-ManagedProcess]: http://hackage.haskell.org/package/distributed-process-platform/Control-Distributed-Process-Platform-ManagedProcess.html
+[d-p-client-server-ManagedProcess]: https://hackage.haskell.org/package/distributed-process-client-server/docs/Control-Distributed-Process-ManagedProcess.html

index.md

@@ -5,9 +5,8 @@ title: Home
 Cloud Haskell: Erlang-style concurrent and distributed programming in Haskell.
 The Cloud Haskell Platform consists of a
 [generic network transport API](https://github.com/haskell-distributed/network-transport),
-libraries for sending [static closures](https://github.com/haskell-distributed/distributed-static) to remote nodes, a rich [API for distributed programming](https://github.com/haskell-distributed/distributed-process) and a 
-set of [Platform Libraries](https://github.com/haskell-distributed/distributed-process-platform),
-modelled after Erlang's [Open Telecom Platform](http://www.erlang.org/doc/).
+libraries for sending [static closures](https://github.com/haskell-distributed/distributed-static) to remote nodes, a rich [API for distributed programming](https://github.com/haskell-distributed/distributed-process) and a
+set of platform libraries modelled after Erlang's [Open Telecom Platform](http://www.erlang.org/doc/).
 
 Generic network transport backends have been developed for
 [TCP](https://github.com/haskell-distributed/network-transport-tcp) and
@@ -32,5 +31,3 @@ each library.
     </ul>
   </div>
 </div>
-
-

team.md

@@ -27,7 +27,7 @@ of Cloud Haskell as a whole. [Edsko De Vries][13], a member of Well-Typed and th
 author of much of the new implementation we have today, is still closely involved
 as well.
 
-[Tim][6] is the primary author and maintainer of [disributed-process-platform][8];
+[Tim][6] is the primary author and maintainer of [disributed-process][8];
 an effort to port many of the benefits of Erlang's [Open Telecom Platform][10] to
 the Cloud Haskell ecosystem.
 
@@ -48,7 +48,7 @@ Duncan Coutts, Simon Marlow, Ryan Newton, Eric Kow, Adam Foltzer, Nicolas Wu
 [5]: http://www.haskell.org/haskellwiki/Parallel_GHC_Project
 [6]: https://github.com/hyperthunk
 [7]: https://github.com/jepst
-[8]: https://github.com/haskell-distributed/disributed-process-platform
+[8]: https://github.com/haskell-distributed/disributed-process
 [9]: http://hackage.haskell.org/trac/ghc/wiki/Contributors
 [10]: http://en.wikipedia.org/wiki/Open_Telecom_Platform
 [11]: https://github.com/jepst/distributed-process-global

tutorials/1ch.md

@@ -138,7 +138,7 @@ main = do
       -- Die immediately - throws a ProcessExitException with the given reason.
       Nothing  -> die "nothing came back!"
       Just s -> say $ "got " ++ s ++ " back!"
-      
+
     -- Without the following delay, the process sometimes exits before the messages are exchanged.
     liftIO $ threadDelay 2000000
 {% endhighlight %}
@@ -289,9 +289,9 @@ different ways:
 
 ------
 
-[1]: /static/doc/distributed-process/Control-Distributed-Process.html#v:Message
-[2]: http://hackage.haskell.org/package/distributed-process
-[3]: /static/doc/distributed-process-platform/Control-Distributed-Process-Platform-Async.html
-[4]: /static/doc/distributed-process-platform/Control-Distributed-Process-Platform-ManagedProcess.htmlv:callAsync
-[5]: http://hackage.haskell.org/packages/archive/distributed-process/latest/doc/html/Control-Distributed-Process-Internal-Primitives.html#t:Match
-[6]: http://hackage.haskell.org/packages/archive/distributed-process/latest/doc/html/Control-Distributed-Process-Closure.html
+[1]: https://hackage.haskell.org/package/distributed-process-0.6.6/docs/Control-Distributed-Process.html#t:Message
+[2]: https://hackage.haskell.org/package/distributed-process
+[3]: https://hackage.haskell.org/package/distributed-process-async/docs/Control-Distributed-Process-Async.html
+[4]: https://hackage.haskell.org/package/distributed-process-client-server-0.1.3.2/docs/Control-Distributed-Process-ManagedProcess-Client.html#v:callAsync
+[5]: https://hackage.haskell.org/packages/archive/distributed-process/latest/doc/html/Control-Distributed-Process-Internal-Primitives.html#t:Match
+[6]: https://hackage.haskell.org/packages/archive/distributed-process/latest/doc/html/Control-Distributed-Process-Closure.html