module("socket")

local M = {}

function connect(address, port, laddress, lport)

function M.connect(address, port, laddress, lport)

        local res, err = sock:bind(laddress, lport, -1)
        if not res then return nil, err end

        local res, berr = sock:bind(laddress, lport, -1)
        if not res then return nil, berr end

    local res, err = sock:connect(address, port)
    if not res then return nil, err end

    local res, cerr = sock:connect(address, port)
    if not res then return nil, cerr end

function bind(host, port, backlog)

function M.bind(host, port, backlog)

    local res, err = sock:bind(host, port)
    if not res then return nil, err end
    res, err = sock:listen(backlog)
    if not res then return nil, err end

    local res, berr = sock:bind(host, port)
    if not res then return nil, berr end
    res, berr = sock:listen(backlog)
    if not res then return nil, berr end

try = newtry()

M.try = socket.newtry()

function choose(table)

function M.choose(table)

        if not f then base.error("unknown key (".. base.tostring(name) ..")", 3)
        else return f(opt1, opt2) end

        if not f then
            base.error("unknown key (" .. base.tostring(name) .. ")", 3)
        else
            return f(opt1, opt2)
        end

sourcet = {}
sinkt = {}

M.sourcet = {}
M.sinkt = {}

BLOCKSIZE = 2048

M.BLOCKSIZE = 2048

sinkt["close-when-done"] = function(sock)

M.sinkt["close-when-done"] = function(sock)

        __call = function(self, chunk, err)

        __call = function(_, chunk, _)

            else return sock:send(chunk) end

            else
                return sock:send(chunk)
            end

sinkt["keep-open"] = function(sock)

M.sinkt["keep-open"] = function(sock)

        __call = function(self, chunk, err)
            if chunk then return sock:send(chunk)
            else return 1 end

        __call = function(_, chunk, _)
            if chunk then
                return sock:send(chunk)
            else
                return 1
            end

sinkt["default"] = sinkt["keep-open"]

M.sinkt["default"] = M.sinkt["keep-open"]

sink = choose(sinkt)

M.sink = M.choose(M.sinkt)

sourcet["by-length"] = function(sock, length)

M.sourcet["by-length"] = function(sock, length)

sourcet["until-closed"] = function(sock)

M.sourcet["until-closed"] = function(sock)

            if not err then return chunk

            if not err then
                return chunk

            else return nil, err end

            else
                return nil, err
            end

sourcet["default"] = sourcet["until-closed"]

M.sourcet["default"] = M.sourcet["until-closed"]

source = choose(sourcet)

M.source = M.choose(M.sourcet)

return M