ICU4X Result<(), _> cases

results.txt

/Users/zibi/projects/icu4x〉rg 'Result<\(\)' -g "!{ffi/**}" -g "!{coverage/**}" ./                 11/02/2022 08:50:06 AM
./components/collections/src/codepointinvlist/cpinvlist.rs
864:    fn test_serde_with_postcard_roundtrip() -> Result<(), postcard::Error> {

./components/collections/src/codepointtrie/cptrie.rs
996:    fn test_serde_with_postcard_roundtrip() -> Result<(), postcard::Error> {

./components/list/src/provider.rs
274:        ) -> Result<(), DataError> {

./components/plurals/src/rules/reference/lexer.rs
90:    fn expect(&mut self, expected: u8) -> Result<(), LexerError> {

./components/plurals/src/rules/runtime/ast.rs
300:    fn validate_byte_slice(bytes: &[u8]) -> Result<(), ZeroVecError> {

./components/datetime/src/pattern/reference/parser.rs
121:    fn collect_segment(state: Segment, result: &mut Vec<PatternItem>) -> Result<(), PatternError> {
139:    ) -> Result<(), PatternError> {

./components/datetime/src/pattern/item/ule.rs
95:    fn validate_byte_slice(bytes: &[u8]) -> Result<(), ZeroVecError> {
230:    fn validate_byte_slice(bytes: &[u8]) -> Result<(), ZeroVecError> {

./components/locid/src/locale.rs
339:    pub(crate) fn for_each_subtag_str<E, F>(&self, f: &mut F) -> Result<(), E>
341:        F: FnMut(&str) -> Result<(), E>,

./components/locid/src/subtags/variants.rs
108:    pub(crate) fn for_each_subtag_str<E, F>(&self, f: &mut F) -> Result<(), E>
110:        F: FnMut(&str) -> Result<(), E>,

./components/locid/src/helpers.rs
515:            fn validate_byte_slice(bytes: &[u8]) -> Result<(), zerovec::ZeroVecError> {

./components/locid/src/extensions/private/mod.rs
124:    pub(crate) fn for_each_subtag_str<E, F>(&self, f: &mut F) -> Result<(), E>
126:        F: FnMut(&str) -> Result<(), E>,

./components/locid/src/extensions/transform/value.rs
94:    pub(crate) fn for_each_subtag_str<E, F>(&self, f: &mut F) -> Result<(), E>
96:        F: FnMut(&str) -> Result<(), E>,

./components/locid/src/extensions/unicode/value.rs
139:    pub(crate) fn for_each_subtag_str<E, F>(&self, f: &mut F) -> Result<(), E>
141:        F: FnMut(&str) -> Result<(), E>,

./components/locid/src/extensions/unicode/attributes.rs
100:    pub(crate) fn for_each_subtag_str<E, F>(&self, f: &mut F) -> Result<(), E>
102:        F: FnMut(&str) -> Result<(), E>,

./components/locid/src/extensions/transform/mod.rs
189:    pub(crate) fn for_each_subtag_str<E, F>(&self, f: &mut F) -> Result<(), E>
191:        F: FnMut(&str) -> Result<(), E>,

./components/locid/src/langid.rs
313:    pub(crate) fn for_each_subtag_str<E, F>(&self, f: &mut F) -> Result<(), E>
315:        F: FnMut(&str) -> Result<(), E>,

./components/locid/src/extensions/other/mod.rs
141:    pub(crate) fn for_each_subtag_str<E, F>(&self, f: &mut F) -> Result<(), E>
143:        F: FnMut(&str) -> Result<(), E>,

./components/locid/src/extensions/unicode/keywords.rs
375:    pub(crate) fn for_each_subtag_str<E, F>(&self, f: &mut F) -> Result<(), E>
377:        F: FnMut(&str) -> Result<(), E>,

./components/locid/src/extensions/transform/fields.rs
196:    pub(crate) fn for_each_subtag_str<E, F>(&self, f: &mut F) -> Result<(), E>
198:        F: FnMut(&str) -> Result<(), E>,

./components/locid/src/extensions/mod.rs
248:    pub(crate) fn for_each_subtag_str<E, F>(&self, f: &mut F) -> Result<(), E>
250:        F: FnMut(&str) -> Result<(), E>,

./components/locid/src/extensions/unicode/mod.rs
193:    pub(crate) fn for_each_subtag_str<E, F>(&self, f: &mut F) -> Result<(), E>
195:        F: FnMut(&str) -> Result<(), E>,

./components/datetime/src/fields/mod.rs
78:    pub(crate) fn validate_bytes(bytes: (u8, u8)) -> Result<(), zerovec::ZeroVecError> {

./components/calendar/src/date.rs
359:    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {

./components/datetime/src/fields/length.rs
123:    pub(crate) fn validate_byte(byte: u8) -> Result<(), ZeroVecError> {
140:    fn validate_byte_slice(bytes: &[u8]) -> Result<(), ZeroVecError> {

./components/calendar/src/duration.rs
138:    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {

./components/calendar/src/week_of.rs
393:    fn test_num_weeks() -> Result<(), CalendarError> {
453:    fn test_relative_week_of_month() -> Result<(), CalendarError> {
505:    fn test_week_of_month_using_dates() -> Result<(), CalendarError> {

./components/datetime/src/format/datetime.rs
132:) -> Result<(), Error>
167:) -> Result<(), Error>
199:) -> Result<(), Error>

./components/datetime/src/format/zoned_datetime.rs
62:) -> Result<(), Error>
110:) -> Result<(), Error>

./components/datetime/src/time_zone.rs
34:) -> Result<(), DateTimeError>

./components/datetime/src/fields/symbols.rs
184:    pub(crate) fn validate_byte(byte: u8) -> Result<(), ZeroVecError> {
201:    fn validate_byte_slice(bytes: &[u8]) -> Result<(), ZeroVecError> {

./components/datetime/tests/mock.rs
38:    let validate = |c, i| -> Result<(), CalendarError> {

./components/decimal/src/format.rs
34:    fn write_to<W>(&self, sink: &mut W) -> core::result::Result<(), core::fmt::Error>

./components/datetime/tests/patterns/structs/time_zones.rs
127:    pub fn set_on_formatter(self, tzf: &mut TimeZoneFormatter) -> Result<(), DateTimeError> {

./utils/pattern/src/pattern/mod.rs
168:    ) -> Result<(), PatternError<R::Key>>
206:    ) -> Result<(), PatternError<R::Key>>
294:    fn write_to<W>(&self, sink: &mut W) -> std::result::Result<(), std::fmt::Error>

./utils/tinystr/src/ule.rs
21:    fn validate_byte_slice(bytes: &[u8]) -> Result<(), ZeroVecError> {

./utils/fixed_decimal/src/decimal.rs
940:    fn increment_abs_by_one(&mut self) -> Result<(), Error> {
1629:    pub fn concatenate_end(&mut self, other: FixedDecimal) -> Result<(), FixedDecimal> {

./utils/pattern/src/interpolator/mod.rs
33:    fn write_to<W>(&self, sink: &mut W) -> std::result::Result<(), std::fmt::Error>
48:    fn fmt(&self, f: &mut Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {

./utils/tzif/tests/mod.rs
8:fn parse_tzif_file<P: AsRef<Path>>(path: P) -> Result<(), tzif::error::Error> {
16:fn parse_tzif_testdata() -> Result<(), tzif::error::Error> {

./utils/crlify/src/lib.rs
47:    fn flush(&mut self) -> Result<()> {

./utils/zerovec/src/ule/mod.rs
88:    fn validate_byte_slice(bytes: &[u8]) -> Result<(), ZeroVecError>;
294:    fn validate_byte_slice(_bytes: &[u8]) -> Result<(), ZeroVecError>;

./utils/zerovec/src/zerovec/mod.rs
766:        mut f: impl FnMut(&mut T) -> Result<(), E>,
767:    ) -> Result<(), E> {

./utils/zerovec/src/map/map.rs
520:    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {

./utils/zerovec/src/ule/slices.rs
17:    fn validate_byte_slice(bytes: &[u8]) -> Result<(), ZeroVecError> {
47:    fn validate_byte_slice(bytes: &[u8]) -> Result<(), ZeroVecError> {
95:    fn validate_byte_slice(slice: &[u8]) -> Result<(), ZeroVecError> {

./utils/zerovec/src/map2d/borrowed.rs
336:    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {

./utils/zerovec/src/ule/plain.rs
46:            fn validate_byte_slice(bytes: &[u8]) -> Result<(), ZeroVecError> {
189:    fn validate_byte_slice(_bytes: &[u8]) -> Result<(), ZeroVecError> {
218:    fn validate_byte_slice(bytes: &[u8]) -> Result<(), ZeroVecError> {
256:    fn validate_byte_slice(_bytes: &[u8]) -> Result<(), ZeroVecError> {
339:    fn validate_byte_slice(bytes: &[u8]) -> Result<(), ZeroVecError> {

./utils/zerovec/src/map/borrowed.rs
316:    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {

./utils/zerovec/src/zerovec/slice.rs
454:    fn validate_byte_slice(bytes: &[u8]) -> Result<(), ZeroVecError> {

./utils/zerovec/src/map2d/cursor.rs
297:    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {

./utils/zerovec/src/ule/unvalidated.rs
148:    fn validate_byte_slice(_: &[u8]) -> Result<(), ZeroVecError> {

./utils/zerovec/src/map2d/map.rs
645:    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {

./utils/zerovec/src/ule/multi.rs
80:    ) -> Result<(), ZeroVecError> {
143:    fn validate_byte_slice(slice: &[u8]) -> Result<(), ZeroVecError> {

./utils/zerovec/src/ule/option.rs
70:    fn validate_byte_slice(bytes: &[u8]) -> Result<(), ZeroVecError> {
166:    fn validate_byte_slice(slice: &[u8]) -> Result<(), ZeroVecError> {

./utils/zerovec/src/ule/tuple.rs
48:            fn validate_byte_slice(bytes: &[u8]) -> Result<(), ZeroVecError> {
86:            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {

./utils/zerovec/src/ule/niche.rs
111:    fn validate_byte_slice(bytes: &[u8]) -> Result<(), crate::ZeroVecError> {

./utils/zerovec/src/error.rs
22:    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {

./utils/zerovec/src/ule/chars.rs
54:    fn validate_byte_slice(bytes: &[u8]) -> Result<(), ZeroVecError> {

./utils/zerovec/src/ule/custom.rs
70://!     fn validate_byte_slice(bytes: &[u8]) -> Result<(), ZeroVecError> {

./utils/zerovec/src/varzerovec/components.rs
323:    fn check_indices_and_things(self) -> Result<(), ZeroVecError> {

./utils/zerovec/src/varzerovec/slice.rs
469:    fn validate_byte_slice(bytes: &[u8]) -> Result<(), ZeroVecError> {

./utils/zerovec/design_doc.md
177:    fn validate_byte_slice(bytes: &[u8]) -> Result<(), ZeroVecError>;
217:    fn validate_byte_slice(_bytes: &[u8]) -> Result<(), ZeroVecError>;

./utils/zerovec/derive/src/varule.rs
104:            fn validate_byte_slice(bytes: &[u8]) -> Result<(), zerovec::ZeroVecError> {

./utils/zerovec/derive/src/ule.rs
61:            fn validate_byte_slice(bytes: &[u8]) -> Result<(), zerovec::ZeroVecError> {

./utils/zerovec/derive/src/make_ule.rs
197:            fn validate_byte_slice(bytes: &[u8]) -> Result<(), zerovec::ZeroVecError> {

./utils/deduplicating_array/src/lib.rs
214:            fn expecting(&self, formatter: &mut Formatter) -> Result<(), Error> {

./provider/blob/src/export/blob_exporter.rs
49:    ) -> Result<(), DataError> {
73:    fn close(&mut self) -> Result<(), DataError> {

./provider/fs/src/manifest.rs
61:    pub fn write(&self, root: &Path) -> Result<(), DataError> {

./provider/fs/src/export/fs_exporter.rs
117:    ) -> Result<(), DataError> {
163:    fn close(&mut self) -> Result<(), DataError> {
195:    fn flush(&mut self) -> std::io::Result<()> {

./provider/fs/src/export/serializers/postcard.rs
46:    ) -> Result<(), DataError> {

./provider/fs/src/export/serializers/bincode.rs
46:    ) -> Result<(), DataError> {

./provider/fs/src/export/serializers/mod.rs
27:    ) -> Result<(), DataError>;

./provider/fs/src/export/serializers/json.rs
67:    ) -> Result<(), DataError> {

./provider/datagen/src/databake.rs
72:    ) -> Result<(), DataError> {
137:    ) -> Result<(), DataError> {
151:    fn flush(&self, key: DataKey) -> Result<(), DataError> {
279:    fn close(&mut self) -> Result<(), DataError> {

./provider/datagen/src/source.rs
203:    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
225:    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {

./provider/datagen/src/bin/datagen.rs
17:fn main() -> eyre::Result<()> {

./provider/datagen/src/lib.rs
156:/// # fn main() -> std::io::Result<()> {
187:/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
271:) -> Result<(), DataError> {

./provider/testdata/src/bin/download-sources.rs
28:    async fn fetch(&self, cldr_path: &str) -> eyre::Result<()> {
105:    pub async fn unzip(&mut self, path: &str) -> eyre::Result<()> {
126:async fn main() -> eyre::Result<()> {

./provider/core/src/datagen/mod.rs
35:    ) -> Result<(), DataError>;
39:    fn flush(&self, _key: DataKey) -> Result<(), DataError> {
46:    fn close(&mut self) -> Result<(), DataError> {

./provider/core/src/buf.rs
90:    pub fn check_available(&self) -> Result<(), DataError> {

./provider/core/src/key.rs
383:    ) -> Result<(), (&'static str, usize)> {
454:    pub fn match_key(self, key: Self) -> Result<(), DataError> {

./provider/core/src/datagen/payload.rs
16:    ) -> Result<(), DataError>;
31:    ) -> Result<(), DataError> {
81:    pub fn serialize<S>(&self, serializer: S) -> Result<(), DataError>

./experimental/casemapping/src/internals.rs
412:    pub(crate) fn validate(&self) -> Result<(), Error> {
416:        let validate_delta = |c: char, delta: i32| -> Result<(), Error> {