Use const fn

Cargo.toml

@@ -10,6 +10,7 @@ homepage = "https://github.com/paritytech/parity-tokio-ipc"
 description = """
 Interprocess communication library for tokio.
 """
+include = ["src/**/*", "LICENSE-*", "README.md"]
 
 [dependencies]
 futures = "0.3"

examples/client.rs

@@ -1,24 +1,33 @@
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use parity_tokio_ipc::Endpoint;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
 
 #[tokio::main(flavor = "current_thread")]
 async fn main() {
-	let path = std::env::args().nth(1).expect("Run it with server path to connect as argument");
+    let path = std::env::args()
+        .nth(1)
+        .expect("Run it with server path to connect as argument");
 
-	let mut client = Endpoint::connect(&path).await
-		.expect("Failed to connect client.");
+    let mut client = Endpoint::connect(&path)
+        .await
+        .expect("Failed to connect client.");
 
-	loop {
-		let mut buf = [0u8; 4];
-		println!("SEND: PING");
-		client.write_all(b"ping").await.expect("Unable to write message to client");
-		client.read_exact(&mut buf[..]).await.expect("Unable to read buffer");
-		if let Ok("pong") = std::str::from_utf8(&buf[..]) {
-			println!("RECEIVED: PONG");
-		} else {
-			break;
-		}
+    loop {
+        let mut buf = [0u8; 4];
+        println!("SEND: PING");
+        client
+            .write_all(b"ping")
+            .await
+            .expect("Unable to write message to client");
+        client
+            .read_exact(&mut buf[..])
+            .await
+            .expect("Unable to read buffer");
+        if let Ok("pong") = std::str::from_utf8(&buf[..]) {
+            println!("RECEIVED: PONG");
+        } else {
+            break;
+        }
 
-		tokio::time::sleep(std::time::Duration::from_secs(2)).await;
-	}
+        tokio::time::sleep(std::time::Duration::from_secs(2)).await;
+    }
 }

examples/server.rs

@@ -4,41 +4,45 @@ use tokio::io::{split, AsyncReadExt, AsyncWriteExt};
 use parity_tokio_ipc::{Endpoint, SecurityAttributes};
 
 async fn run_server(path: String) {
-	let mut endpoint = Endpoint::new(path);
-	endpoint.set_security_attributes(SecurityAttributes::allow_everyone_create().unwrap());
+    let mut endpoint = Endpoint::new(path);
+    endpoint.set_security_attributes(SecurityAttributes::allow_everyone_create().unwrap());
 
-	let incoming = endpoint.incoming().expect("failed to open new socket");
-	futures::pin_mut!(incoming);
+    let incoming = endpoint.incoming().expect("failed to open new socket");
+    futures::pin_mut!(incoming);
 
-	while let Some(result) = incoming.next().await
-	{
-		match result {
-			Ok(stream) => {
-				let (mut reader, mut writer) = split(stream);
+    while let Some(result) = incoming.next().await {
+        match result {
+            Ok(stream) => {
+                let (mut reader, mut writer) = split(stream);
 
-				tokio::spawn(async move {
-					loop {
-						let mut buf = [0u8; 4];
-						let pong_buf = b"pong";
-						if let Err(_) = reader.read_exact(&mut buf).await {
-							println!("Closing socket");
-							break;
-						}
-						if let Ok("ping") = std::str::from_utf8(&buf[..]) {
-							println!("RECIEVED: PING");
-							writer.write_all(pong_buf).await.expect("unable to write to socket");
-							println!("SEND: PONG");
-						}
-					}
-				});
-			}
-			_ => unreachable!("ideally")
-		}
-	};
+                tokio::spawn(async move {
+                    loop {
+                        let mut buf = [0u8; 4];
+                        let pong_buf = b"pong";
+                        if reader.read_exact(&mut buf).await.is_err() {
+                            println!("Closing socket");
+                            break;
+                        }
+                        if let Ok("ping") = std::str::from_utf8(&buf[..]) {
+                            println!("RECIEVED: PING");
+                            writer
+                                .write_all(pong_buf)
+                                .await
+                                .expect("unable to write to socket");
+                            println!("SEND: PONG");
+                        }
+                    }
+                });
+            }
+            _ => unreachable!("ideally"),
+        }
+    }
 }
 
 #[tokio::main(flavor = "current_thread")]
 async fn main() {
-	let path = std::env::args().nth(1).expect("Run it with server path as argument");
-	run_server(path).await
-}
+    let path = std::env::args()
+        .nth(1)
+        .expect("Run it with server path as argument");
+    run_server(path).await
+}