Skip to main content

ArcBiConsumer

qubit_function::consumers::bi_consumer

Struct ArcBiConsumer 

Source 
pub struct ArcBiConsumer<T, U> { /* private fields */ }
Expand description

ArcBiConsumer struct

A non-mutating bi-consumer implementation based on Arc<dyn Fn(&T, &U) + Send + Sync> for thread-safe shared ownership scenarios. The wrapper does not need Mutex because it only invokes a shared Fn.

§Features

  • Shared Ownership: Cloneable via Arc, multiple owners allowed
  • Thread-Safe: Implements Send + Sync, safe for concurrent use
  • Lock-free Wrapper: No Mutex protection needed by the wrapper
  • Non-Consuming API: and_then borrows &self, original remains usable

§Use Cases

Choose ArcBiConsumer when:

  • Need to share non-mutating bi-consumer across multiple threads
  • Pure observation operations like logging, monitoring, notifications
  • Need high-concurrency reads without lock overhead

§Performance Advantages

Compared to ArcStatefulBiConsumer, ArcBiConsumer has no Mutex locking overhead, resulting in better performance in high-concurrency observation scenarios.

§Examples

use qubit_function::{BiConsumer, ArcBiConsumer};

let consumer = ArcBiConsumer::new(|x: &i32, y: &i32| {
    println!("Sum: {}", x + y);
});
let clone = consumer.clone();

consumer.accept(&5, &3);
clone.accept(&10, &20);

Implementations§

Source§

impl<T, U> ArcBiConsumer<T, U>

Source

pub fn new<F>(f: F) -> Self
where F: Fn(&T, &U) + Send + Sync + 'static,

Creates a new bi-consumer.

Wraps the provided closure in the appropriate smart pointer type for this bi-consumer implementation.

