From f193405edd7ce9760907877c3dfbf3006150ebe6 Mon Sep 17 00:00:00 2001 From: lcnr Date: Mon, 5 Sep 2022 07:38:21 +0200 Subject: [PATCH 1/9] add section about implied bounds --- src/trait-bounds.md | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/src/trait-bounds.md b/src/trait-bounds.md index 0a6731288..bd67efd8c 100644 --- a/src/trait-bounds.md +++ b/src/trait-bounds.md @@ -156,6 +156,35 @@ fn call_on_ref_zero(f: F) where F: for<'a> Fn(&'a i32) { } ``` +## Implied bounds + +Rust sometimes infers some bounds the user would have otherwise been required to write. + +```rust +fn requires_t_outlives_a<'a, T>(x: &'a T) {} +``` +While this function requires `t` to outlive `'a`, this is inferred as the function signature +contains the type `&'a T` which is only valid if `T: 'a` holds. + +Rust adds implied bounds for all inputs and outputs of functions. Inside of `requires_t_outlives_a` +you can assume `T: 'a` to hold even if you don't explicitly specify this: +```rust +fn requires_t_outlives_a<'a, T>(x: &'a T) { + requires_t_outlives_a_not_implied::<'a, T>(); +} + +fn requires_t_outlives_a_not_implied<'a, T: 'a>() {} +``` + +Only lifetime bounds are implied, trait bounds still have to be explicitly added. +This behavior may change in the future however. The following example still causes an error: +```rust,compile_fail +use std::fmt::Debug; +struct IsDebug(T); +// error[E0277]: `T` doesn't implement `Debug` +fn doesnt_specify_t_debug(x: IsDebug) {} +``` + [LIFETIME_OR_LABEL]: tokens.md#lifetimes-and-loop-labels [_GenericParams_]: items/generics.md [_TypePath_]: paths.md#paths-in-types From f01e75f5f3bea2b8dae623330ca9981dfd2b1d93 Mon Sep 17 00:00:00 2001 From: lcnr Date: Fri, 9 Sep 2022 14:58:46 +0200 Subject: [PATCH 2/9] review --- src/trait-bounds.md | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/src/trait-bounds.md b/src/trait-bounds.md index bd67efd8c..5836ab6e9 100644 --- a/src/trait-bounds.md +++ b/src/trait-bounds.md @@ -163,13 +163,21 @@ Rust sometimes infers some bounds the user would have otherwise been required to ```rust fn requires_t_outlives_a<'a, T>(x: &'a T) {} ``` -While this function requires `t` to outlive `'a`, this is inferred as the function signature +While this function requires `T` to outlive `'a`, this is inferred because the function signature contains the type `&'a T` which is only valid if `T: 'a` holds. Rust adds implied bounds for all inputs and outputs of functions. Inside of `requires_t_outlives_a` you can assume `T: 'a` to hold even if you don't explicitly specify this: -```rust +```rust,compile_fail fn requires_t_outlives_a<'a, T>(x: &'a T) { + // This compiles, because `T: 'a` is implied by + // the reference type `&'a T`. + requires_t_outlives_a_not_implied::<'a, T>(); +} + +fn not_implied<'a, T>() { + // This errors, because `T: 'a` is not implied by + // the function signature. requires_t_outlives_a_not_implied::<'a, T>(); } From 903009a82ce645ccad10be0f4936fde0a003a3dd Mon Sep 17 00:00:00 2001 From: lcnr Date: Thu, 6 Oct 2022 11:54:06 +0200 Subject: [PATCH 3/9] review --- src/trait-bounds.md | 49 +++++++++++++++++++++++++++++++++++++-------- 1 file changed, 41 insertions(+), 8 deletions(-) diff --git a/src/trait-bounds.md b/src/trait-bounds.md index 5836ab6e9..3fdc8667e 100644 --- a/src/trait-bounds.md +++ b/src/trait-bounds.md @@ -158,34 +158,37 @@ fn call_on_ref_zero(f: F) where F: for<'a> Fn(&'a i32) { ## Implied bounds -Rust sometimes infers some bounds the user would have otherwise been required to write. +Lifetime bounds required for types to be well-formed are sometimes inferred by the compiler. ```rust fn requires_t_outlives_a<'a, T>(x: &'a T) {} ``` -While this function requires `T` to outlive `'a`, this is inferred because the function signature -contains the type `&'a T` which is only valid if `T: 'a` holds. +The type parameter `T` is required to outlive `'a` for the type `&'a T` to be well-formed. +This is inferred because the function signature contains the type `&'a T` which is +only valid if `T: 'a` holds. Rust adds implied bounds for all inputs and outputs of functions. Inside of `requires_t_outlives_a` you can assume `T: 'a` to hold even if you don't explicitly specify this: -```rust,compile_fail +```rust +fn requires_t_outlives_a_not_implied<'a, T: 'a>() {} + fn requires_t_outlives_a<'a, T>(x: &'a T) { // This compiles, because `T: 'a` is implied by // the reference type `&'a T`. requires_t_outlives_a_not_implied::<'a, T>(); } +``` +```rust,compile_fail +# fn requires_t_outlives_a_not_implied<'a, T: 'a>() {} fn not_implied<'a, T>() { // This errors, because `T: 'a` is not implied by // the function signature. requires_t_outlives_a_not_implied::<'a, T>(); } - -fn requires_t_outlives_a_not_implied<'a, T: 'a>() {} ``` -Only lifetime bounds are implied, trait bounds still have to be explicitly added. -This behavior may change in the future however. The following example still causes an error: +Only lifetime bounds are implied, trait bounds still have to be explicitly added. The following example therefore causes an error: ```rust,compile_fail use std::fmt::Debug; struct IsDebug(T); @@ -193,6 +196,36 @@ struct IsDebug(T); fn doesnt_specify_t_debug(x: IsDebug) {} ``` +Lifetime bounds are also inferred in type definitions and impl blocks. + +```rust +struct Struct<'a, T> { + // This requires `T: 'a` to be well-formed + // which is inferred by the compiler. + field: &'a T, +} + +enum Enum<'a, T> { + // This requires `T: 'a` to be well-formed, + // which is inferred by the compiler. + // + // Note that `T: 'a` is required even when only + // using `Enum::OtherVariant`. + SomeVariant(&'a T), + OtherVariant, +} + +trait Trait<'a, T: 'a> {} + +// This would error because `T: 'a` is not implied by any type +// in the impl header. +// impl<'a, T> Trait<'a, T> for () {} + +// This compiles as `T: 'a` is implied by the self type `&'a ()`. +impl<'a, T> Trait<'a, T> for &'a T {} +``` + + [LIFETIME_OR_LABEL]: tokens.md#lifetimes-and-loop-labels [_GenericParams_]: items/generics.md [_TypePath_]: paths.md#paths-in-types From c0c23b844e8d72183878814bdf41a98af1bc1875 Mon Sep 17 00:00:00 2001 From: lcnr Date: Thu, 6 Oct 2022 12:06:39 +0200 Subject: [PATCH 4/9] SPAAAAAAAAAAACE --- src/trait-bounds.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/trait-bounds.md b/src/trait-bounds.md index 3fdc8667e..95d8566f2 100644 --- a/src/trait-bounds.md +++ b/src/trait-bounds.md @@ -196,7 +196,7 @@ struct IsDebug(T); fn doesnt_specify_t_debug(x: IsDebug) {} ``` -Lifetime bounds are also inferred in type definitions and impl blocks. +Lifetime bounds are also inferred for type definitions and impl blocks for any type ```rust struct Struct<'a, T> { @@ -221,7 +221,7 @@ trait Trait<'a, T: 'a> {} // in the impl header. // impl<'a, T> Trait<'a, T> for () {} -// This compiles as `T: 'a` is implied by the self type `&'a ()`. +// This compiles as `T: 'a` is implied by the self type `&'a ()`. impl<'a, T> Trait<'a, T> for &'a T {} ``` From a707381666cfe4cdbd8d3180b310e0a2bae65e6f Mon Sep 17 00:00:00 2001 From: lcnr Date: Fri, 21 Oct 2022 09:37:28 +0200 Subject: [PATCH 5/9] Update src/trait-bounds.md Co-authored-by: Ryan Scheel --- src/trait-bounds.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/trait-bounds.md b/src/trait-bounds.md index 95d8566f2..1766ad477 100644 --- a/src/trait-bounds.md +++ b/src/trait-bounds.md @@ -158,7 +158,7 @@ fn call_on_ref_zero(f: F) where F: for<'a> Fn(&'a i32) { ## Implied bounds -Lifetime bounds required for types to be well-formed are sometimes inferred by the compiler. +Lifetime bounds required for types to be well-formed are sometimes inferred. ```rust fn requires_t_outlives_a<'a, T>(x: &'a T) {} From 62fb4e0bcfb9380ade9c63611a0f340cfa29e492 Mon Sep 17 00:00:00 2001 From: lcnr Date: Fri, 21 Oct 2022 09:40:00 +0200 Subject: [PATCH 6/9] parameters --- src/trait-bounds.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/trait-bounds.md b/src/trait-bounds.md index 1766ad477..66521de88 100644 --- a/src/trait-bounds.md +++ b/src/trait-bounds.md @@ -167,7 +167,7 @@ The type parameter `T` is required to outlive `'a` for the type `&'a T` to be we This is inferred because the function signature contains the type `&'a T` which is only valid if `T: 'a` holds. -Rust adds implied bounds for all inputs and outputs of functions. Inside of `requires_t_outlives_a` +Rust adds implied bounds for all parameters and outputs of functions. Inside of `requires_t_outlives_a` you can assume `T: 'a` to hold even if you don't explicitly specify this: ```rust fn requires_t_outlives_a_not_implied<'a, T: 'a>() {} From 6164b63b4a9aaef5dda79cef35e4e5100b5c59d4 Mon Sep 17 00:00:00 2001 From: lcnr Date: Fri, 21 Oct 2022 09:41:14 +0200 Subject: [PATCH 7/9] w --- src/trait-bounds.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/trait-bounds.md b/src/trait-bounds.md index 66521de88..c5726711a 100644 --- a/src/trait-bounds.md +++ b/src/trait-bounds.md @@ -221,7 +221,7 @@ trait Trait<'a, T: 'a> {} // in the impl header. // impl<'a, T> Trait<'a, T> for () {} -// This compiles as `T: 'a` is implied by the self type `&'a ()`. +// This compiles as `T: 'a` is implied by the self type `&'a T`. impl<'a, T> Trait<'a, T> for &'a T {} ``` From 24d44b5d35e76d2a3f242fecf1bd3e2450046dce Mon Sep 17 00:00:00 2001 From: lcnr Date: Wed, 26 Oct 2022 09:06:15 +0200 Subject: [PATCH 8/9] w --- src/trait-bounds.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/trait-bounds.md b/src/trait-bounds.md index c5726711a..26790384d 100644 --- a/src/trait-bounds.md +++ b/src/trait-bounds.md @@ -167,7 +167,7 @@ The type parameter `T` is required to outlive `'a` for the type `&'a T` to be we This is inferred because the function signature contains the type `&'a T` which is only valid if `T: 'a` holds. -Rust adds implied bounds for all parameters and outputs of functions. Inside of `requires_t_outlives_a` +Implied bounds are added for all parameters and outputs of functions. Inside of `requires_t_outlives_a` you can assume `T: 'a` to hold even if you don't explicitly specify this: ```rust fn requires_t_outlives_a_not_implied<'a, T: 'a>() {} @@ -188,7 +188,8 @@ fn not_implied<'a, T>() { } ``` -Only lifetime bounds are implied, trait bounds still have to be explicitly added. The following example therefore causes an error: +Only lifetime bounds are implied, trait bounds still have to be explicitly added. +The following example therefore causes an error: ```rust,compile_fail use std::fmt::Debug; struct IsDebug(T); From f24f128949905108723bec0dc129266d04a2c544 Mon Sep 17 00:00:00 2001 From: Eric Huss Date: Thu, 10 Aug 2023 13:46:27 -0700 Subject: [PATCH 9/9] Small editorial nits. compile_fail is a dangerous thing to use since it doesn't validate which error is generated (it could be something like a typo). --- src/trait-bounds.md | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/trait-bounds.md b/src/trait-bounds.md index 26790384d..a7cd5a7d9 100644 --- a/src/trait-bounds.md +++ b/src/trait-bounds.md @@ -169,6 +169,7 @@ only valid if `T: 'a` holds. Implied bounds are added for all parameters and outputs of functions. Inside of `requires_t_outlives_a` you can assume `T: 'a` to hold even if you don't explicitly specify this: + ```rust fn requires_t_outlives_a_not_implied<'a, T: 'a>() {} @@ -179,7 +180,7 @@ fn requires_t_outlives_a<'a, T>(x: &'a T) { } ``` -```rust,compile_fail +```rust,compile_fail,E0309 # fn requires_t_outlives_a_not_implied<'a, T: 'a>() {} fn not_implied<'a, T>() { // This errors, because `T: 'a` is not implied by @@ -190,14 +191,15 @@ fn not_implied<'a, T>() { Only lifetime bounds are implied, trait bounds still have to be explicitly added. The following example therefore causes an error: -```rust,compile_fail + +```rust,compile_fail,E0277 use std::fmt::Debug; struct IsDebug(T); // error[E0277]: `T` doesn't implement `Debug` fn doesnt_specify_t_debug(x: IsDebug) {} ``` -Lifetime bounds are also inferred for type definitions and impl blocks for any type +Lifetime bounds are also inferred for type definitions and impl blocks for any type: ```rust struct Struct<'a, T> {