* IO.read_line - documentation - say explicitly what happens on last line of file that has no final \n

* using Ropes we are forced to use character-indexes: a leaf is seemingly always traversed on [get] and [sub]; should be able to do byte-indexing (with enough privacy this can be done safely). Personally, I think that in real applications byte-indexing provides enough functionality and is faster. I mean: indexes are usually used as if were private, always come from some form of parsing or traversal.

* [open Batteries include Backwards_compatibility]

* import pa-do (http://pa-do.forge.ocamlcore.org/)

* import Camlp4

* import Camomile

* import OCamlNet
 * Shell gets merged into Sys or Unix
  * producer <- channel_out
  * consumer <- channel_in
 * Netshm gets    into Data.Containers.Mutable.Shared.Memory
 * Netshm_data    gets into Data.Containers.Mutable.Shared.Data
 * Netshm_hashtbl gets into Data.Containers.Mutable.Shared.Hashtbl
 * Netshm_array   gets into Data.Containers.Mutable.Shared.Array
 * Equeue         gets into Control.Concurrency.Queues
 * Unixqueue      gets into System.

* import OCaml-Fileutils

* import Godi-cryptokits

* import Cairo

* import OUnit

* import Calendar

* import PCRE?

* evaluate/import OcNAE

* import Core? Not right now.
 * Core.Squeue     goes into Concurrency.Threads
 * Core.Thread_safe_queue goes into Concurrency.Threads
 * Core.Bag        goes into Containers
 * Core.Bigbuffer  goes into Containers
 * Core.Dequeue    goes into Containers
 * Core.Fasthtbl   goes into Containers
 * Core.Force_once goes into Containers
 * Core.Fqueue     goes into Containers
 * Core.Hashqueue  goes into Containers
 * Core.Hash_set   goes into Containers ?
 * Core.Heap       goes into Containers
 * Core.PSet       goes into Containers
 * Core.Ref        goes into Containers
 * Core.Tuple      goes into Containers
 * Core.Bigstring  goes into Text
 * Core.Char       goes into Text
 * Core.Bool       goes into Math
 * Core.Float      goes into Math
 * Core.Floatable  goes into Math
 * Core.Int        goes into Math
 * Core.Int_intf   goes into Math as ?
 * Core.Interval   goes into Math
 * Core.Interval_set     goes into Math
 * Core.Piecewise_linear goes into Math
 * Core.Time       goes into Math.Time
 * Core.Month      goes into Math.Time
 * Core.Exn        goes into Meta
 * Core.Caml       goes into Meta as Legacy
 * Core.Memo       goes into Meta
 * Core.Monad      goes into Meta?
 * Core.Size       goes into Meta
 * Core.Unique_id  goes into Meta
 * Core.Word_size  goes into Meta
 * Core.Linux_ext  goes into System as Linux
 * Core.Timer      goes into System
 * Core.Crc        goes into Util
 * Core.Common split between
  * Standard      -- [result], [%], [/%], [forever], [ascending],
   [descending], [failwithf], [invalidargf]
  * Threads.Mutex -- [critical_section]
  * Filename      -- [^/]
 * Core.Unix_ext   merged with System.Unix
 * Core.Option     merged with Containers.Option
 * Core.Core_*   merged
 * Core.Equatable  goes into Meta? into Data?
 * Core.Hashable   goes into Meta? into Data?
 * Core.Doubly_linked?
 * Core.In_channel gets vampirized into System.IO
 * Core.Out_channelgets vampirized into System.IO
 * Core.Linebuf    gets vampirized into System.IO
 * Core.OUnit_utils gets vampirized into Meta.Toolchain.OUnit when
   possible
 * Core.Sexpable   gets vampirized into Meta.Sexplib
 * Core.Stringable gets vampirized into Meta.Sexplib
 * substitute [protectx] with [Standard.finally]