Examples found in repository?
examples/consumers/bi_consumer_observation_demo.rs (lines 59-62)
30fn main() {
31    println!("=== BiConsumer Observation Demo ===\n");
32
33    // 1. BoxBiConsumer - Single ownership
34    println!("1. BoxBiConsumer - Single ownership:");
35    let box_consumer = BoxBiConsumer::new(|x: &i32, y: &i32| {
36        println!("  Values: x={}, y={}, sum={}", x, y, x + y);
37    });
38    box_consumer.accept(&10, &5);
39    println!();
40
41    // 2. Method chaining with BoxBiConsumer
42    println!("2. BoxBiConsumer with method chaining:");
43    let chained = BoxBiConsumer::new(|x: &i32, y: &i32| {
44        println!("  First operation: x={}, y={}", x, y);
45    })
46    .and_then(|x: &i32, y: &i32| {
47        println!("  Second operation: sum={}", x + y);
48    })
49    .and_then(|x: &i32, y: &i32| {
50        println!("  Third operation: product={}", x * y);
51    });
52    chained.accept(&5, &3);
53    println!();
54
55    // 3. ArcBiConsumer - Thread-safe shared ownership
56    println!("3. ArcBiConsumer - Thread-safe shared ownership:");
57    let counter = Arc::new(AtomicUsize::new(0));
58    let c = counter.clone();
59    let arc_consumer = ArcBiConsumer::new(move |x: &i32, y: &i32| {
60        c.fetch_add(1, Ordering::SeqCst);
61        println!("  Thread {:?}: sum={}", thread::current().id(), x + y);
62    });
63
64    let consumer1 = arc_consumer.clone();
65    let consumer2 = arc_consumer.clone();
66
67    let handle1 = thread::spawn(move || {
68        consumer1.accept(&10, &5);
69    });
70
71    let handle2 = thread::spawn(move || {
72        consumer2.accept(&20, &8);
73    });
74
75    handle1.join().unwrap();
76    handle2.join().unwrap();
77    println!("  Total calls: {}\n", counter.load(Ordering::SeqCst));
78
79    // 4. RcBiConsumer - Single-threaded shared ownership
80    println!("4. RcBiConsumer - Single-threaded shared ownership:");
81    let counter = Rc::new(std::cell::Cell::new(0));
82    let c = counter.clone();
83    let rc_consumer = RcBiConsumer::new(move |x: &i32, y: &i32| {
84        c.set(c.get() + 1);
85        println!("  Call {}: sum={}", c.get(), x + y);
86    });
87
88    let clone1 = rc_consumer.clone();
89    let clone2 = rc_consumer.clone();
90
91    clone1.accept(&5, &3);
92    clone2.accept(&7, &2);
93    println!("  Total calls: {}\n", counter.get());
94
95    // 5. Working with closures directly
96    println!("5. Working with closures directly:");
97    let closure = |x: &i32, y: &i32| {
98        println!("  x={}, y={}, product={}", x, y, x * y);
99    };
100    closure.accept(&10, &20);
101    println!();
102
103    // 6. Pure observation - logging
104    println!("6. Pure observation - logging:");
105    let logger = BoxBiConsumer::new(|x: &i32, y: &i32| {
106        println!("  [LOG] Processing pair: ({}, {})", x, y);
107    });
108    logger.accept(&5, &3);
109    logger.accept(&10, &7);
110    println!();
111
112    // 7. Chaining observations
113    println!("7. Chaining observations:");
114    let log_input = BoxBiConsumer::new(|x: &i32, y: &i32| {
115        println!("  [INPUT] x={}, y={}", x, y);
116    });
117    let log_sum = BoxBiConsumer::new(|x: &i32, y: &i32| {
118        println!("  [SUM] {}", x + y);
119    });
120    let log_product = BoxBiConsumer::new(|x: &i32, y: &i32| {
121        println!("  [PRODUCT] {}", x * y);
122    });
123
124    let chained = log_input.and_then(log_sum).and_then(log_product);
125    chained.accept(&5, &3);
126    println!();
127
128    // 8. ArcBiConsumer - Reusability
129    println!("8. ArcBiConsumer - Reusability:");
130    let first = ArcBiConsumer::new(|x: &i32, y: &i32| {
131        println!("  First: x={}, y={}", x, y);
132    });
133    let second = ArcBiConsumer::new(|x: &i32, y: &i32| {
134        println!("  Second: sum={}", x + y);
135    });
136
137    // Both first and second can be reused after chaining
138    let chained1 = first.and_then(second.clone());
139    let chained2 = first.and_then(second.clone());
140
141    println!("  Using chained1:");
142    chained1.accept(&5, &3);
143
144    println!("  Using chained2:");
145    chained2.accept(&10, &2);
146    println!();
147
148    // 9. Name support
149    println!("9. Name support:");
150    let mut named_consumer = BoxBiConsumer::<i32, i32>::noop();
151    println!("  Initial name: {:?}", named_consumer.name());
152
153    named_consumer.set_name("sum_logger");
154    println!("  After setting name: {:?}", named_consumer.name());
155    println!("  Display: {}\n", named_consumer);
156
157    // 10. No-op consumer
158    println!("10. No-op consumer:");
159    let noop = BoxBiConsumer::<i32, i32>::noop();
160    noop.accept(&42, &10);
161    println!("  No-op completed (no output expected)\n");
162
163    println!("=== Demo Complete ===");
164}
More examples
Hide additional examples
examples/consumers/bi_consumer_demo.rs (lines 66-69)
32fn main() {
33    println!("=== BiConsumer Demo ===\n");
34
35    // 1. BoxBiConsumer - Single ownership
36    println!("1. BoxBiConsumer - Single ownership:");
37    let log = Arc::new(Mutex::new(Vec::new()));
38    let l = log.clone();
39    let box_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
40        println!("  Processing: x={}, y={}", x, y);
41        l.lock().unwrap().push(*x + *y);
42    });
43    box_consumer.accept(&10, &5);
44    println!("  Result log: {:?}\n", *log.lock().unwrap());
45
46    // 2. Method chaining with BoxBiConsumer
47    println!("2. BoxBiConsumer with method chaining:");
48    let log = Arc::new(Mutex::new(Vec::new()));
49    let l1 = log.clone();
50    let l2 = log.clone();
51    let chained = BoxBiConsumer::new(move |x: &i32, y: &i32| {
52        l1.lock().unwrap().push(*x + *y);
53        println!("  After first operation: sum = {}", x + y);
54    })
55    .and_then(move |x: &i32, y: &i32| {
56        l2.lock().unwrap().push(*x * *y);
57        println!("  After second operation: product = {}", x * y);
58    });
59    chained.accept(&5, &3);
60    println!("  Final log: {:?}\n", *log.lock().unwrap());
61
62    // 3. ArcBiConsumer - Thread-safe shared ownership
63    println!("3. ArcBiConsumer - Thread-safe shared ownership:");
64    let log = Arc::new(Mutex::new(Vec::new()));
65    let l = log.clone();
66    let arc_consumer = ArcBiConsumer::new(move |x: &i32, y: &i32| {
67        l.lock().unwrap().push(*x + *y);
68        println!("  Thread {:?}: sum = {}", thread::current().id(), x + y);
69    });
70
71    let consumer1 = arc_consumer.clone();
72    let consumer2 = arc_consumer.clone();
73
74    let handle1 = thread::spawn(move || {
75        let c = consumer1;
76        c.accept(&10, &5);
77    });
78
79    let handle2 = thread::spawn(move || {
80        let c = consumer2;
81        c.accept(&20, &8);
82    });
83
84    handle1.join().unwrap();
85    handle2.join().unwrap();
86    println!("  Final log: {:?}\n", *log.lock().unwrap());
87
88    // 4. RcBiConsumer - Single-threaded shared ownership
89    println!("4. RcBiConsumer - Single-threaded shared ownership:");
90    let log = Rc::new(RefCell::new(Vec::new()));
91    let l = log.clone();
92    let rc_consumer = RcBiConsumer::new(move |x: &i32, y: &i32| {
93        l.borrow_mut().push(*x + *y);
94    });
95
96    let clone1 = rc_consumer.clone();
97    let clone2 = rc_consumer.clone();
98
99    clone1.accept(&5, &3);
100    println!("  After first use: {:?}", *log.borrow());
101
102    clone2.accept(&7, &2);
103    println!("  After second use: {:?}\n", *log.borrow());
104
105    // 5. Working with closures directly
106    println!("5. Working with closures directly:");
107    let log = Arc::new(Mutex::new(Vec::new()));
108    let l = log.clone();
109    let closure = move |x: &i32, y: &i32| {
110        let sum = *x + *y;
111        l.lock().unwrap().push(sum);
112    };
113    closure.accept(&10, &20);
114    println!("  After closure: {:?}\n", *log.lock().unwrap());
115
116    // 6. Conditional BiConsumer
117    println!("6. Conditional BiConsumer:");
118    let log = Arc::new(Mutex::new(Vec::new()));
119    let l = log.clone();
120    let mut conditional = BoxStatefulBiConsumer::new(move |x: &i32, y: &i32| {
121        l.lock().unwrap().push(*x + *y);
122    })
123    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);
124
125    conditional.accept(&5, &3);
126    println!("  Positive values: {:?}", *log.lock().unwrap());
127
128    conditional.accept(&-5, &3);
129    println!("  Negative value (unchanged): {:?}\n", *log.lock().unwrap());
130
131    // 7. Conditional branch BiConsumer
132    println!("7. Conditional branch BiConsumer:");
133    let log = Arc::new(Mutex::new(Vec::new()));
134    let l1 = log.clone();
135    let l2 = log.clone();
136    let mut branch = BoxStatefulBiConsumer::new(move |x: &i32, _y: &i32| {
137        l1.lock().unwrap().push(*x);
138    })
139    .when(|x: &i32, y: &i32| *x > *y)
140    .or_else(move |_x: &i32, y: &i32| {
141        l2.lock().unwrap().push(*y);
142    });
143
144    branch.accept(&15, &10);
145    println!("  When x > y: {:?}", *log.lock().unwrap());
146
147    branch.accept(&5, &10);
148    println!("  When x <= y: {:?}\n", *log.lock().unwrap());
149
150    // 8. Accumulating statistics
151    println!("8. Accumulating statistics:");
152    let count = Arc::new(Mutex::new(0));
153    let sum = Arc::new(Mutex::new(0));
154    let c = count.clone();
155    let s = sum.clone();
156    let stats_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
157        *c.lock().unwrap() += 1;
158        *s.lock().unwrap() += x + y;
159    });
160
161    stats_consumer.accept(&5, &3);
162    stats_consumer.accept(&10, &2);
163    stats_consumer.accept(&7, &8);
164
165    println!("  Count: {}", *count.lock().unwrap());
166    println!("  Sum: {}\n", *sum.lock().unwrap());
167
168    // 9. Name support
169    println!("9. Name support:");
170    let mut named_consumer = BoxBiConsumer::<i32, i32>::noop();
171    println!("  Initial name: {:?}", named_consumer.name());
172
173    named_consumer.set_name("sum_calculator");
174    println!("  After setting name: {:?}", named_consumer.name());
175    println!("  Display: {}\n", named_consumer);
176
177    println!("=== Demo Complete ===");
178}
Source

