Add TryWriteable for writeables that can fail #4772

sffc · 2024-04-03T03:41:50Z

We need something of this shape for at least two things I'm currently collaborating on: datetime formatting and freeform multi-placeholder patterns.

In this PR, I add a new trait TryWriteable, which is implemented on Option<T>, with the following behavior:

let mut sink = String::new();

Some("abcdefg")
    .checked()
    .try_write_to(&mut sink)
    .unwrap()
    .unwrap();
assert_eq!(sink, "abcdefg");
assert!(matches!(
    None::<&str>.checked().try_write_to(&mut sink),
    Ok(Err(MissingWriteableError))
));

assert_writeable_eq!(Some("abcdefg").lossy(), "abcdefg");
assert_eq!(
    Some("abcdefg").lossy().writeable_length_hint(),
    LengthHint::exact(7)
);

assert_writeable_eq!(None::<&str>.lossy(), "�");
assert_eq!(
    None::<&str>.lossy().writeable_length_hint(),
    LengthHint::exact(3)
);

assert_writeable_eq!(Some("abcdefg").panicky(), "abcdefg");
assert_eq!(
    Some("abcdefg").panicky().writeable_length_hint(),
    LengthHint::exact(7)
);

assert_writeable_eq!(Some("abcdefg").gigo(), "abcdefg");
assert_eq!(
    Some("abcdefg").gigo().writeable_length_hint(),
    LengthHint::exact(7)
);

Manishearth · 2024-04-03T17:31:32Z

utils/writeable/src/fallible.rs

