Struct jumpy::prelude::fluent::bundle::FluentBundle

pub struct FluentBundle<R, M> {
    pub locales: Vec<LanguageIdentifier>,
    pub(crate) resources: Vec<R>,
    pub(crate) entries: HashMap<String, Entry, BuildHasherDefault<FxHasher>>,
    pub(crate) intls: M,
    pub(crate) use_isolating: bool,
    pub(crate) transform: Option<fn(_: &str) -> Cow<'_, str>>,
    pub(crate) formatter: Option<fn(_: &FluentValue<'_>, _: &M) -> Option<String>>,
}
Expand description

A collection of localization messages for a single locale, which are meant to be used together in a single view, widget or any other UI abstraction.

§Examples

use fluent_bundle::{FluentBundle, FluentResource, FluentValue, FluentArgs};
use unic_langid::langid;

// 1. Create a FluentResource

let ftl_string = String::from("intro = Welcome, { $name }.");
let resource = FluentResource::try_new(ftl_string)
    .expect("Could not parse an FTL string.");


// 2. Create a FluentBundle

let langid_en = langid!("en-US");
let mut bundle = FluentBundle::new(vec![langid_en]);


// 3. Add the resource to the bundle

bundle.add_resource(&resource)
    .expect("Failed to add FTL resources to the bundle.");


// 4. Retrieve a FluentMessage from the bundle

let msg = bundle.get_message("intro")
    .expect("Message doesn't exist.");

let mut args = FluentArgs::new();
args.set("name", "Rustacean");


// 5. Format the value of the message

let mut errors = vec![];

let pattern = msg.value()
    .expect("Message has no value.");

assert_eq!(
    bundle.format_pattern(&pattern, Some(&args), &mut errors),
    // The placeholder is wrapper in Unicode Directionality Marks
    // to indicate that the placeholder may be of different direction
    // than surrounding string.
    "Welcome, \u{2068}Rustacean\u{2069}."
);

§FluentBundle Life Cycle

§Create a bundle

To create a bundle, call FluentBundle::new with a locale list that represents the best possible fallback chain for a given locale. The simplest case is a one-locale list.

Fluent uses LanguageIdentifier which can be created using langid! macro.

§Add Resources

Next, call add_resource one or more times, supplying translations in the FTL syntax.

Since FluentBundle is generic over anything that can borrow a FluentResource, one can use FluentBundle to own its resources, store references to them, or even Rc<FluentResource> or Arc<FluentResource>.

The FluentBundle instance is now ready to be used for localization.

§Format

To format a translation, call get_message to retrieve a FluentMessage, and then call format_pattern on the message value or attribute in order to retrieve the translated string.

The result of format_pattern is an Cow<str>. It is recommended to treat the result as opaque from the perspective of the program and use it only to display localized messages. Do not examine it or alter in any way before displaying. This is a general good practice as far as all internationalization operations are concerned.

If errors were encountered during formatting, they will be accumulated in the Vec<FluentError> passed as the third argument.

While they are not fatal, they usually indicate problems with the translation, and should be logged or reported in a way that allows the developer to notice and fix them.

§Locale Fallback Chain

FluentBundle stores messages in a single locale, but keeps a locale fallback chain for the purpose of language negotiation with i18n formatters. For instance, if date and time formatting are not available in the first locale, FluentBundle will use its locales fallback chain to negotiate a sensible fallback for date and time formatting.

§Concurrency

As you may have noticed, fluent_bundle::FluentBundle is a specialization of fluent_bundle::bundle::FluentBundle which works with an IntlLangMemoizer over RefCell. In scenarios where the memoizer must work concurrently, there’s an implementation of IntlLangMemoizer that uses Mutex and there’s FluentBundle::new_concurrent which works with that.

Fields§

§locales: Vec<LanguageIdentifier>§resources: Vec<R>§entries: HashMap<String, Entry, BuildHasherDefault<FxHasher>>§intls: M§use_isolating: bool§transform: Option<fn(_: &str) -> Cow<'_, str>>§formatter: Option<fn(_: &FluentValue<'_>, _: &M) -> Option<String>>

Implementations§

§

impl<R, M> FluentBundle<R, M>

pub fn add_resource(&mut self, r: R) -> Result<(), Vec<FluentError>>

Adds a resource to the bundle, returning an empty Result<T> on success.

If any entry in the resource uses the same identifier as an already existing key in the bundle, the new entry will be ignored and a FluentError::Overriding will be added to the result.

