This is a Ruby tree! It shows every object from the Ruby Programming Language in a tree format.

write_nonblock 

        # IO.write_nonblock

(from ruby core)
---
    ios.write_nonblock(string)   -> integer
    ios.write_nonblock(string [, options])   -> integer

---

Writes the given string to *ios* using the write(2) system call after
O_NONBLOCK is set for the underlying file descriptor.

It returns the number of bytes written.

write_nonblock just calls the write(2) system call. It causes all errors
the write(2) system call causes: Errno::EWOULDBLOCK, Errno::EINTR, etc.
The result may also be smaller than string.length (partial write). The
caller should care such errors and partial write.

If the exception is Errno::EWOULDBLOCK or Errno::EAGAIN, it is extended
by IO::WaitWritable. So IO::WaitWritable can be used to rescue the
exceptions for retrying write_nonblock.

    # Creates a pipe.
    r, w = IO.pipe

    # write_nonblock writes only 65536 bytes and return 65536.
    # (The pipe size is 65536 bytes on this environment.)
    s = "a" * 100000
    p w.write_nonblock(s)     #=> 65536

    # write_nonblock cannot write a byte and raise EWOULDBLOCK (EAGAIN).
    p w.write_nonblock("b")   # Resource temporarily unavailable (Errno::EAGAIN)

If the write buffer is not empty, it is flushed at first.

When write_nonblock raises an exception kind of IO::WaitWritable,
write_nonblock should not be called until io is writable for avoiding
busy loop. This can be done as follows.

    begin
      result = io.write_nonblock(string)
    rescue IO::WaitWritable, Errno::EINTR
      IO.select(nil, [io])
      retry
    end

Note that this doesn't guarantee to write all data in string. The length
written is reported as result and it should be checked later.

On some platforms such as Windows, write_nonblock is not supported
according to the kind of the IO object. In such cases, write_nonblock
raises `Errno::EBADF`.

By specifying a keyword argument *exception* to `false`, you can
indicate that write_nonblock should not raise an IO::WaitWritable
exception, but return the symbol `:wait_writable` instead.

This is MURDOC! A Ruby documentation browser inspired by Smalltalk-80. It allows you to learn about Ruby by browsing through its class hierarchies, and see any of its methods.