+    fn unwrap_infallible(self) -> Self::T;
+}
+
+impl<T> UnwrapInfallible for Result<T, Infallible> {


nit: let's just use a free function for this

sffc · 2024-04-03T17:59:12Z

utils/writeable/src/fallible.rs

+    fn fallible_write_to<
+        W: fmt::Write + ?Sized,
+        L: Writeable,
+        E,
+        F: FnMut(Self::Error) -> Result<L, E>,
+    >(
+        &self,
+        sink: &mut W,
+        handler: F,
+    ) -> Result<Result<(), E>, fmt::Error>;


Discussion: This signature is nice in the sense that it enforces consistency while handling errors via the type system, but it also may cause more monomorphization. We'd probably need to add it to write_pattern. However, the creep should be limited to which version of TryWriteable the user calls.

pub(crate) fn write_pattern<'data, T, W, DS, TS>( pattern_items: impl Iterator<Item = PatternItem>, pattern_metadata: PatternMetadata, date_symbols: Option<&DS>, time_symbols: Option<&TS>, loc_datetime: &impl LocalizedDateTimeInput<T>, fixed_decimal_format: &FixedDecimalFormatter, w: &mut W, ) -> Result<(), Error> where T: DateTimeInput, W: fmt::Write + ?Sized, DS: DateSymbols<'data>, TS: TimeSymbols, {

sffc · 2024-04-04T17:49:11Z

Working Group Discussion:

@zbraniecki / @Manishearth - Double unwrap is weird, can we do something else?
@sffc - I tried an enum but double result was cleaner
@zbraniecki - Do we want to change all our APIs to this?
@sffc - We probably don't want to start adding failure cases where they don't already exist, but we could use format and try_format. Maybe even in DateTimeFormatter we should have try_format.
@zbraniecki - This looks good to me, still unsure about the double result

robertbastian · 2024-04-08T09:08:45Z

utils/writeable/src/fallible.rs

+enum NeverWriteable {}
+
+impl Writeable for NeverWriteable {
+    #[inline(always)] // to help the compiler find unreachable code paths


question: does this actually work with the annotation, and not without?

robertbastian · 2024-04-08T09:14:12Z

utils/writeable/src/fallible.rs

+    }
+}
+
+impl<T> TryWriteable for T where T: FallibleWriteable {}


why are these separate traits if TryWriteable is blanket-implemented?

robertbastian · 2024-04-08T09:16:04Z

utils/writeable/src/fallible.rs

+        match self.fallible_write_to(&mut wc, handler) {
+            Ok(Ok(())) => (),
+            Ok(Err(e)) => return Err(e),
+            Err(core::fmt::Error) => unreachable!("writing to string is infallible"),


issue: wrong message, you're not writing to string

robertbastian · 2024-04-08T09:19:18Z

utils/writeable/src/fallible.rs

+    >(
+        &self,
+        sink: &mut W,
+        handler: F,


Passing error handlers as closures is unusual. Can this not be done at the call site?

robertbastian · 2024-04-08T09:25:48Z

utils/writeable/src/fallible.rs

+/// Lower-level trait for writeables that can fail while writing.
+///
+/// The methods on this trait should be implemented on custom writeables, but they generally
+/// should not called directly. For methods more useful in client code, see [`TryWriteable`].


Suggested change

/// should not called directly. For methods more useful in client code, see [`TryWriteable`].

/// should not be called directly. For methods more useful in client code, see [`TryWriteable`].

robertbastian · 2024-04-08T09:39:13Z

utils/writeable/src/fallible.rs

+    /// writeable::assert_writeable_eq!(try_writeable.lossy(), "�");
+    /// ```
+    #[inline]
+    fn lossy(&self) -> LossyWriteable<&Self> {


LossyWriteable needs Self::Error: Writeable to work, but the bound is not here. This sounds like it will lead to very annoying errors.

I do find it a bit odd that lossy allows custom errors to be written, it's not really lossy then because no information is lost. If it unconditionally wrote U+FFFD, it'd be lossy.

robertbastian · 2024-04-08T09:41:38Z

utils/writeable/src/fallible.rs

+/// );
+/// assert_writeable_eq!(
+///     HelloWriteable { name: None::<&str> }.lossy(),
+///     "Hello, ___!"


lossy is documented to return U+FFFD in the error case, but here it returns ___ because the writeable can somehow overwrite that? I think this is very confusing.

robertbastian · 2024-04-08T09:42:36Z

utils/writeable/src/fallible.rs

+    ///
+    /// let try_writeable = None::<&str>;
+    /// assert!(matches!(
+    ///     try_writeable.checked().try_write_to_string(),


thought: why is try_write_to_string not on TryWriteable itself?

robertbastian · 2024-04-08T09:43:55Z

utils/writeable/src/fallible.rs

+    /// }
+    /// ```
+    #[inline]
+    fn gigo(&self) -> GigoWriteable<&Self> {


hmm, so we haven't been using the term "gigo" on our API before. I think it's not one of the universally known acronyms, so I'd like to find a better name for it.

robertbastian · 2024-04-08T09:49:04Z

utils/writeable/src/fallible.rs

+
+impl_display_with_writeable!([T] GigoWriteable<T> where T: FallibleWriteable, T::Error: Writeable, T::Error: fmt::Debug);
+
+impl<T> FallibleWriteable for Option<T>


I would prefer implementing FallibleWriteable on Result<T, E>, so that the caller can control the error type. Using Option means the caller has to keep track of errors outside of this fallibility, because the handler will always receive the ZST.

sffc · 2024-04-09T22:04:35Z

Putting in draft because we might merge #4787 instead

sffc · 2024-04-10T18:22:30Z

Replaced by #4787

Code backed up at https://github.com/sffc/omnicu/tree/archive/fallible-writeable

sffc added 14 commits April 2, 2024 15:17

Checkpoint

516c432

Switch to nested result

02e2a88

Checkpoint

0691659

Checkpoint

d816de9

Refactor handler signatures

908827a

Simplify

8df4cbe

Move methods to another type; rename

5887385

fmt

0638502

Inlining and simplifying

154e3d9

Add GigoWriteable; refactoring

e79ff48

Fix write_to_parts; other cleanup

6534162

Add FallibleWriteableConvenience; other refactoring

dcd3327

Docs

b3331ef

fmt

f8a4722

sffc requested a review from robertbastian as a code owner April 3, 2024 03:41

sffc requested review from Manishearth and zbraniecki April 3, 2024 03:41

sffc mentioned this pull request Apr 3, 2024

Should we have a fallible Writeable? #4741

Closed

Manishearth approved these changes Apr 3, 2024

View reviewed changes

sffc commented Apr 3, 2024

View reviewed changes

zbraniecki approved these changes Apr 4, 2024

View reviewed changes

robertbastian reviewed Apr 8, 2024

View reviewed changes

sffc marked this pull request as draft April 9, 2024 22:04

sffc mentioned this pull request Apr 10, 2024

Add TryWriteable with internal Writeable refactoring #4787

Merged

sffc closed this Apr 10, 2024

sffc deleted the fallible-writeable branch April 10, 2024 18:21

sffc mentioned this pull request Sep 5, 2024

Migrate example tui to neo datetime and impl fmt::Display for LossyWrap #5493

Merged

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Add TryWriteable for writeables that can fail #4772

Add TryWriteable for writeables that can fail #4772

sffc commented Apr 3, 2024

Manishearth Apr 3, 2024

sffc Apr 3, 2024

sffc commented Apr 4, 2024

robertbastian Apr 8, 2024

robertbastian Apr 8, 2024

robertbastian Apr 8, 2024

robertbastian Apr 8, 2024

robertbastian Apr 8, 2024

robertbastian Apr 8, 2024

robertbastian Apr 8, 2024

robertbastian Apr 8, 2024

robertbastian Apr 8, 2024

robertbastian Apr 8, 2024

sffc commented Apr 9, 2024

sffc commented Apr 10, 2024

	/// should not called directly. For methods more useful in client code, see [`TryWriteable`].
	/// should not be called directly. For methods more useful in client code, see [`TryWriteable`].


		impl_display_with_writeable!([T] GigoWriteable<T> where T: FallibleWriteable, T::Error: Writeable, T::Error: fmt::Debug);

		impl<T> FallibleWriteable for Option<T>

Add TryWriteable for writeables that can fail #4772

Add TryWriteable for writeables that can fail #4772

Conversation

sffc commented Apr 3, 2024

Choose a reason for hiding this comment

Choose a reason for hiding this comment

sffc commented Apr 4, 2024

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

sffc commented Apr 9, 2024

sffc commented Apr 10, 2024