Reword "object safety" as "dyn compatibility" #1512

kornelski · 2024-06-16T15:45:47Z

"Object safe" is not a self-explanatory term.

The the word "object" doesn't have a clear definition in Rust's context, and to users it may not be obvious that the term refers to trait objects specifically.

The "safe" part is not good either, because it could be misunderstood as relating to "safe Rust" or not-unsafe.

However, the term "object safe" is used in a lot of places, so I propose a minimal backwards-compatible fix by calling this concept "trait-object safety". Addition of the word "trait" adds context, and clearly connects it to trait objects.

Users may only know this concept from Box<dyn Trait> types, so I'm also emphasising dyn Trait compatibility.

More in the forum thread:
https://internals.rust-lang.org/t/object-safety-is-a-terrible-term/21025

or dyn Trait compatible

kornelski · 2024-06-18T16:00:12Z

It's odd that the link checker doesn't get the right anchor, even tough when I run mdbook build locally, it writes the correct one. It seems like {#anchor} syntax isn't always supported?

ehuss · 2024-06-18T17:20:18Z

To support heading attributes, the version of mdbook in

reference/.github/workflows/main.yml

Line 22 in 0b805c6

    
                   curl -sSL https://github.com/rust-lang/mdBook/releases/download/v0.4.14/mdbook-v0.4.14-x86_64-unknown-linux-gnu.tar.gz | tar -xz --directory=bin

needs to be updated to the latest version (0.4.40).

traviscross · 2024-06-18T21:26:21Z

We discussed this in a rustdocs call. We're going to let the discussion on IRLO play out a bit further, then we may lang nominate this.

joshtriplett · 2024-06-20T16:49:11Z

However, the term "object safe" is used in a lot of places, so I propose a minimal backwards-compatible fix by calling this concept "trait-object safety".

We've definitely been using the term "object safe" or "object safety" for a long time in many places, so we don't want to leave people unable to look up that term. But I don't think that means we need to leave the term substantially unmodified; I think that means we need to leave plenty of pointers to what we used to call it.

I would suggest, instead, that we fully rebrand this as "dyn Trait compatible" (or, when appropriate, "compatible with dyn Trait" or "dyn-compatible"), and then include notes saying things like "This is sometimes also called 'trait-object safety', 'object safety', or 'object safe'." With that, plus keeping the old link anchors working (though we should add new ones as well to avoid making the old ones look like the canonical names), I think that'll be sufficient to not abandon people who already know the existing term.

traviscross · 2024-09-25T07:01:25Z

@rustbot labels -S-waiting-on-team

When this ongoing FCP completes, we will have decided to call traits that are compatible with dyn "dyn compatible" rather than "object safe".

fmease · 2024-10-12T12:51:22Z

src/glossary.md

@@ -175,10 +175,13 @@ the hierarchy has its own collection of named entities.
 Types that can be referred to by a path directly. Specifically [enums],
 [structs], [unions], and [trait objects].

-### Object safe traits
+### Trait-object-safe traits


Suggested change

### Trait-object-safe traits

### Dyn-compatible traits

fmease · 2024-10-12T13:00:50Z

src/glossary.md

+[Traits] that can be used in `dyn Trait` types, and allow creation of
+[trait objects]. Only traits that follow specific [rules][object safety] are
+trait-object safe.
+
+This is also called *object safety*.


Suggested change

[Traits] that can be used in `dyn Trait` types, and allow creation of

[trait objects]. Only traits that follow specific [rules][object safety] are

trait-object safe.

This is also called *object safety*.

[Traits] that can be used in [trait object types][trait objects] (`dyn Trait`). Only traits that follow specific [rules][dyn-compatibility] are dyn compatible.

Formerly known as *object safety*.

+ updating the second part of the reference-style MarkDown link.

TC, let me know if you agree with my suggestion.

Looks about right. Probably worth making a full sentence out of the last line, e.g. "These were formerly known as object safe traits".

fmease · 2024-10-12T13:06:57Z

src/items/traits.md

@@ -62,12 +62,12 @@ trait Seq<T> {
 }
 ```

-## Object Safety
+## Trait-Object Safety <a id="object-safety"></a>


Suggested change

## Trait-Object Safety <a id="object-safety"></a>

## Dyn Compatibility

NB: I'd love the URL fragment (named anchor) to get changed to dyn-compatibility and have an HTTP redirect from object-safety. Although I haven't checked if the Reference is set up to support redirects. I know that the rustc-dev-guide is.

We should add a paragraph or footnote pointing out that this concept is "formerly known as object safety".

NB: I'd love the URL fragment (named anchor) to get changed to dyn-compatibility and have an HTTP redirect from object-safety

This would be quite nice because we show this URL literally in rustc's diagnostics. As a result of that we currently have a mismatch of terminology on nightly (diagnostic text vs. URL). Of course, that's expected but I'd like this to be temporary only (namely until this PR hits stable (rustc's diagnostics usually link to the stable channel of the Reference)) as it's a bit awkward imho.

When renaming sections, you need to use a <script> tag to redirect the fragment, see

reference/src/expressions/operator-expr.md

Lines 687 to 699 in c64e52a

<script>

(function() {

var fragments = {

"#slice-dst-pointer-to-pointer-cast": "operator-expr.html#pointer-to-pointer-cast",

};

var target = fragments[window.location.hash];

if (target) {

var url = window.location.toString();

var base = url.substring(0, url.lastIndexOf('/'));

window.location.replace(base + "/" + target);

}

})();

</script>

as an example.

fmease · 2024-10-12T13:09:58Z

src/items/traits.md

@@ -93,7 +93,7 @@ Object safe traits can be the base trait of a [trait object]. A trait is
 # use std::rc::Rc;
 # use std::sync::Arc;
 # use std::pin::Pin;
-// Examples of object safe methods.
+// Examples of trait-object safe methods.


Suggested change

// Examples of trait-object safe methods.

// Examples of dyn-compatible methods.

Though strictly speaking we haven't defined "dyn compatible" for methods, only for traits. We could be more explicit but not sure if worthwhile.

fmease · 2024-10-12T13:12:40Z

src/items/traits.md

+An object-safe trait can be used in a `dyn Trait` type, and be the base trait of a [trait object].
+A trait is *object safe* if it has the following qualities (defined in [RFC 255]):


Suggested change

An object-safe trait can be used in a `dyn Trait` type, and be the base trait of a [trait object].

A trait is *object safe* if it has the following qualities (defined in [RFC 255]):

A dyn-compatible trait can be used in a trait object type (`dyn Trait`), and be the base trait of a [trait object].

A trait is *dyn compatible* if it has the following qualities (defined in [RFC 255]):

Unrelated to the renaming: The dyn-compatibility rules have been updated over time (for example, "dyn-incompatible" associated types marked with where Self: Sized no longer render the trait dyn-incompatible). So stating that the rules were defined in RFC 255 is misleading or at the very least outdated. That should probably be changed as part of a separate PR though.

fmease · 2024-10-12T13:20:39Z

src/items/traits.md

@@ -110,7 +110,7 @@ trait TraitMethods {
 ```

 ```rust,compile_fail
-// This trait is object-safe, but these methods cannot be dispatched on a trait object.


You should double-check if there are any other mentions of /(non[\- _]?)?obj(ect)?[\- _](un)?safe(ty)?/i and update them accordingly.

fmease · 2024-10-12T13:21:36Z

src/items/traits.md

@@ -135,7 +135,7 @@ obj.typed(1);  // ERROR: cannot call with generic type
 ```rust,compile_fail
 # use std::rc::Rc;
 // Examples of non-object safe traits.
-trait NotObjectSafe {
+trait NotDynCompatible {


Suggested change

trait NotDynCompatible {

trait DynIncompatible {

+ usage sites

fmease · 2024-10-12T13:23:12Z

src/items/traits.md

@@ -135,7 +135,7 @@ obj.typed(1);  // ERROR: cannot call with generic type
 ```rust,compile_fail
 # use std::rc::Rc;
 // Examples of non-object safe traits.


Suggested change

// Examples of non-object safe traits.

// Examples of dyn-incompatible traits.

+ all other occurrences of this phrasing in this repo.

fmease · 2024-10-12T13:25:01Z

src/types/trait-object.md

@@ -7,8 +7,8 @@
 > _TraitObjectTypeOneBound_ :\
 > &nbsp;&nbsp; `dyn`<sup>?</sup> [_TraitBound_]

-A *trait object* is an opaque value of another type that implements a set of
-traits. The set of traits is made up of an [object safe] *base trait* plus any
+A *trait object* is an opaque value of a `dyn`-prefixed type that implements a set of


Minor nitpick, can ignore: Describing types (semantic layer) via a 'syntactic characteristic' doesn't sit quite right with me. Esp. since this specific characteristic isn't the whole truth (cc existence of bare trait object types in earlier editions).

fmease · 2024-10-12T13:26:03Z

src/types/trait-object.md

update analogously

traviscross · 2024-10-22T21:41:49Z

@rustbot author

fmease · 2024-10-28T16:31:38Z

Competing PR: #1666.

ehuss · 2024-10-30T13:30:45Z

Closing in favor of #1666.

kornelski mentioned this pull request Jun 16, 2024

Reword trait-object compatibility in rustdoc rust-lang/rust#126554

Closed

Reword object safety as trait-object safety

df37a6e

or dyn Trait compatible

kornelski force-pushed the dyn-trait branch from ccb0d6d to df37a6e Compare June 16, 2024 16:05

Fudge inconsistent support for {#anchor} syntax

41341d4

kornelski force-pushed the dyn-trait branch from 3d8ded5 to 41341d4 Compare June 18, 2024 16:12

traviscross added S-waiting-on-team Status: This is waiting for action from some team. T-lang Team: Lang labels Sep 3, 2024

rustbot removed the S-waiting-on-team Status: This is waiting for action from some team. label Sep 25, 2024

traviscross mentioned this pull request Sep 25, 2024

Tracking issue for rename from "object safe" to "dyn compatible" rust-lang/rust#130852

Open

12 tasks

fmease suggested changes Oct 12, 2024

View reviewed changes

Kijewski mentioned this pull request Oct 12, 2024

"object safe" is now "dyn-compatible" rinja-rs/rinja#199

Open

traviscross changed the title ~~Reword "object safety" as "trait-object safety"~~ Reword "object safety" as "dyn compatibility" Oct 22, 2024

rustbot added the S-waiting-on-author Status: The marked PR is awaiting some action (such as code changes) from the PR author. label Oct 22, 2024

fmease mentioned this pull request Oct 28, 2024

Rename "object safe" to "dyn compatible" #1666

Merged

ehuss closed this Oct 30, 2024

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Reword "object safety" as "dyn compatibility" #1512

Reword "object safety" as "dyn compatibility" #1512

kornelski commented Jun 16, 2024

kornelski commented Jun 18, 2024

ehuss commented Jun 18, 2024

traviscross commented Jun 18, 2024

joshtriplett commented Jun 20, 2024

traviscross commented Sep 25, 2024

fmease Oct 12, 2024

fmease Oct 12, 2024

traviscross Oct 13, 2024

fmease Oct 12, 2024

fmease Oct 12, 2024

fmease Oct 12, 2024 •

edited

Loading

ehuss Oct 12, 2024

fmease Oct 12, 2024 •

edited

Loading

fmease Oct 12, 2024

fmease Oct 12, 2024

fmease Oct 12, 2024 •

edited

Loading

fmease Oct 12, 2024

fmease Oct 12, 2024

fmease Oct 12, 2024 •

edited

Loading

fmease Oct 12, 2024

traviscross commented Oct 22, 2024

fmease commented Oct 28, 2024

ehuss commented Oct 30, 2024

	## Trait-Object Safety <a id="object-safety"></a>
	## Dyn Compatibility

	<script>
	(function() {
	var fragments = {
	"#slice-dst-pointer-to-pointer-cast": "operator-expr.html#pointer-to-pointer-cast",
	};
	var target = fragments[window.location.hash];
	if (target) {
	var url = window.location.toString();
	var base = url.substring(0, url.lastIndexOf('/'));
	window.location.replace(base + "/" + target);
	}
	})();
	</script>

	// Examples of trait-object safe methods.
	// Examples of dyn-compatible methods.

		An object-safe trait can be used in a `dyn Trait` type, and be the base trait of a [trait object].
		A trait is object safe if it has the following qualities (defined in [RFC 255]):

	// Examples of non-object safe traits.
	// Examples of dyn-incompatible traits.

Reword "object safety" as "dyn compatibility" #1512

Reword "object safety" as "dyn compatibility" #1512

Conversation

kornelski commented Jun 16, 2024

kornelski commented Jun 18, 2024

ehuss commented Jun 18, 2024

traviscross commented Jun 18, 2024

joshtriplett commented Jun 20, 2024

traviscross commented Sep 25, 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

fmease Oct 12, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

fmease Oct 12, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

fmease Oct 12, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

fmease Oct 12, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

traviscross commented Oct 22, 2024

fmease commented Oct 28, 2024

ehuss commented Oct 30, 2024

fmease Oct 12, 2024 •

edited

Loading

fmease Oct 12, 2024 •

edited

Loading

fmease Oct 12, 2024 •

edited

Loading

fmease Oct 12, 2024 •

edited

Loading