proconio

Proconio uses the Source trait to define how input data is provided to the input! macro. There are three main types of sources:

1. OnceSource: Reads the entire input at once. It is very fast but requires you to signal EOF (Ctrl-D on Unix, Ctrl-Z on Windows) after the input. It is used by the input_once! macro.
2. LineSource: Reads input line by line. This is ideal for local debugging and interactive testing where you press Enter after each line. It is used by the input! macro.
3. AutoSource: A compatibility source that switches behavior based on the build profile: LineSource in debug builds and OnceSource in release builds.

Note: To ensure consistent behavior between local testing and judge servers, the input! macro always uses LineSource and input_once! always uses OnceSource, regardless of the build profile. You should only use AutoSource if you explicitly want profile-dependent behavior.

# extern crate proconio;
use proconio::source::auto::AutoSource;
use proconio::input;

let source = AutoSource::from("32 54 -23");
input! {
    from source,
    n: u8,
    m: u32,
    l: i32,
}

The input! macro is the primary way to read values from stdin or a custom source and declare them as variables. By default, it reads line-by-line, making it suitable for interactive problems.

Syntax

input! {
    from source,          // optional: defaults to stdin
    (mut) variable: type, // mut is optional
    ...
}

Key Features

• Mutability: Use mut variable: type to declare a mutable variable.
• Arrays and Matrices: You can read arrays or matrices. If the first input is the length, you can omit the length in the type definition to read jagged arrays.
• Tuples: Supports reading into tuples: t: (i32, i32).
• Custom Sources: Use from source to read from an object implementing the Source trait (e.g., AutoSource). To prevent moving the source, use from &mut source.

use proconio::input;
use proconio::source::auto::AutoSource;

let source = AutoSource::from("32 54 -23");

input! {
    from source,
    n: u8,
    m: u32,
    l: i32,
}

// n, m, and l are now available as variables

You can make your own structs Readable using the #[derive_readable] attribute (requires the derive feature). This allows you to use your custom types directly inside input! or read_value! macros.

When using #[derive_readable], types used in the struct fields are automatically translated to their actual output types. For example, if a field is declared as proconio::marker::Usize1, the resulting struct field will be of type usize.

Example

#[cfg(feature = "derive")]
{
    use proconio::input;
    use proconio::derive_readable;
    use proconio::marker::Usize1;

    #[derive_readable]
    struct Weight;

    #[derive_readable]
    struct Cost(i32);

    #[derive_readable]
    struct Edge {
        from: usize,
        to: Usize1, // The real Edge::to has type usize.
        weight: Weight,
        cost: Cost,
    }

    fn main() {
        input! {
            edge: Edge,
        }
    }
}

#[cfg(feature = "derive")]
{
    extern crate proconio;
    use proconio::input;
    use proconio::source::auto::AutoSource;
    use proconio::derive_readable;

    #[derive_readable]
    #[derive(PartialEq, Debug)]
    struct Weight;

    #[derive_readable]
    #[derive(PartialEq, Debug)]
    struct Cost(i32);

    #[derive_readable]
    #[derive(Debug)]
    struct Edge {
        from: usize,
        to: proconio::marker::Usize1, // The real Edge::to has type usize.
        weight: Weight,
        cost: Cost,
    }

    fn main() {
    # let source = AutoSource::from("12 32 35");
        input! {
    #       from source,
            edge: Edge,
        }

    #     assert_eq!(edge.from, 12);
    #     assert_eq!(edge.to, 31);
    #     assert_eq!(edge.weight, Weight);
    #     assert_eq!(edge.cost, Cost(35));
    }
}

If you enable the derive feature in your Cargo.toml, you can use the #[fastout] attribute to speed up print! and println! calls by using buffered output.

Setup

In Cargo.toml:

proconio = { version = "...", features = ["derive"] }

Usage

use proconio::fastout;

#[fastout]
fn main() {
    println!("Hello, world!");
}

Important Limitations

• Thread Safety: You cannot create a closure containing print! or println! inside a #[fastout] function (e.g., via std::thread::spawn), as the closure becomes thread-unsafe due to the internal unlocked stdout.
• Deadlocks: If you spawn a new thread that runs a function annotated with #[fastout], you must not annotate the caller function with #[fastout]. Doing so will cause a deadlock because the caller will hold the stdout lock that the callee needs.
• Printing Order: Because #[fastout] uses buffering, the order of output between main and other functions might differ from standard execution.

#[cfg(feature = "derive")]
{
    use proconio::fastout;

    #[fastout]
    fn main() {
        print!("{}{}, ", 'h', "ello"); // "hello" (no newline)
        println!("{}!", "world");      // "world!\n"
        println!("{}", 123456789);     // "123456789\n"
    }
}