SYMBOL INDEX (112 symbols across 12 files)

FILE: examples/async-echo.rs
  function main (line 7) | fn main() -> Result<(), Error> {

FILE: examples/fab.rs
  function main (line 6) | fn main() {
  function fab (line 19) | fn fab(mut n: u64) -> impl Generator<Yield = u64, Return = u64> {

FILE: examples/file-server.rs
  function main (line 8) | fn main() -> Result<(), Error> {
  constant CRLF (line 14) | const CRLF: &[char] = &['\r', '\n'];
  function new_server (line 16) | async fn new_server() -> Result<(), Error> {
  function handle_stream (line 26) | async fn handle_stream(mut stream: TcpStream) -> Result<(), Error> {

FILE: examples/fs-mio.rs
  constant TEST_FILE_VALUE (line 4) | const TEST_FILE_VALUE: &str = "Hello, World!\n";
  function main (line 6) | fn main() -> Result<(), Error> {

FILE: examples/fs.rs
  constant TEST_FILE_VALUE (line 4) | const TEST_FILE_VALUE: &str = "Hello, World!\n";
  function main (line 6) | fn main() -> Result<(), Error> {

FILE: examples/poll-timeout.rs
  function main (line 5) | fn main() -> Result<(), Error> {

FILE: examples/spurious-events.rs
  constant TOKEN (line 7) | const TOKEN: Token = Token(0);
  function main (line 9) | fn main() -> Result<(), Error> {

FILE: examples/tcp.rs
  constant SERVER_ACCEPT (line 7) | const SERVER_ACCEPT: Token = Token(0);
  constant SERVER (line 8) | const SERVER: Token = Token(1);
  constant CLIENT (line 9) | const CLIENT: Token = Token(2);
  constant SERVER_HELLO (line 10) | const SERVER_HELLO: &[u8] = b"PING";
  constant CLIENT_HELLO (line 11) | const CLIENT_HELLO: &[u8] = b"PONG";
  function main (line 13) | fn main() -> Result<(), Error> {

FILE: src/executor.rs
  constant MAX_RESOURCE_NUM (line 14) | const MAX_RESOURCE_NUM: usize = 1 << 31;
  constant MAIN_TASK_TOKEN (line 15) | const MAIN_TASK_TOKEN: Token = Token(MAX_RESOURCE_NUM);
  constant EVENT_CAP (line 16) | const EVENT_CAP: usize = 1024;
  constant RAW_WAKER_V_TABLE (line 18) | const RAW_WAKER_V_TABLE: RawWakerVTable = RawWakerVTable::new(clone_raw,...
  function get_source_token (line 20) | const fn get_source_token(index: usize) -> Token {
  function get_task_token (line 24) | const fn get_task_token(index: usize) -> Token {
  function index_from_source_token (line 29) | unsafe fn index_from_source_token(token: Token) -> usize {
  function index_from_task_token (line 37) | unsafe fn index_from_task_token(token: Token) -> usize {
  function is_source (line 44) | const fn is_source(token: Token) -> bool {
  function is_task (line 48) | const fn is_task(token: Token) -> bool {
  type PinFuture (line 52) | type PinFuture<T> = Pin<Box<dyn Future<Output = T>>>;
  type Executor (line 54) | struct Executor {
    method new (line 125) | pub fn new() -> Result<Self, Error> {
  type Awaker (line 61) | struct Awaker {
    method gen_waker (line 114) | fn gen_waker(&self) -> Waker {
  type Source (line 66) | struct Source {
  type Task (line 71) | struct Task {
  type TcpListener (line 77) | pub struct TcpListener {
    method new (line 372) | fn new(listener: mio::net::TcpListener) -> TcpListener {
    method poll_accept (line 379) | fn poll_accept(&mut self, waker: Waker) -> task::Poll<Result<(TcpStrea...
    method bind (line 401) | pub fn bind(addr: &SocketAddr) -> io::Result<TcpListener> {
    method local_addr (line 406) | pub fn local_addr(&self) -> io::Result<SocketAddr> {
    method ttl (line 409) | pub fn ttl(&self) -> io::Result<u32> {
    method set_ttl (line 412) | pub fn set_ttl(&self, ttl: u32) -> io::Result<()> {
    method accept (line 416) | pub fn accept(&mut self) -> TcpAcceptState {
  type TcpStream (line 83) | pub struct TcpStream {
    method new (line 422) | pub fn new(connected: mio::net::TcpStream) -> TcpStream {
    method read (line 430) | pub fn read(&mut self) -> StreamReadState {
    method write (line 434) | pub fn write(&mut self, data: Vec<u8>) -> StreamWriteState {
    method write_str (line 438) | pub fn write_str(&mut self, data: &str) -> StreamWriteState {
    method close (line 445) | pub fn close(self) {
    method read_poll (line 453) | fn read_poll(&mut self, waker: Waker) -> task::Poll<Result<Vec<u8>, Er...
    method write_poll (line 488) | fn write_poll(&mut self, data: &[u8], waker: Waker) -> task::Poll<Resu...
  type TcpAcceptState (line 89) | pub struct TcpAcceptState<'a> {
  type StreamReadState (line 93) | pub struct StreamReadState<'a> {
  type StreamWriteState (line 97) | pub struct StreamWriteState<'a> {
  function clone_raw (line 102) | fn clone_raw(ptr: *const ()) -> RawWaker {
  function drop_raw (line 106) | fn drop_raw(_ptr: *const ()) {}
  function wake (line 108) | fn wake(ptr: *const ()) {
  function block_on (line 150) | pub fn block_on<R, F>(main_task: F) -> Result<R, Error>
  function spawn (line 229) | pub fn spawn<F: Future<Output = Result<(), Error>> + 'static>(task: F) -...
  function register_source (line 266) | pub fn register_source<T: Evented + 'static>(
  function reregister_source (line 288) | unsafe fn reregister_source(token: Token, interest: Ready) -> Result<(),...
  function drop_source (line 302) | unsafe fn drop_source(token: Token) -> Result<(), Error> {
  method register (line 314) | fn register(
  method reregister (line 324) | fn reregister(
  method deregister (line 334) | fn deregister(&self, poll: &Poll) -> io::Result<()> {
  method register (line 340) | fn register(
  method reregister (line 352) | fn reregister(
  method deregister (line 364) | fn deregister(&self, poll: &Poll) -> io::Result<()> {
  type Output (line 518) | type Output = Result<(TcpStream, SocketAddr), Error>;
  method poll (line 519) | fn poll(
  type Output (line 528) | type Output = Result<Vec<u8>, Error>;
  method poll (line 529) | fn poll(
  type Output (line 538) | type Output = Result<usize, Error>;
  method poll (line 539) | fn poll(

FILE: src/fs.rs
  type Fs (line 8) | pub struct Fs {
    method println (line 62) | pub fn println(&self, string: String) -> Result<(), Error> {
    method open (line 66) | pub fn open<F>(&self, path: &str, callback: F) -> Result<(), Error>
    method read_to_string (line 77) | pub fn read_to_string<F>(&self, file: File, callback: F) -> Result<(),...
    method close (line 86) | pub fn close(&self) -> Result<(), Error> {
  type FsHandler (line 12) | pub struct FsHandler {
    method join (line 92) | pub fn join(self) -> Result<(), Error> {
  function fs_async (line 17) | pub fn fs_async() -> (Fs, FsHandler) {
  type FileCallback (line 98) | type FileCallback = Box<dyn FnOnce(File, Fs) -> Result<(), Error> + Sync...
  type StringCallback (line 99) | type StringCallback = Box<dyn FnOnce(String, Fs) -> Result<(), Error> + ...
  type Task (line 101) | pub enum Task {
  type TaskResult (line 108) | pub enum TaskResult {

FILE: src/fs_future.rs
  type BlockTaskWorker (line 13) | struct BlockTaskWorker {
    method new (line 18) | fn new() -> Self {
  function send_block_task (line 35) | fn send_block_task<T: BlockTask + 'static>(task: T) {
  type BlockTask (line 42) | trait BlockTask: Send {
    method exec (line 43) | fn exec(&mut self);
    method exec (line 59) | fn exec(&mut self) {
  type ReadFileTask (line 46) | struct ReadFileTask {
  type ReadFileState (line 52) | struct ReadFileState {
  function read_to_string (line 69) | pub fn read_to_string(file_name: String) -> impl Future<Output = Result<...
  type Output (line 85) | type Output = Result<String, Error>;
  method poll (line 86) | fn poll(

FILE: src/fs_mio.rs
  type Fs (line 10) | pub struct Fs {
    method println (line 102) | pub fn println(&self, string: String) -> Result<(), Error> {
    method open (line 106) | pub fn open<F>(&self, path: &str, callback: F) -> Result<(), Error>
    method read_to_string (line 117) | pub fn read_to_string<F>(&self, file: File, callback: F) -> Result<(),...
    method close (line 126) | pub fn close(&self) -> Result<(), Error> {
  type FsHandler (line 14) | pub struct FsHandler {
    method join (line 132) | pub fn join(self) -> Result<(), Error> {
  constant FS_TOKEN (line 19) | const FS_TOKEN: Token = Token(0);
  function fs_async (line 21) | pub fn fs_async() -> (Fs, FsHandler) {
  type FileCallback (line 138) | type FileCallback = Box<dyn FnOnce(File, Fs) -> Result<(), Error> + Sync...
  type StringCallback (line 139) | type StringCallback = Box<dyn FnOnce(String, Fs) -> Result<(), Error> + ...
  type Task (line 141) | pub enum Task {
  type TaskResult (line 148) | pub enum TaskResult {