Struct may_clack::multi_select::MultiSelect

source · 
pub struct MultiSelect<M: Display, T: Clone, O: Display + Clone> { /* private fields */ }
Expand description

MultiSelect struct

§Examples

use may_clack::multi_select;

let answer = multi_select("select")
    .option("val1", "value 1")
    .option("val2", "value 2")
    .option_hint("val 3", "value 3", "hint")
    .interact()?;
println!("answer {:?}", answer);

Implementations§

source§

impl<M: Display, T: Clone, O: Display + Clone> MultiSelect<M, T, O>

source

pub fn new(message: M) -> Self

Creates a new MultiSelect struct.

Has a shorthand version in multi_select()

§Examples
use may_clack::{multi_select, multi_select::MultiSelect};

// these two are equivalent
let mut question = MultiSelect::new("message");
question.option("value", "hint");

let mut question = multi_select("message");
question.option("value", "hint");
source

pub fn option(&mut self, val: T, label: O) -> &mut Self

Add an option without a hint.

§Examples
use may_clack::multi_select;

let answer = multi_select("message")
    .option("val1", "label 1")
    .option("val2", "label 2")
    .interact()?;
println!("answer {:?}", answer);
Examples found in repository?
examples/single.rs (line 12)
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

fn main() -> Result<(), ClackError> {
	println!();
	intro!(" single ".reversed());
	let do_single_select = select("single")
		.option("one", "one")
		.cancel(do_cancel)
		.interact()?;
	let do_single_multi = multi_select("single")
		.option("one", "one")
		.cancel(do_cancel)
		.interact()?;

	outro!();

	println!("select {:?}", do_single_select);
	println!("multi {:?}", do_single_multi);

	Ok(())
}
More examples
Hide additional examples
examples/generic_select.rs (line 34)
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

fn main() -> Result<(), ClackError> {
	println!();
	intro!(" generic select ".reversed());

	let select_enum = select("select enum")
		.option(SelectEnum::One, SelectEnum::One)
		.option(SelectEnum::Two, SelectEnum::Two)
		.option(SelectEnum::Three, SelectEnum::Three)
		.cancel(do_cancel)
		.interact()?;

	let multi_enum = multi_select("multi_select enum")
		.option(SelectEnum::One, "one")
		.option(SelectEnum::Two, "two")
		.option(SelectEnum::Three, "three")
		.cancel(do_cancel)
		.interact()?;

	outro!();

	println!("select enum, label enum {:?}", select_enum);
	println!("multi select enum, label string {:?}", multi_enum);

	Ok(())
}
examples/full.rs (line 26)
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