pub fn new_with_name<F>(name: &str, f: F) -> Self
where F: Fn(&T, &U) + Send + Sync + 'static,

Creates a new named bi-consumer.

Wraps the provided closure and assigns it a name, which is useful for debugging and logging purposes.

Source

pub fn new_with_optional_name<F>(f: F, name: Option<String>) -> Self
where F: Fn(&T, &U) + Send + Sync + 'static,

Creates a new named bi-consumer with an optional name.

Wraps the provided closure and assigns it an optional name.

Source

pub fn name(&self) -> Option<&str>

Gets the name of this bi-consumer.

§Returns

Returns Some(&str) if a name was set, None otherwise.

Source

pub fn set_name(&mut self, name: &str)

Sets the name of this bi-consumer.

§Parameters
  • name - The name to set for this bi-consumer
Source

pub fn clear_name(&mut self)

Clears the name of this bi-consumer.

Source

pub fn noop() -> Self

Creates a no-operation bi-consumer.

Creates a bi-consumer that does nothing when called. Useful for default values or placeholder implementations.

§Returns

Returns a new bi-consumer instance that performs no operation.

Source

pub fn when<P>(&self, predicate: P) -> ArcConditionalBiConsumer<T, U>
where T: 'static, U: 'static, P: BiPredicate<T, U> + Send + Sync + 'static,

