In practice, it is not more verbose. Here's some example code from
net/protocol, and once try_read_nonblock is used.

Existing code:

def rbuf_fill
  begin
    @rbuf << @io.read_nonblock(BUFSIZE)
  rescue IO::WaitReadable
    return retry if IO.select([@io], nil, nil, @read_timeout)
    raise Timeout::Error
  rescue IO::WaitWritable
    # OpenSSL::Buffering#read_nonblock may fail with IO::WaitWritable.
    # http://www.openssl.org/support/faq.html#PROG10
    return retry if IO.select(nil, [@io], nil, @read_timeout)
    raise Timeout::Error
  end
end


With try_read_nonblock:

def rbuf_fill
  case value = @io.try_read_nonblock(BUFSIZE)
  when :read_would_block
    return rbuf_fill if IO.select([@io], nil, nil, @read_timeout)
    raise Timeout::Error
  when :write_would_block
    return rbuf_fill if IO.select(nil, [@io], nil, @read_timeout)
    raise Timeout::Error
  when String
    @rbuf << value
  end
end

*As you can see, the control flow logic is almost identical, but we
use Symbols instead of exceptions to manage the flow.*



Yehuda Katz
Chief Technologist | Strobe
(ph) 718.877.1325


On Mon, Aug 1, 2011 at 3:49 PM, Shyouhei Urabe <shyouhei / ruby-lang.org>wrote:

>
> Issue #5138 has been updated by Shyouhei Urabe.
>
>
> Instead of avoiding exceptions I would like to suggest making exceptions
> lightweight.
>
> "Check those return values every time you call this function" is nothing
> different from C.  I would write my program totally in C if I have to do
> that way.
> ----------------------------------------
> Bug #5138: Add nonblocking IO that does not use exceptions for EOF and
> EWOULDBLOCK
> http://redmine.ruby-lang.org/issues/5138
>
> Author: Yehuda Katz
> Status: Open
> Priority: Normal
> Assignee: Yukihiro Matsumoto
> Category: core
> Target version: 1.9.4
> ruby -v: ruby 1.9.4dev (2011-07-31 trunk 32788) [x86_64-darwin11.0.0]
>
>
> The current Ruby I/O classes have non-blocking methods (read_nonblock and
> write_nonblock). These methods will never block, and if they would block,
> they raise an exception instead (IO::WaitReadable or IO::WaitWritable). In
> addition, if the IO is at EOF, they raise an EOFError.
>
> These exceptions are raised repeatedly in virtually every use of the
> non-blocking methods. This patch adds a pair of methods (try_read_nonblock
> and try_write_nonblock) that have the same semantics as the existing
> methods, but they return Symbols instead of raising exceptions for these
> routine cases:
>
> * :read_would_block
> * :write_would_block
> * :eof
>
> The patch contains updates for IO, StringIO, and OpenSSL. The updates are
> fully documented and tested.
>
>
> --
> http://redmine.ruby-lang.org
>
>