typed-websocket 0.1.0

# [typed-websocket](./README.md)
[![crates](https://img.shields.io/crates/v/typed-websocket)](https://crates.io/crates/typed-websocket)
[![docs](https://img.shields.io/docsrs/typed-websocket)](https://docs.rs/typed-websocket)
[![license](https://img.shields.io/github/license/kanekoshoyu/typed-websocket)](https://github.com/kanekoshoyu/typed-websocket/blob/master/LICENSE)
> simple wrapper on top of websocket stream that enforces type

## use case
```
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    use tokio_tungstenite::connect_async;
    use url::Url;

    let url = Url::parse("wss://example.com/socket")?;
    let (stream, _) = connect_async(url).await?;

    // Create a TypedWebSocketStream with specific input/output types
    let mut ws: TypedWebSocketStream<_, RequestMessage, ResponseMessage> = TypedWebSocketStream::new(stream);

    // Send a message
    let outgoing = RequestMessage::new();
    ws.send(outgoing).await?;

    // Receive a message
    match ws.receive().await {
        Ok(incoming) => println!("Received: {:?}", incoming),
        Err(e) => eprintln!("Error receiving message: {}", e),
    }

    // Close the connection
    ws.close().await?;

    Ok(())
}
```

## requirement
- INPUT: impl Serialize
- OUTPUT: impl Deserialize
```
// Define input and output message types
#[derive(Serialize, Debug)]
struct RequestMessage {
    command: String,
    data: String,
}

#[derive(Deserialize, Debug)]
struct ResponseMessage {
    response: String,
    status: u16,
}
```

## notes
- [changelog](./CHANGELOG.md)