Creates a conditional bi-consumer

Wraps this bi-consumer with a bi-predicate condition, creating a new conditional bi-consumer that will only execute the original bi-consumer when the predicate evaluates to true.

§Parameters
  • predicate - The condition that must be satisfied for the bi-consumer to execute
§Returns

Returns a conditional bi-consumer that executes this bi-consumer only when the predicate is satisfied

§Examples
use qubit_function::{ArcBiConsumer, BiConsumer};
let consumer = ArcBiConsumer::new(|x: &i32, y: &i32| println!("{}", x + y));
let conditional = consumer.when(|x: &i32, y: &i32| *x > 0 && *y > 0);

conditional.accept(&5, &3);  // prints: 8
conditional.accept(&-5, &3); // prints nothing
Source

pub fn and_then<C>(&self, after: C) -> ArcBiConsumer<T, U>
where T: 'static, U: 'static, C: BiConsumer<T, U> + Send + Sync + 'static,

Chains another bi-consumer in sequence

Combines this bi-consumer with another bi-consumer into a new bi-consumer that executes both bi-consumers in sequence. The returned bi-consumer first executes this bi-consumer, then unconditionally executes the after bi-consumer.

§Parameters
  • after - The bi-consumer to execute after this one (always executed)
§Returns

Returns a new bi-consumer that executes both bi-consumers in sequence

§Examples
use qubit_function::{ArcBiConsumer, BiConsumer};
let consumer1 = ArcBiConsumer::new(|x: &i32, y: &i32| print!("first: {}", x + y));
let consumer2 = ArcBiConsumer::new(|x: &i32, y: &i32| println!(" second: {}", x * y));

let chained = consumer1.and_then(consumer2);

