     }
 }
 extension Socket {
+	/// Sends `data` to the connected peer
+	///
+	/// Depending on the protocol, the socket must either be in a connected 
+	/// state, or had a previous call to connect (or bind) to specify the
+	/// communication address.
+	///
+	/// - parameters:
+	///		- data:		A pointer to a buffer to send
+	///		- length:	The length of the buffer (in bytes).
+	///		- flags:	Control options for sending and recieving. 0 is the 
+	///					default.
+	///		- maxSize:	Specifies the maximum packet size when attempting to
+	///					send large amounts of data. If, for example, length
+	///					is twice the size of maxSize, then it will take two
+	///					calls (internally) to send the data. Default is 1024.
+	/// - Returns:
+	///					The number of bytes sent.
+	/// - Throws:
+	///		- `SocketError.SendToFailed`
     public func send(data: UnsafePointer<Void>, length: Int, flags: Int32 = 0,
         maxSize: Int = 1024) throws -> Int {
 			var data = data 

    }
    
    deinit {
        // Clean up what the user didn't
        if !closed {
            do { try close() } catch {}
        }

            }
            return bytesSent
    }
	/// Sends `msghdr` to the specified peer.
	///
	/// Currently, this method provides a convience wrapper to calling
	///	`Darwin.sendmsg()`. Do not rely on this. If you are using this method
	/// you probally know more about it than I do, and you should probally write
	/// the implementation for it.
	///
	/// - parameters:
	///		- msg:			A msghdr object which specifies a series of messages
	///						and their destination.
	///		- flags:		Controls additional parameters on the send behaviour.
	///						Default is 0.
	///		- maxSize:		Specifies the maximum packet size allowed to be sent
	///						(measured in bytes).
	///						Buffers which exceed this value will be split to be 
	///						less than or equal to this length.
	/// - Returns:
	///						The number of bytes sent.
	/// - Throws:
	///		- `SocketError.SendMSGFailed`
	///
	/// - Todo: This implementation is a poor one. I do not have enough 
	///			understanding/willpower to implement it correctly. It should 
	///			attempt to break each packet into a size of 1024, and send 
	///			individually.
    public func send(inout msg: msghdr, flags: Int32 = 0, maxSize: Int = 1024)
        throws -> Int {
        
