Better documentation (#391)

* Better documentation

* Minor

libp2p/src/lib.rs

@@ -18,6 +18,118 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
+//! Libp2p is a peer-to-peer framework.
+//!
+//! # Major libp2p concepts
+//!
+//! Here is a list of all the major concepts of libp2p.
+//!
+//! ## Multiaddr
+//! 
+//! A `Multiaddr` is a way to reach a node. Examples:
+//! 
+//! * `/ip4/80.123.90.4/tcp/5432`
+//! * `/ip6/[::1]/udp/10560`
+//! * `/unix//path/to/socket`
+//!
+//! ## Transport
+//!
+//! `Transport` is a trait that represents an object capable of dialing multiaddresses or
+//! listening on multiaddresses. The `Transport` produces an output which varies depending on the
+//! object that implements the trait.
+//!
+//! Each implementation of `Transport` typically supports only some multiaddresses. For example
+//! the `TcpConfig` type (which implements `Transport`) only supports multiaddresses of the format
+//! `/ip4/.../tcp/...`.
+//!
+//! Example:
+//!
+//! ```rust
+//! use libp2p::{Multiaddr, Transport, tcp::TcpConfig};
+//! let tcp_transport = TcpConfig::new();
+//! let addr: Multiaddr = "/ip4/98.97.96.95/tcp/20500".parse().expect("invalid multiaddr");
+//! let _outgoing_connec = tcp_transport.dial(addr);
+//! // Note that `_outgoing_connec` is a `Future`, and therefore doesn't do anything by itself
+//! // unless it is run through a tokio runtime.
+//! ```
+//!
+//! The easiest way to create a transport is to use the `CommonTransport` struct. This struct
+//! provides support for the most common protocols.
+//!
+//! Example:
+//!
+//! ```rust
+//! use libp2p::CommonTransport;
+//! let _transport = CommonTransport::new();
+//! // _transport.dial(...);
+//! ```
+//!
+//! See the documentation of the `libp2p-core` crate for more details about transports.
+//!
+//! # Connection upgrades
+//!
+//! Once a connection has been opened with a remote through a `Transport`, it can be *upgraded*.
+//! This consists in negotiating a protocol with the remote (through the `multistream-select`
+//! protocol), and applying that protocol on the socket.
+//!
+//! Example upgrades:
+//!
+//! - Adding a security layer on top of the connection.
+//! - Applying multiplexing, so that a connection can be split into multiple substreams.
+//! - Negotiating a specific protocol, such as *ping* or *kademlia*.
+//!
+//! A potential connection upgrade is represented with the `ConnectionUpgrade` trait. The trait
+//! consists in a protocol name plus a method that turns the socket into an `Output` object whose
+//! nature and type is specific to each upgrade. For example, if you upgrade a connection with a
+//! security layer, the output might contain an encrypted stream and the public key of the remote.
+//!
+//! You can combine a `Transport` with a compatible `ConnectionUpgrade` in order to obtain another
+//! `Transport` that yields the output of the upgrade.
+//!
+//! Example:
+//!
+//! ```rust
+//! use libp2p::{Transport, tcp::TcpConfig, secio::{SecioConfig, SecioKeyPair}};
+//! let tcp_transport = TcpConfig::new();
+//! let secio_upgrade = SecioConfig {
+//!     key: SecioKeyPair::ed25519_generated().unwrap(),
+//! };
+//! let with_security = tcp_transport.with_upgrade(secio_upgrade);
+//! // let _ = with_security.dial(...);
+//! // `with_security` also implements the `Transport` trait, and all the connections opened
+//! // through it will automatically negotiate the `secio` protocol.
+//! ```
+//!
+//! See the documentation of the `libp2p-core` crate for more details about upgrades.
+//!
+//! ## Swarm
+//!
+//! Once you have created an object that implements the `Transport` trait, you can put it in a
+//! *swarm*. This is done by calling the `swarm()` freestanding function with the transport
+//! alongside with a function or a closure that will turn the output of the upgrade (usually an
+//! actual protocol, as explained above) into a `Future` producing `()`.
+//!
+//! See the documentation of the `libp2p-core` crate for more details about creating a swarm.
+//!
+//! # Using libp2p
+//!
+//! This section contains details about how to use libp2p in practice.
+//!
+//! The most simple way to use libp2p consists in the following steps:
+//!
+//! - Create a *base* implementation of `Transport` that combines all the protocols you want and
+//!   the upgrades you want, such as the security layer and multiplexing.
+//! - Create structs that implement the `ConnectionUpgrade` trait for the protocols you want to
+//!   create, or use the protocols provided by the `libp2p` crate.
+//! - Create a swarm that combines your base transport and all the upgrades and that handles the
+//!   behaviour that happens.
+//! - Use this swarm to dial and listen.
+//!
+//! You probably also want to have some sort of nodes discovery mechanism, so that you
+//! automatically connect to nodes of the network. The details of this haven't been fleshed out
+//! in libp2p and will be written later.
+//!
+
 pub extern crate bytes;
 pub extern crate futures;
 #[cfg(not(target_os = "emscripten"))]