chained.accept(&5, &3);  // prints: first: 8 second: 15
Examples found in repository?
examples/consumers/bi_consumer_observation_demo.rs (line 138)
30fn main() {
31    println!("=== BiConsumer Observation Demo ===\n");
32
33    // 1. BoxBiConsumer - Single ownership
34    println!("1. BoxBiConsumer - Single ownership:");
35    let box_consumer = BoxBiConsumer::new(|x: &i32, y: &i32| {
36        println!("  Values: x={}, y={}, sum={}", x, y, x + y);
37    });
38    box_consumer.accept(&10, &5);
39    println!();
40
41    // 2. Method chaining with BoxBiConsumer
42    println!("2. BoxBiConsumer with method chaining:");
43    let chained = BoxBiConsumer::new(|x: &i32, y: &i32| {
44        println!("  First operation: x={}, y={}", x, y);
45    })
46    .and_then(|x: &i32, y: &i32| {
47        println!("  Second operation: sum={}", x + y);
48    })
49    .and_then(|x: &i32, y: &i32| {
50        println!("  Third operation: product={}", x * y);
51    });
52    chained.accept(&5, &3);
53    println!();
54
55    // 3. ArcBiConsumer - Thread-safe shared ownership
56    println!("3. ArcBiConsumer - Thread-safe shared ownership:");
57    let counter = Arc::new(AtomicUsize::new(0));
58    let c = counter.clone();
59    let arc_consumer = ArcBiConsumer::new(move |x: &i32, y: &i32| {
60        c.fetch_add(1, Ordering::SeqCst);
61        println!("  Thread {:?}: sum={}", thread::current().id(), x + y);
62    });
63
64    let consumer1 = arc_consumer.clone();
65    let consumer2 = arc_consumer.clone();
66
67    let handle1 = thread::spawn(move || {
68        consumer1.accept(&10, &5);
69    });
70
71    let handle2 = thread::spawn(move || {
72        consumer2.accept(&20, &8);
73    });
74
75    handle1.join().unwrap();
76    handle2.join().unwrap();
77    println!("  Total calls: {}\n", counter.load(Ordering::SeqCst));
78
79    // 4. RcBiConsumer - Single-threaded shared ownership
80    println!("4. RcBiConsumer - Single-threaded shared ownership:");
81    let counter = Rc::new(std::cell::Cell::new(0));
82    let c = counter.clone();
83    let rc_consumer = RcBiConsumer::new(move |x: &i32, y: &i32| {
84        c.set(c.get() + 1);
85        println!("  Call {}: sum={}", c.get(), x + y);
86    });
87
88    let clone1 = rc_consumer.clone();
89    let clone2 = rc_consumer.clone();
90
91    clone1.accept(&5, &3);
92    clone2.accept(&7, &2);
93    println!("  Total calls: {}\n", counter.get());
94
95    // 5. Working with closures directly
96    println!("5. Working with closures directly:");
97    let closure = |x: &i32, y: &i32| {
98        println!("  x={}, y={}, product={}", x, y, x * y);
99    };
100    closure.accept(&10, &20);
101    println!();
102
103    // 6. Pure observation - logging
104    println!("6. Pure observation - logging:");
105    let logger = BoxBiConsumer::new(|x: &i32, y: &i32| {
106        println!("  [LOG] Processing pair: ({}, {})", x, y);
107    });
108    logger.accept(&5, &3);
109    logger.accept(&10, &7);
110    println!();
111
112    // 7. Chaining observations
113    println!("7. Chaining observations:");
114    let log_input = BoxBiConsumer::new(|x: &i32, y: &i32| {
115        println!("  [INPUT] x={}, y={}", x, y);
116    });
117    let log_sum = BoxBiConsumer::new(|x: &i32, y: &i32| {
118        println!("  [SUM] {}", x + y);
119    });
120    let log_product = BoxBiConsumer::new(|x: &i32, y: &i32| {
121        println!("  [PRODUCT] {}", x * y);
122    });
123
124    let chained = log_input.and_then(log_sum).and_then(log_product);
125    chained.accept(&5, &3);
126    println!();
127
128    // 8. ArcBiConsumer - Reusability
129    println!("8. ArcBiConsumer - Reusability:");
130    let first = ArcBiConsumer::new(|x: &i32, y: &i32| {
131        println!("  First: x={}, y={}", x, y);
132    });
133    let second = ArcBiConsumer::new(|x: &i32, y: &i32| {
134        println!("  Second: sum={}", x + y);
135    });
136
137    // Both first and second can be reused after chaining
138    let chained1 = first.and_then(second.clone());
139    let chained2 = first.and_then(second.clone());
140
141    println!("  Using chained1:");
142    chained1.accept(&5, &3);
143
144    println!("  Using chained2:");
145    chained2.accept(&10, &2);
146    println!();
147
148    // 9. Name support
149    println!("9. Name support:");
150    let mut named_consumer = BoxBiConsumer::<i32, i32>::noop();
151    println!("  Initial name: {:?}", named_consumer.name());
152
153    named_consumer.set_name("sum_logger");
154    println!("  After setting name: {:?}", named_consumer.name());
155    println!("  Display: {}\n", named_consumer);
156
157    // 10. No-op consumer
158    println!("10. No-op consumer:");
159    let noop = BoxBiConsumer::<i32, i32>::noop();
160    noop.accept(&42, &10);
161    println!("  No-op completed (no output expected)\n");
162
163    println!("=== Demo Complete ===");
164}