fn main() -> Result<(), ClackError> {
	println!();
	intro!(" full ".reversed());

	info!("visit the documentation at https://docs.rs/may-clack");

	let do_input = input("input")
		.placeholder("placeholder")
		.cancel(do_cancel)
		.required()?;
	let do_multi_input = multi_input("multi input")
		.max(4)
		.cancel(do_cancel)
		.interact()?;
	let do_confirm = confirm("confirm")
		.prompts("true", "false")
		.cancel(do_cancel)
		.interact()?;
	let do_multi_select = multi_select("multi select")
		.option("opt1", "option 1")
		.option("opt2", "option 2")
		.option_hint("opt3", "option 3", "hint")
		.cancel(do_cancel)
		.interact()?;
	let do_select = select("select")
		.option("val1", "value 1")
		.option("val2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.cancel(do_cancel)
		.interact()?;

	outro!();

	println!("input {:?}", do_input);
	println!("confirm {:?}", do_confirm);
	println!("multi_input {:?}", do_multi_input);
	println!("multi_select {:?}", do_multi_select);
	println!("select {:?}", do_select);

	Ok(())
}
examples/less.rs (line 23)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

fn main() -> Result<(), ClackError> {
	println!();
	intro!(" less ".reversed());

	let select_less = select("less")
		.option("val 1", "value 1")
		.option("val 2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.option("val 4", "value 4")
		.option("val 5", "value 5")
		.less_amt(3)
		.cancel(do_cancel)
		.interact()?;

	let multi_less_noop = multi_select("less")
		.option("val 1", "value 1")
		.option("val 2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.less_amt(5)
		.cancel(do_cancel)
		.interact()?;

	let multi_less = multi_select("less")
		.option("val 1", "value 1")
		.option("val 2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.option("val 4", "value 4")
		.option("val 5", "value 5")
		.less()
		.cancel(do_cancel)
		.interact()?;

	let mut page_up_down = select("page up / down");
	page_up_down.less_max(25);
	page_up_down.cancel(do_cancel);

	for i in 0..100 {
		page_up_down.option(i, i);
	}

	let page_up_down = page_up_down.interact()?;

	outro!();

	println!("page_up_down {:?}", page_up_down);
	println!("select_less {:?}", select_less);
	println!("multi_less_noop {:?}", multi_less_noop);
	println!("multi_less {:?}", multi_less);

	Ok(())
}
source

pub fn option_hint<S: ToString>( &mut self, val: T, label: O, hint: S ) -> &mut Self

Add an option with a hint.

§Examples
use may_clack::multi_select;

let answer = multi_select("message")
    .option("val1", "label 1")
    .option_hint("val2", "label 2", "hint")
    .option("val3", "label 3")
    .interact()?;
println!("answer {:?}", answer);
Examples found in repository?
examples/full.rs (line 28)
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

fn main() -> Result<(), ClackError> {
	println!();
	intro!(" full ".reversed());

	info!("visit the documentation at https://docs.rs/may-clack");

	let do_input = input("input")
		.placeholder("placeholder")
		.cancel(do_cancel)
		.required()?;
	let do_multi_input = multi_input("multi input")
		.max(4)
		.cancel(do_cancel)
		.interact()?;
	let do_confirm = confirm("confirm")
		.prompts("true", "false")
		.cancel(do_cancel)
		.interact()?;
	let do_multi_select = multi_select("multi select")
		.option("opt1", "option 1")
		.option("opt2", "option 2")
		.option_hint("opt3", "option 3", "hint")
		.cancel(do_cancel)
		.interact()?;
	let do_select = select("select")
		.option("val1", "value 1")
		.option("val2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.cancel(do_cancel)
		.interact()?;

	outro!();

	println!("input {:?}", do_input);
	println!("confirm {:?}", do_confirm);
	println!("multi_input {:?}", do_multi_input);
	println!("multi_select {:?}", do_multi_select);
	println!("select {:?}", do_select);

	Ok(())
}
More examples
Hide additional examples
examples/less.rs (line 25)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

fn main() -> Result<(), ClackError> {
	println!();
	intro!(" less ".reversed());

	let select_less = select("less")
		.option("val 1", "value 1")
		.option("val 2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.option("val 4", "value 4")
		.option("val 5", "value 5")
		.less_amt(3)
		.cancel(do_cancel)
		.interact()?;

	let multi_less_noop = multi_select("less")
		.option("val 1", "value 1")
		.option("val 2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.less_amt(5)
		.cancel(do_cancel)
		.interact()?;

	let multi_less = multi_select("less")
		.option("val 1", "value 1")
		.option("val 2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.option("val 4", "value 4")
		.option("val 5", "value 5")
		.less()
		.cancel(do_cancel)
		.interact()?;

	let mut page_up_down = select("page up / down");
	page_up_down.less_max(25);
	page_up_down.cancel(do_cancel);

	for i in 0..100 {
		page_up_down.option(i, i);
	}

	let page_up_down = page_up_down.interact()?;

	outro!();

	println!("page_up_down {:?}", page_up_down);
	println!("select_less {:?}", select_less);
	println!("multi_less_noop {:?}", multi_less_noop);
	println!("multi_less {:?}", multi_less);

	Ok(())
}
source

pub fn options(&mut self, options: Vec<Opt<T, O>>) -> &mut Self

Add multiple options.

§Examples
use may_clack::{multi_select, multi_select::Opt};

let opts = vec![
    Opt::simple("val1", "label 1"),
    Opt::hint("val2", "label 2", "hint"),
    Opt::simple("val3", "label 3")
];

let answer = multi_select("message").options(opts).interact()?;
println!("answer {:?}", answer);
source

pub fn less(&mut self) -> &mut Self

Enable paging with the amount of terminal rows.

§Examples
use may_clack::multi_select;

let answer = multi_select("message")
    .option("val 1", "value 1")
    .option("val 2", "value 2")
    .option_hint("val 3", "value 3", "hint")
    .option("val 4", "value 4")
    .option("val 5", "value 5")
    .less()
    .interact()?;
println!("answer {:?}", answer);
Examples found in repository?
examples/less.rs (line 36)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

fn main() -> Result<(), ClackError> {
	println!();
	intro!(" less ".reversed());

	let select_less = select("less")
		.option("val 1", "value 1")
		.option("val 2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.option("val 4", "value 4")
		.option("val 5", "value 5")
		.less_amt(3)
		.cancel(do_cancel)
		.interact()?;

	let multi_less_noop = multi_select("less")
		.option("val 1", "value 1")
		.option("val 2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.less_amt(5)
		.cancel(do_cancel)
		.interact()?;

	let multi_less = multi_select("less")
		.option("val 1", "value 1")
		.option("val 2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.option("val 4", "value 4")
		.option("val 5", "value 5")
		.less()
		.cancel(do_cancel)
		.interact()?;

	let mut page_up_down = select("page up / down");
	page_up_down.less_max(25);
	page_up_down.cancel(do_cancel);

	for i in 0..100 {
		page_up_down.option(i, i);
	}

	let page_up_down = page_up_down.interact()?;

	outro!();

	println!("page_up_down {:?}", page_up_down);
	println!("select_less {:?}", select_less);
	println!("multi_less_noop {:?}", multi_less_noop);
	println!("multi_less {:?}", multi_less);

	Ok(())
}
source

pub fn less_max(&mut self, max: u16) -> &mut Self

Enable paging with the amount of terminal rows, additionally setting a maximum amount.

§Panics

Panics when the given value is 0.
Panics when called after MultiSelect::less_amt has already been called.

§Examples
use may_clack::multi_select;

let answer = multi_select("message")
    .option("val 1", "value 1")
    .option("val 2", "value 2")
    .option_hint("val 3", "value 3", "hint")
    .option("val 4", "value 4")
    .option("val 5", "value 5")
    .less_max(3)
    .interact()?;
println!("answer {:?}", answer);
source

pub fn less_amt(&mut self, less: u16) -> &mut Self

Enable paging with the specified amount of lines.

§Panics

Panics when the given value is 0.
Panics when called after MultiSelect::less_max has already been called.

§Examples
use may_clack::multi_select;

let answer = multi_select("message")
    .option("val 1", "value 1")
    .option("val 2", "value 2")
    .option_hint("val 3", "value 3", "hint")
    .option("val 4", "value 4")
    .option("val 5", "value 5")
    .less_amt(3)
    .interact()?;
println!("answer {:?}", answer);
Examples found in repository?
examples/less.rs (line 26)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

fn main() -> Result<(), ClackError> {
	println!();
	intro!(" less ".reversed());

	let select_less = select("less")
		.option("val 1", "value 1")
		.option("val 2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.option("val 4", "value 4")
		.option("val 5", "value 5")
		.less_amt(3)
		.cancel(do_cancel)
		.interact()?;

	let multi_less_noop = multi_select("less")
		.option("val 1", "value 1")
		.option("val 2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.less_amt(5)
		.cancel(do_cancel)
		.interact()?;

	let multi_less = multi_select("less")
		.option("val 1", "value 1")
		.option("val 2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.option("val 4", "value 4")
		.option("val 5", "value 5")
		.less()
		.cancel(do_cancel)
		.interact()?;

	let mut page_up_down = select("page up / down");
	page_up_down.less_max(25);
	page_up_down.cancel(do_cancel);

	for i in 0..100 {
		page_up_down.option(i, i);
	}

	let page_up_down = page_up_down.interact()?;

	outro!();

	println!("page_up_down {:?}", page_up_down);
	println!("select_less {:?}", select_less);
	println!("multi_less_noop {:?}", multi_less_noop);
	println!("multi_less {:?}", multi_less);

	Ok(())
}
source

pub fn cancel<F>(&mut self, cancel: F) -> &mut Self
where F: Fn() + 'static,

Specify function to call on cancel.

§Examples
use may_clack::{multi_select, cancel};

let answer = multi_select("select")
    .option("val1", "value 1")
    .option("val2", "value 2")
    .option_hint("val 3", "value 3", "hint")
    .cancel(do_cancel)
    .interact()?;
println!("answer {:?}", answer);

fn do_cancel() {
    cancel!("operation cancelled");
    panic!("operation cancelled");
}
Examples found in repository?
examples/single.rs (line 13)
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

fn main() -> Result<(), ClackError> {
	println!();
	intro!(" single ".reversed());
	let do_single_select = select("single")
		.option("one", "one")
		.cancel(do_cancel)
		.interact()?;
	let do_single_multi = multi_select("single")
		.option("one", "one")
		.cancel(do_cancel)
		.interact()?;

	outro!();

	println!("select {:?}", do_single_select);
	println!("multi {:?}", do_single_multi);

	Ok(())
}
More examples
Hide additional examples
examples/generic_select.rs (line 37)
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

fn main() -> Result<(), ClackError> {
	println!();
	intro!(" generic select ".reversed());

	let select_enum = select("select enum")
		.option(SelectEnum::One, SelectEnum::One)
		.option(SelectEnum::Two, SelectEnum::Two)
		.option(SelectEnum::Three, SelectEnum::Three)
		.cancel(do_cancel)
		.interact()?;

	let multi_enum = multi_select("multi_select enum")
		.option(SelectEnum::One, "one")
		.option(SelectEnum::Two, "two")
		.option(SelectEnum::Three, "three")
		.cancel(do_cancel)
		.interact()?;

	outro!();

	println!("select enum, label enum {:?}", select_enum);
	println!("multi select enum, label string {:?}", multi_enum);

	Ok(())
}
examples/full.rs (line 29)
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

fn main() -> Result<(), ClackError> {
	println!();
	intro!(" full ".reversed());

	info!("visit the documentation at https://docs.rs/may-clack");

	let do_input = input("input")
		.placeholder("placeholder")
		.cancel(do_cancel)
		.required()?;
	let do_multi_input = multi_input("multi input")
		.max(4)
		.cancel(do_cancel)
		.interact()?;
	let do_confirm = confirm("confirm")
		.prompts("true", "false")
		.cancel(do_cancel)
		.interact()?;
	let do_multi_select = multi_select("multi select")
		.option("opt1", "option 1")
		.option("opt2", "option 2")
		.option_hint("opt3", "option 3", "hint")
		.cancel(do_cancel)
		.interact()?;
	let do_select = select("select")
		.option("val1", "value 1")
		.option("val2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.cancel(do_cancel)
		.interact()?;

	outro!();

	println!("input {:?}", do_input);
	println!("confirm {:?}", do_confirm);
	println!("multi_input {:?}", do_multi_input);
	println!("multi_select {:?}", do_multi_select);
	println!("select {:?}", do_select);

	Ok(())
}
examples/less.rs (line 27)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

fn main() -> Result<(), ClackError> {
	println!();
	intro!(" less ".reversed());

	let select_less = select("less")
		.option("val 1", "value 1")
		.option("val 2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.option("val 4", "value 4")
		.option("val 5", "value 5")
		.less_amt(3)
		.cancel(do_cancel)
		.interact()?;

	let multi_less_noop = multi_select("less")
		.option("val 1", "value 1")
		.option("val 2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.less_amt(5)
		.cancel(do_cancel)
		.interact()?;

	let multi_less = multi_select("less")
		.option("val 1", "value 1")
		.option("val 2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.option("val 4", "value 4")
		.option("val 5", "value 5")
		.less()
		.cancel(do_cancel)
		.interact()?;

	let mut page_up_down = select("page up / down");
	page_up_down.less_max(25);
	page_up_down.cancel(do_cancel);

	for i in 0..100 {
		page_up_down.option(i, i);
	}

	let page_up_down = page_up_down.interact()?;

	outro!();

	println!("page_up_down {:?}", page_up_down);
	println!("select_less {:?}", select_less);
	println!("multi_less_noop {:?}", multi_less_noop);
	println!("multi_less {:?}", multi_less);

	Ok(())
}
source

pub fn interact(&self) -> Result<Vec<T>, ClackError>

Wait for the user to submit the selected options.

§Examples
use may_clack::multi_select;

let answer = multi_select("select")
    .option("val1", "value 1")
    .option("val2", "value 2")
    .option_hint("val 3", "value 3", "hint")
    .interact()?;
println!("answer {:?}", answer);
Examples found in repository?
examples/single.rs (line 14)
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

fn main() -> Result<(), ClackError> {
	println!();
	intro!(" single ".reversed());
	let do_single_select = select("single")
		.option("one", "one")
		.cancel(do_cancel)
		.interact()?;
	let do_single_multi = multi_select("single")
		.option("one", "one")
		.cancel(do_cancel)
		.interact()?;

	outro!();

	println!("select {:?}", do_single_select);
	println!("multi {:?}", do_single_multi);

	Ok(())
}
More examples
Hide additional examples
examples/generic_select.rs (line 38)
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

fn main() -> Result<(), ClackError> {
	println!();
	intro!(" generic select ".reversed());

	let select_enum = select("select enum")
		.option(SelectEnum::One, SelectEnum::One)
		.option(SelectEnum::Two, SelectEnum::Two)
		.option(SelectEnum::Three, SelectEnum::Three)
		.cancel(do_cancel)
		.interact()?;

	let multi_enum = multi_select("multi_select enum")
		.option(SelectEnum::One, "one")
		.option(SelectEnum::Two, "two")
		.option(SelectEnum::Three, "three")
		.cancel(do_cancel)
		.interact()?;

	outro!();

	println!("select enum, label enum {:?}", select_enum);
	println!("multi select enum, label string {:?}", multi_enum);

	Ok(())
}
examples/full.rs (line 30)
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

fn main() -> Result<(), ClackError> {
	println!();
	intro!(" full ".reversed());

	info!("visit the documentation at https://docs.rs/may-clack");

	let do_input = input("input")
		.placeholder("placeholder")
		.cancel(do_cancel)
		.required()?;
	let do_multi_input = multi_input("multi input")
		.max(4)
		.cancel(do_cancel)
		.interact()?;
	let do_confirm = confirm("confirm")
		.prompts("true", "false")
		.cancel(do_cancel)
		.interact()?;
	let do_multi_select = multi_select("multi select")
		.option("opt1", "option 1")
		.option("opt2", "option 2")
		.option_hint("opt3", "option 3", "hint")
		.cancel(do_cancel)
		.interact()?;
	let do_select = select("select")
		.option("val1", "value 1")
		.option("val2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.cancel(do_cancel)
		.interact()?;

	outro!();

	println!("input {:?}", do_input);
	println!("confirm {:?}", do_confirm);
	println!("multi_input {:?}", do_multi_input);
	println!("multi_select {:?}", do_multi_select);
	println!("select {:?}", do_select);

	Ok(())
}
examples/less.rs (line 28)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

fn main() -> Result<(), ClackError> {
	println!();
	intro!(" less ".reversed());

	let select_less = select("less")
		.option("val 1", "value 1")
		.option("val 2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.option("val 4", "value 4")
		.option("val 5", "value 5")
		.less_amt(3)
		.cancel(do_cancel)
		.interact()?;

	let multi_less_noop = multi_select("less")
		.option("val 1", "value 1")
		.option("val 2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.less_amt(5)
		.cancel(do_cancel)
		.interact()?;

	let multi_less = multi_select("less")
		.option("val 1", "value 1")
		.option("val 2", "value 2")
		.option_hint("val 3", "value 3", "hint")
		.option("val 4", "value 4")
		.option("val 5", "value 5")
		.less()
		.cancel(do_cancel)
		.interact()?;

	let mut page_up_down = select("page up / down");
	page_up_down.less_max(25);
	page_up_down.cancel(do_cancel);

	for i in 0..100 {
		page_up_down.option(i, i);
	}

	let page_up_down = page_up_down.interact()?;

	outro!();

	println!("page_up_down {:?}", page_up_down);
	println!("select_less {:?}", select_less);
	println!("multi_less_noop {:?}", multi_less_noop);
	println!("multi_less {:?}", multi_less);

	Ok(())
}

Auto Trait Implementations§

§

impl<M, T, O> Freeze for MultiSelect<M, T, O>
where M: Freeze,

§

impl<M, T, O> !RefUnwindSafe for MultiSelect<M, T, O>

§

impl<M, T, O> !Send for MultiSelect<M, T, O>

§

impl<M, T, O> !Sync for MultiSelect<M, T, O>

§

impl<M, T, O> Unpin for MultiSelect<M, T, O>
where M: Unpin, T: Unpin, O: Unpin,

§

impl<M, T, O> !UnwindSafe for MultiSelect<M, T, O>

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<D> OwoColorize for D

source§

fn fg<C>(&self) -> FgColorDisplay<'_, C, Self>
where C: Color,

Set the foreground color generically Read more
source§

fn bg<C>(&self) -> BgColorDisplay<'_, C, Self>
where C: Color,

Set the background color generically. Read more
source§

fn black(&self) -> FgColorDisplay<'_, Black, Self>

Change the foreground color to black
source§

fn on_black(&self) -> BgColorDisplay<'_, Black, Self>

Change the background color to black
source§

fn red(&self) -> FgColorDisplay<'_, Red, Self>

Change the foreground color to red
source§

fn on_red(&self) -> BgColorDisplay<'_, Red, Self>

Change the background color to red
source§

fn green(&self) -> FgColorDisplay<'_, Green, Self>

Change the foreground color to green
source§

fn on_green(&self) -> BgColorDisplay<'_, Green, Self>

Change the background color to green
source§

fn yellow(&self) -> FgColorDisplay<'_, Yellow, Self>

Change the foreground color to yellow
source§

fn on_yellow(&self) -> BgColorDisplay<'_, Yellow, Self>

Change the background color to yellow
source§

fn blue(&self) -> FgColorDisplay<'_, Blue, Self>

Change the foreground color to blue
source§

fn on_blue(&self) -> BgColorDisplay<'_, Blue, Self>

Change the background color to blue
source§

fn magenta(&self) -> FgColorDisplay<'_, Magenta, Self>

Change the foreground color to magenta
source§

fn on_magenta(&self) -> BgColorDisplay<'_, Magenta, Self>

Change the background color to magenta
source§

fn purple(&self) -> FgColorDisplay<'_, Magenta, Self>

Change the foreground color to purple
source§

fn on_purple(&self) -> BgColorDisplay<'_, Magenta, Self>

Change the background color to purple
source§

fn cyan(&self) -> FgColorDisplay<'_, Cyan, Self>

Change the foreground color to cyan
source§

fn on_cyan(&self) -> BgColorDisplay<'_, Cyan, Self>

Change the background color to cyan
source§

fn white(&self) -> FgColorDisplay<'_, White, Self>

Change the foreground color to white
source§

fn on_white(&self) -> BgColorDisplay<'_, White, Self>

Change the background color to white
source§

fn default_color(&self) -> FgColorDisplay<'_, Default, Self>

Change the foreground color to the terminal default
source§

fn on_default_color(&self) -> BgColorDisplay<'_, Default, Self>

Change the background color to the terminal default
source§

fn bright_black(&self) -> FgColorDisplay<'_, BrightBlack, Self>

Change the foreground color to bright black
source§

fn on_bright_black(&self) -> BgColorDisplay<'_, BrightBlack, Self>

Change the background color to bright black
source§

fn bright_red(&self) -> FgColorDisplay<'_, BrightRed, Self>

Change the foreground color to bright red
source§

fn on_bright_red(&self) -> BgColorDisplay<'_, BrightRed, Self>

Change the background color to bright red
source§

fn bright_green(&self) -> FgColorDisplay<'_, BrightGreen, Self>

Change the foreground color to bright green
source§

fn on_bright_green(&self) -> BgColorDisplay<'_, BrightGreen, Self>

Change the background color to bright green
source§

fn bright_yellow(&self) -> FgColorDisplay<'_, BrightYellow, Self>

Change the foreground color to bright yellow
source§

fn on_bright_yellow(&self) -> BgColorDisplay<'_, BrightYellow, Self>

Change the background color to bright yellow
source§

fn bright_blue(&self) -> FgColorDisplay<'_, BrightBlue, Self>

Change the foreground color to bright blue
source§

fn on_bright_blue(&self) -> BgColorDisplay<'_, BrightBlue, Self>

Change the background color to bright blue
source§

fn bright_magenta(&self) -> FgColorDisplay<'_, BrightMagenta, Self>

Change the foreground color to bright magenta
source§

fn on_bright_magenta(&self) -> BgColorDisplay<'_, BrightMagenta, Self>

Change the background color to bright magenta
source§

fn bright_purple(&self) -> FgColorDisplay<'_, BrightMagenta, Self>

Change the foreground color to bright purple
source§

fn on_bright_purple(&self) -> BgColorDisplay<'_, BrightMagenta, Self>

Change the background color to bright purple
source§

fn bright_cyan(&self) -> FgColorDisplay<'_, BrightCyan, Self>

Change the foreground color to bright cyan
source§

fn on_bright_cyan(&self) -> BgColorDisplay<'_, BrightCyan, Self>

Change the background color to bright cyan
source§

fn bright_white(&self) -> FgColorDisplay<'_, BrightWhite, Self>

Change the foreground color to bright white
source§

fn on_bright_white(&self) -> BgColorDisplay<'_, BrightWhite, Self>

Change the background color to bright white
source§

fn bold(&self) -> BoldDisplay<'_, Self>

Make the text bold
source§

fn dimmed(&self) -> DimDisplay<'_, Self>

Make the text dim
source§

fn italic(&self) -> ItalicDisplay<'_, Self>

Make the text italicized
source§

fn underline(&self) -> UnderlineDisplay<'_, Self>

Make the text italicized
Make the text blink
Make the text blink (but fast!)
source§

fn reversed(&self) -> ReversedDisplay<'_, Self>

Swap the foreground and background colors
source§

fn hidden(&self) -> HiddenDisplay<'_, Self>

Hide the text
source§

fn strikethrough(&self) -> StrikeThroughDisplay<'_, Self>

Cross out the text
source§

fn color<Color>(&self, color: Color) -> FgDynColorDisplay<'_, Color, Self>
where Color: DynColor,

Set the foreground color at runtime. Only use if you do not know which color will be used at compile-time. If the color is constant, use either OwoColorize::fg or a color-specific method, such as OwoColorize::green, Read more
source§

fn on_color<Color>(&self, color: Color) -> BgDynColorDisplay<'_, Color, Self>
where Color: DynColor,

Set the background color at runtime. Only use if you do not know what color to use at compile-time. If the color is constant, use either OwoColorize::bg or a color-specific method, such as OwoColorize::on_yellow, Read more
source§

fn fg_rgb<const R: u8, const G: u8, const B: u8>( &self ) -> FgColorDisplay<'_, CustomColor<R, G, B>, Self>

Set the foreground color to a specific RGB value.
source§

fn bg_rgb<const R: u8, const G: u8, const B: u8>( &self ) -> BgColorDisplay<'_, CustomColor<R, G, B>, Self>

Set the background color to a specific RGB value.
source§

fn truecolor(&self, r: u8, g: u8, b: u8) -> FgDynColorDisplay<'_, Rgb, Self>

Sets the foreground color to an RGB value.
source§

fn on_truecolor(&self, r: u8, g: u8, b: u8) -> BgDynColorDisplay<'_, Rgb, Self>

Sets the background color to an RGB value.
source§

fn style(&self, style: Style) -> Styled<&Self>

Apply a runtime-determined style
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.