The method can take any type that can be borrowed to FluentResource:

  • FluentResource
  • &FluentResource
  • Rc<FluentResource>
  • Arc<FluentResource>

This allows the user to introduce custom resource management and share resources between instances of FluentBundle.

§Examples
use fluent_bundle::{FluentBundle, FluentResource};
use unic_langid::langid;

let ftl_string = String::from("
hello = Hi!
goodbye = Bye!
");
let resource = FluentResource::try_new(ftl_string)
    .expect("Could not parse an FTL string.");
let langid_en = langid!("en-US");
let mut bundle = FluentBundle::new(vec![langid_en]);
bundle.add_resource(resource)
    .expect("Failed to add FTL resources to the bundle.");
assert_eq!(true, bundle.has_message("hello"));
§Whitespace

Message ids must have no leading whitespace. Message values that span multiple lines must have leading whitespace on all but the first line. These are standard FTL syntax rules that may prove a bit troublesome in source code formatting. The indoc! crate can help with stripping extra indentation if you wish to indent your entire message.

pub fn add_resource_overriding(&mut self, r: R)

Adds a resource to the bundle, returning an empty Result<T> on success.

If any entry in the resource uses the same identifier as an already existing key in the bundle, the entry will override the previous one.

The method can take any type that can be borrowed as FluentResource:

  • FluentResource
  • &FluentResource
  • Rc<FluentResource>
  • Arc<FluentResource>

This allows the user to introduce custom resource management and share resources between instances of FluentBundle.

§Examples
use fluent_bundle::{FluentBundle, FluentResource};
use unic_langid::langid;

let ftl_string = String::from("
hello = Hi!
goodbye = Bye!
");
let resource = FluentResource::try_new(ftl_string)
    .expect("Could not parse an FTL string.");

let ftl_string = String::from("
hello = Another Hi!
");
let resource2 = FluentResource::try_new(ftl_string)
    .expect("Could not parse an FTL string.");

let langid_en = langid!("en-US");

let mut bundle = FluentBundle::new(vec![langid_en]);
bundle.add_resource(resource)
    .expect("Failed to add FTL resources to the bundle.");

bundle.add_resource_overriding(resource2);

let mut errors = vec![];
let msg = bundle.get_message("hello")
    .expect("Failed to retrieve the message");
let value = msg.value().expect("Failed to retrieve the value of the message");
assert_eq!(bundle.format_pattern(value, None, &mut errors), "Another Hi!");
§Whitespace

Message ids must have no leading whitespace. Message values that span multiple lines must have leading whitespace on all but the first line. These are standard FTL syntax rules that may prove a bit troublesome in source code formatting. The indoc! crate can help with stripping extra indentation if you wish to indent your entire message.

pub fn set_use_isolating(&mut self, value: bool)

When formatting patterns, FluentBundle inserts Unicode Directionality Isolation Marks to indicate that the direction of a placeable may differ from the surrounding message.

This is important for cases such as when a right-to-left user name is presented in the left-to-right message.

In some cases, such as testing, the user may want to disable the isolating.

pub fn set_transform(&mut self, func: Option<fn(_: &str) -> Cow<'_, str>>)

This method allows to specify a function that will be called on all textual fragments of the pattern during formatting.

This is currently primarily used for pseudolocalization, and fluent-pseudo crate provides a function that can be passed here.

pub fn set_formatter( &mut self, func: Option<fn(_: &FluentValue<'_>, _: &M) -> Option<String>>, )

This method allows to specify a function that will be called before any FluentValue is formatted allowing overrides.

It’s particularly useful for plugging in an external formatter for FluentValue::Number.

pub fn has_message(&self, id: &str) -> bool

Returns true if this bundle contains a message with the given id.

§Examples
use fluent_bundle::{FluentBundle, FluentResource};
use unic_langid::langid;

let ftl_string = String::from("hello = Hi!");
let resource = FluentResource::try_new(ftl_string)
    .expect("Failed to parse an FTL string.");
let langid_en = langid!("en-US");
let mut bundle = FluentBundle::new(vec![langid_en]);
bundle.add_resource(&resource)
    .expect("Failed to add FTL resources to the bundle.");
assert_eq!(true, bundle.has_message("hello"));

pub fn get_message<'l>(&'l self, id: &str) -> Option<FluentMessage<'l>>

Retrieves a FluentMessage from a bundle.

§Examples
use fluent_bundle::{FluentBundle, FluentResource};
use unic_langid::langid;

let ftl_string = String::from("hello-world = Hello World!");
let resource = FluentResource::try_new(ftl_string)
    .expect("Failed to parse an FTL string.");

let langid_en = langid!("en-US");
let mut bundle = FluentBundle::new(vec![langid_en]);

bundle.add_resource(&resource)
    .expect("Failed to add FTL resources to the bundle.");

let msg = bundle.get_message("hello-world");
assert_eq!(msg.is_some(), true);

pub fn write_pattern<'bundle, W>( &'bundle self, w: &mut W, pattern: &'bundle Pattern<&str>, args: Option<&'bundle FluentArgs<'_>>, errors: &mut Vec<FluentError>, ) -> Result<(), Error>
where R: Borrow<FluentResource>, W: Write, M: MemoizerKind,

Writes a formatted pattern which comes from a FluentMessage.

§Example
use fluent_bundle::{FluentBundle, FluentResource};
use unic_langid::langid;

let ftl_string = String::from("hello-world = Hello World!");
let resource = FluentResource::try_new(ftl_string)
    .expect("Failed to parse an FTL string.");

let langid_en = langid!("en-US");
let mut bundle = FluentBundle::new(vec![langid_en]);

bundle.add_resource(&resource)
    .expect("Failed to add FTL resources to the bundle.");

let msg = bundle.get_message("hello-world")
    .expect("Failed to retrieve a FluentMessage.");

let pattern = msg.value()
    .expect("Missing Value.");
let mut errors = vec![];

let mut s = String::new();
bundle.write_pattern(&mut s, &pattern, None, &mut errors)
    .expect("Failed to write.");

assert_eq!(s, "Hello World!");

pub fn format_pattern<'bundle, 'args>( &'bundle self, pattern: &'bundle Pattern<&'bundle str>, args: Option<&'args FluentArgs<'_>>, errors: &mut Vec<FluentError>, ) -> Cow<'bundle, str>
where R: Borrow<FluentResource>, M: MemoizerKind,

Formats a pattern which comes from a FluentMessage.

§Example
use fluent_bundle::{FluentBundle, FluentResource};
use unic_langid::langid;

let ftl_string = String::from("hello-world = Hello World!");
let resource = FluentResource::try_new(ftl_string)
    .expect("Failed to parse an FTL string.");

let langid_en = langid!("en-US");
let mut bundle = FluentBundle::new(vec![langid_en]);

bundle.add_resource(&resource)
    .expect("Failed to add FTL resources to the bundle.");

let msg = bundle.get_message("hello-world")
    .expect("Failed to retrieve a FluentMessage.");

let pattern = msg.value()
    .expect("Missing Value.");
let mut errors = vec![];

let result = bundle.format_pattern(&pattern, None, &mut errors);

assert_eq!(result, "Hello World!");

pub fn add_function<F>(&mut self, id: &str, func: F) -> Result<(), FluentError>
where F: for<'a> Fn(&[FluentValue<'a>], &FluentArgs<'_>) -> FluentValue<'a> + Sync + Send + 'static,

Makes the provided rust function available to messages with the name id. See the FTL syntax guide to learn how these are used in messages.

FTL functions accept both positional and named args. The rust function you provide therefore has two parameters: a slice of values for the positional args, and a FluentArgs for named args.

§Examples
use fluent_bundle::{FluentBundle, FluentResource, FluentValue};
use unic_langid::langid;

let ftl_string = String::from("length = { STRLEN(\"12345\") }");
let resource = FluentResource::try_new(ftl_string)
    .expect("Could not parse an FTL string.");
let langid_en = langid!("en-US");
let mut bundle = FluentBundle::new(vec![langid_en]);
bundle.add_resource(&resource)
    .expect("Failed to add FTL resources to the bundle.");

// Register a fn that maps from string to string length
bundle.add_function("STRLEN", |positional, _named| match positional {
    [FluentValue::String(str)] => str.len().into(),
    _ => FluentValue::Error,
}).expect("Failed to add a function to the bundle.");

let msg = bundle.get_message("length").expect("Message doesn't exist.");
let mut errors = vec![];
let pattern = msg.value().expect("Message has no value.");
let value = bundle.format_pattern(&pattern, None, &mut errors);
assert_eq!(&value, "5");
§

impl<R> FluentBundle<R, IntlLangMemoizer>

pub fn new( locales: Vec<LanguageIdentifier>, ) -> FluentBundle<R, IntlLangMemoizer>

Constructs a FluentBundle. The first element in locales should be the language this bundle represents, and will be used to determine the correct plural rules for this bundle. You can optionally provide extra languages in the list; they will be used as fallback date and time formatters if a formatter for the primary language is unavailable.

§Examples
use fluent_bundle::FluentBundle;
use fluent_bundle::FluentResource;
use unic_langid::langid;

let langid_en = langid!("en-US");
let mut bundle: FluentBundle<FluentResource> = FluentBundle::new(vec![langid_en]);
§Errors

This will panic if no formatters can be found for the locales.

§

impl<R> FluentBundle<R, IntlLangMemoizer>

pub fn new_concurrent( locales: Vec<LanguageIdentifier>, ) -> FluentBundle<R, IntlLangMemoizer>

A constructor analogous to FluentBundle::new but operating on a concurrent version of IntlLangMemoizer over Mutex.

§Example
use fluent_bundle::concurrent::FluentBundle;
use fluent_bundle::FluentResource;
use unic_langid::langid;

let langid_en = langid!("en-US");
let mut bundle: FluentBundle<FluentResource> =
    FluentBundle::new_concurrent(vec![langid_en]);

Trait Implementations§

§

impl<R> Default for FluentBundle<R, IntlLangMemoizer>

§

fn default() -> FluentBundle<R, IntlLangMemoizer>

Returns the “default value” for a type. Read more

Auto Trait Implementations§

§

impl<R, M> Freeze for FluentBundle<R, M>
where M: Freeze,

§

impl<R, M> !RefUnwindSafe for FluentBundle<R, M>

§

impl<R, M> Send for FluentBundle<R, M>
where M: Send, R: Send,

§

impl<R, M> Sync for FluentBundle<R, M>
where M: Sync, R: Sync,

§

impl<R, M> Unpin for FluentBundle<R, M>
where M: Unpin, R: Unpin,

§

impl<R, M> !UnwindSafe for FluentBundle<R, M>

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
§

impl<T, U> AsBindGroupShaderType<U> for T
where U: ShaderType, &'a T: for<'a> Into<U>,

§

fn as_bind_group_shader_type(&self, _images: &RenderAssets<Image>) -> U

Return the T [ShaderType] for self. When used in [AsBindGroup] derives, it is safe to assume that all images in self exist.
§

impl<'a, T, E> AsTaggedExplicit<'a, E> for T
where T: 'a,

§

fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self, E>

§

impl<'a, T, E> AsTaggedImplicit<'a, E> for T
where T: 'a,

§

fn implicit( self, class: Class, constructed: bool, tag: u32, ) -> TaggedParser<'a, Implicit, Self, E>

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
§

impl<T> Conv for T

§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
§

impl<T> FmtForward for T

§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<S> FromSample<S> for S

§

fn from_sample_(s: S) -> S

§

impl<T> FromWorld for T
where T: Default,

§

fn from_world(_world: &mut World) -> T

Creates Self using data from the given [World]
§

impl<T> FromWorld for T
where T: Default,

§

fn from_world(_world: &World) -> T

Creates Self using data from the given World.
§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
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> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
§

impl<F, T> IntoSample<T> for F
where T: FromSample<F>,

§

fn into_sample(self) -> T

§

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

§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more
§

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more
§

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.
§

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function.
§

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
§

impl<T> RawDefault for T
where T: Default,

§

unsafe fn raw_default(dst: *mut c_void)

Write the default value of the type to the pointer. Read more
§

fn raw_default_cb() -> Unsafe<&'static (dyn Fn(*mut c_void) + Send + Sync)>

Get a callback suitable for [SchemaData].
§

impl<T> RawDrop for T

§

unsafe fn raw_drop(ptr: *mut c_void)

Write the default value of the type to the pointer. Read more
§

fn raw_drop_cb() -> Unsafe<&'static (dyn Fn(*mut c_void) + Send + Sync)>

Get a callback suitable for [SchemaData].
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<'gc, T> Singleton<'gc> for T
where T: Default,

§

fn create(_: Context<'gc>) -> T

§

impl<SS, SP> SupersetOf<SS> for SP
where SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
§

impl<T> Tap for T

§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.
§

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
§

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds.
§

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
§

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
§

impl<T, U> ToSample<U> for T
where U: FromSample<T>,

§

fn to_sample_(self) -> U

§

impl<T> TryConv for T

§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
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.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

impl<S, T> Duplex<S> for T
where T: FromSample<S> + ToSample<S>,