Trait Implementations§

Source§

impl<T, U> BiConsumer<T, U> for ArcBiConsumer<T, U>

Source§

fn accept(&self, first: &T, second: &U)

Performs the non-mutating consumption operation Read more
Source§

fn into_box(self) -> BoxBiConsumer<T, U>
where Self: 'static,

Converts to BoxBiConsumer Read more
Source§

fn into_rc(self) -> RcBiConsumer<T, U>
where Self: 'static,

Converts to RcBiConsumer Read more
Source§

fn into_arc(self) -> ArcBiConsumer<T, U>

Converts to ArcBiConsumer Read more
Source§

fn into_fn(self) -> impl Fn(&T, &U)

Converts non-mutating bi-consumer to a closure Read more
Source§

fn into_once(self) -> BoxBiConsumerOnce<T, U>
where Self: 'static,

Convert to BiConsumerOnce Read more
Source§

fn to_box(&self) -> BoxBiConsumer<T, U>
where Self: 'static,

Converts to BoxBiConsumer (without consuming self) Read more
Source§

fn to_rc(&self) -> RcBiConsumer<T, U>
where Self: 'static,

Converts to RcBiConsumer (without consuming self) Read more
Source§

fn to_arc(&self) -> ArcBiConsumer<T, U>

Converts to ArcBiConsumer (without consuming self) Read more
Source§

fn to_fn(&self) -> impl Fn(&T, &U)

Converts to a closure (without consuming self) Read more
Source§

fn to_once(&self) -> BoxBiConsumerOnce<T, U>
where Self: 'static,

Convert to BiConsumerOnce without consuming self Read more
Source§

impl<T, U> Clone for ArcBiConsumer<T, U>

Source§

fn clone(&self) -> Self

Returns a duplicate of the value. Read more
1.0.0 · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
Source§

impl<T, U> Debug for ArcBiConsumer<T, U>

Source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
Source§

impl<T, U> Display for ArcBiConsumer<T, U>

Source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

Auto Trait Implementations§

§

impl<T, U> Freeze for ArcBiConsumer<T, U>

§

impl<T, U> !RefUnwindSafe for ArcBiConsumer<T, U>

§

impl<T, U> Send for ArcBiConsumer<T, U>

§

impl<T, U> Sync for ArcBiConsumer<T, U>

§

impl<T, U> Unpin for ArcBiConsumer<T, U>

§

impl<T, U> UnsafeUnpin for ArcBiConsumer<T, U>

§

impl<T, U> !UnwindSafe for ArcBiConsumer<T, U>

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> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. 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<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T> ToString for T
where T: Display + ?Sized,

Source§

fn to_string(&self) -> String

Converts the given value to a String. Read more
Source§

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

Source§

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>,

Source§

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.