From 2c1e4c85b4e9f8e4866020cd8eed135610f659ac Mon Sep 17 00:00:00 2001
From: Daniel Nelsen <Hoidigan@users.noreply.github.com>
Date: Sat, 31 Jul 2021 10:03:57 -0700
Subject: [PATCH 1/8] Add readme as docs to relevant crates.

---
 crates/bevy_ecs/src/lib.rs       | 2 ++
 crates/bevy_reflect/src/lib.rs   | 2 ++
 crates/bevy_tasks/src/lib.rs     | 2 ++
 crates/bevy_transform/src/lib.rs | 2 ++
 4 files changed, 8 insertions(+)

diff --git a/crates/bevy_ecs/src/lib.rs b/crates/bevy_ecs/src/lib.rs
index 988d020aaab4a..941541cd6eb61 100644
--- a/crates/bevy_ecs/src/lib.rs
+++ b/crates/bevy_ecs/src/lib.rs
@@ -1,3 +1,5 @@
+#![doc = include_str!("../README.md")]
+
 pub mod archetype;
 pub mod bundle;
 pub mod change_detection;
diff --git a/crates/bevy_reflect/src/lib.rs b/crates/bevy_reflect/src/lib.rs
index 7726ce7ee4e76..29929df9f85d8 100644
--- a/crates/bevy_reflect/src/lib.rs
+++ b/crates/bevy_reflect/src/lib.rs
@@ -1,3 +1,5 @@
+#![doc = include_str!("../README.md")]
+
 mod list;
 mod map;
 mod path;
diff --git a/crates/bevy_tasks/src/lib.rs b/crates/bevy_tasks/src/lib.rs
index 08d7dfc42b988..db95dc28db447 100644
--- a/crates/bevy_tasks/src/lib.rs
+++ b/crates/bevy_tasks/src/lib.rs
@@ -1,3 +1,5 @@
+#![doc = include_str!("../README.md")]
+
 mod slice;
 pub use slice::{ParallelSlice, ParallelSliceMut};
 
diff --git a/crates/bevy_transform/src/lib.rs b/crates/bevy_transform/src/lib.rs
index f255c613db814..fa917bf40d889 100644
--- a/crates/bevy_transform/src/lib.rs
+++ b/crates/bevy_transform/src/lib.rs
@@ -1,3 +1,5 @@
+#![doc = include_str!("../README.md")]
+
 pub mod components;
 pub mod hierarchy;
 pub mod transform_propagate_system;

From 9f096ecb830b15943bef87d520e1c696de6868e7 Mon Sep 17 00:00:00 2001
From: Daniel Nelsen <Hoidigan@users.noreply.github.com>
Date: Sun, 1 Aug 2021 08:43:53 -0700
Subject: [PATCH 2/8] Try ignoring a few docs for github

---
 crates/bevy_ecs/README.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/crates/bevy_ecs/README.md b/crates/bevy_ecs/README.md
index 478b23b915a1f..8be5f967e0716 100644
--- a/crates/bevy_ecs/README.md
+++ b/crates/bevy_ecs/README.md
@@ -32,7 +32,7 @@ struct Position { x: f32, y: f32 }
 
 Entities, Components, and Resources are stored in a `World`. Worlds, much like Rust std collections like HashSet and Vec, expose operations to insert, read, write, and remove the data they store.
 
-```rust
+```rust ignore
 let world = World::default();
 ```
 
@@ -40,7 +40,7 @@ let world = World::default();
 
 Entities are unique identifiers that correlate to zero or more Components.
 
-```rust
+```rust ignore
 let entity = world.spawn()
     .insert(Position { x: 0.0, y: 0.0 })
     .insert(Velocity { x: 1.0, y: 0.0 })
@@ -55,7 +55,7 @@ let velocity = entity_ref.get::<Velocity>().unwrap();
 
 Systems are normal Rust functions. Thanks to the Rust type system, Bevy ECS can use function parameter types to determine what data needs to be sent to the system. It also uses this "data access" information to determine what Systems can run in parallel with each other.
 
-```rust
+```rust ignore
 fn print_position(query: Query<(Entity, &Position)>) {
     for (entity, position) in query.iter() {
         println!("Entity {:?} is at position: x {}, y {}", entity, position.x, position.y);
@@ -67,7 +67,7 @@ fn print_position(query: Query<(Entity, &Position)>) {
 
 Apps often require unique resources, such as asset collections, renderers, audio servers, time, etc. Bevy ECS makes this pattern a first class citizen. `Resource` is a special kind of component that does not belong to any entity. Instead, it is identified uniquely by its type:
 
-```rust
+```rust ignore
 #[derive(Default)]
 struct Time {
     seconds: f32,

From 664a47e1ffdcbf939c1f4bfdab93f7232facee8c Mon Sep 17 00:00:00 2001
From: Daniel Nelsen <Hoidigan@users.noreply.github.com>
Date: Sun, 1 Aug 2021 08:50:44 -0700
Subject: [PATCH 3/8] Fix failing doc tests

Ignore the doc tests in the readme, this allows "cargo test --doc
-p *" to run without errors
---
 crates/bevy_ecs/README.md     | 14 +++++++-------
 crates/bevy_reflect/README.md | 14 +++++++-------
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/crates/bevy_ecs/README.md b/crates/bevy_ecs/README.md
index 8be5f967e0716..40b1721d53899 100644
--- a/crates/bevy_ecs/README.md
+++ b/crates/bevy_ecs/README.md
@@ -95,7 +95,7 @@ The built in "parallel stage" considers dependencies between systems and (by def
 
 Bevy ECS should feel very natural for those familiar with Rust syntax:
 
-```rust
+```rust ignore
 use bevy_ecs::prelude::*;
 
 struct Velocity {
@@ -143,7 +143,7 @@ fn main() {
 
 ### Query Filters
 
-```rust
+```rust ignore
 // Gets the Position component of all Entities with Player component and without the RedTeam component
 fn system(query: Query<&Position, (With<Player>, Without<RedTeam>)>) {
     for position in query.iter() {
@@ -157,7 +157,7 @@ Bevy ECS tracks _all_ changes to Components and Resources.
 
 Queries can filter for changed Components:
 
-```rust
+```rust ignore
 // Gets the Position component of all Entities whose Velocity has changed since the last run of the System
 fn system(query: Query<&Position, Changed<Velocity>>) {
     for position in query.iter() {
@@ -173,7 +173,7 @@ fn system(query: Query<&Position, Added<Velocity>>) {
 
 Resources also expose change state:
 
-```rust
+```rust ignore
 // Prints "time changed!" if the Time resource has changed since the last run of the System
 fn system(time: Res<Time>) {
     if time.is_changed() {
@@ -195,7 +195,7 @@ Components can be stored in:
 
 Component storage types are configurable, and they default to table storage if the storage is not manually defined. The [`component_storage.rs`](examples/component_storage.rs) example shows how to configure the storage type for a component.
 
-```rust
+```rust ignore
 // store Position components in Sparse Sets
 world.register_component(ComponentDescriptor::new::<Position>(StorageType::SparseSet));
 ```
@@ -204,7 +204,7 @@ world.register_component(ComponentDescriptor::new::<Position>(StorageType::Spars
 
 Define sets of Components that should be added together.
 
-```rust
+```rust ignore
 #[derive(Bundle, Default)]
 struct PlayerBundle {
     player: Player,
@@ -226,7 +226,7 @@ world.spawn().insert_bundle(PlayerBundle {
 
 Events offer a communication channel between one or more systems. Events can be sent using the system parameter `EventWriter` and received with `EventReader`.
 
-```rust
+```rust ignore
 struct MyEvent {
     message: String,
 }
diff --git a/crates/bevy_reflect/README.md b/crates/bevy_reflect/README.md
index 8ecb319649fc5..b36933051dcce 100644
--- a/crates/bevy_reflect/README.md
+++ b/crates/bevy_reflect/README.md
@@ -14,7 +14,7 @@ This crate enables you to dynamically interact with Rust types:
 
 ### Derive the Reflect traits
 
-```rust
+```rust ignore
 // this will automatically implement the Reflect trait and the Struct trait (because the type is a struct)
 #[derive(Reflect)]
 struct Foo {
@@ -44,7 +44,7 @@ let mut foo = Foo {
 
 ### Interact with fields using their names
 
-```rust
+```rust ignore
 assert_eq!(*foo.get_field::<u32>("a").unwrap(), 1);
 
 *foo.get_field_mut::<u32>("a").unwrap() = 2;
@@ -54,7 +54,7 @@ assert_eq!(foo.a, 2);
 
 ### "Patch" your types with new values
 
-```rust
+```rust ignore
 let mut dynamic_struct = DynamicStruct::default();
 dynamic_struct.insert("a", 42u32);
 dynamic_struct.insert("c", vec![3, 4, 5]);
@@ -67,14 +67,14 @@ assert_eq!(foo.c, vec![3, 4, 5]);
 
 ### Look up nested fields using "path strings"
 
-```rust
+```rust ignore
 let value = *foo.get_path::<f32>("d[0].value").unwrap();
 assert_eq!(value, 3.14);
 ```
 
 ### Iterate over struct fields
 
-```rust
+```rust ignore
 for (i, value: &Reflect) in foo.iter_fields().enumerate() {
     let field_name = foo.name_at(i).unwrap();
     if let Ok(value) = value.downcast_ref::<u32>() {
@@ -85,7 +85,7 @@ for (i, value: &Reflect) in foo.iter_fields().enumerate() {
 
 ### Automatically serialize and deserialize via Serde (without explicit serde impls)
 
-```rust
+```rust ignore
 let mut registry = TypeRegistry::default();
 registry.register::<u32>();
 registry.register::<i32>();
@@ -109,7 +109,7 @@ assert!(foo.reflect_partial_eq(&dynamic_struct).unwrap());
 
 Call a trait on a given &dyn Reflect reference without knowing the underlying type!
 
-```rust
+```rust ignore
 #[derive(Reflect)]
 #[reflect(DoThing)]
 struct MyType {

From 8d742207080772f9311a42199a285baf938623a5 Mon Sep 17 00:00:00 2001
From: Daniel Nelsen <Hoidigan@users.noreply.github.com>
Date: Tue, 10 Aug 2021 06:28:17 -0700
Subject: [PATCH 4/8] Unignore and fix examples in bevy_ecs readme

---
 crates/bevy_ecs/Cargo.toml |  1 +
 crates/bevy_ecs/README.md  | 99 ++++++++++++++++++++++++++++----------
 2 files changed, 74 insertions(+), 26 deletions(-)

diff --git a/crates/bevy_ecs/Cargo.toml b/crates/bevy_ecs/Cargo.toml
index b7797993bc427..3012d5cce8676 100644
--- a/crates/bevy_ecs/Cargo.toml
+++ b/crates/bevy_ecs/Cargo.toml
@@ -33,6 +33,7 @@ serde = "1"
 
 [dev-dependencies]
 parking_lot = "0.11"
+bevy_core = { path = "../bevy_core", version = "0.5.0" }
 
 [[example]]
 name = "events"
diff --git a/crates/bevy_ecs/README.md b/crates/bevy_ecs/README.md
index 40b1721d53899..186701c7e3742 100644
--- a/crates/bevy_ecs/README.md
+++ b/crates/bevy_ecs/README.md
@@ -32,7 +32,9 @@ struct Position { x: f32, y: f32 }
 
 Entities, Components, and Resources are stored in a `World`. Worlds, much like Rust std collections like HashSet and Vec, expose operations to insert, read, write, and remove the data they store.
 
-```rust ignore
+```rust
+use bevy_ecs::world::World;
+
 let world = World::default();
 ```
 
@@ -40,7 +42,14 @@ let world = World::default();
 
 Entities are unique identifiers that correlate to zero or more Components.
 
-```rust ignore
+```rust
+use bevy_ecs::prelude::*;
+
+struct Position { x: f32, y: f32 }
+struct Velocity { x: f32, y: f32 }
+
+let mut world = World::new();
+
 let entity = world.spawn()
     .insert(Position { x: 0.0, y: 0.0 })
     .insert(Velocity { x: 1.0, y: 0.0 })
@@ -55,7 +64,11 @@ let velocity = entity_ref.get::<Velocity>().unwrap();
 
 Systems are normal Rust functions. Thanks to the Rust type system, Bevy ECS can use function parameter types to determine what data needs to be sent to the system. It also uses this "data access" information to determine what Systems can run in parallel with each other.
 
-```rust ignore
+```rust
+use bevy_ecs::prelude::*;
+
+struct Position { x: f32, y: f32 }
+
 fn print_position(query: Query<(Entity, &Position)>) {
     for (entity, position) in query.iter() {
         println!("Entity {:?} is at position: x {}, y {}", entity, position.x, position.y);
@@ -67,12 +80,18 @@ fn print_position(query: Query<(Entity, &Position)>) {
 
 Apps often require unique resources, such as asset collections, renderers, audio servers, time, etc. Bevy ECS makes this pattern a first class citizen. `Resource` is a special kind of component that does not belong to any entity. Instead, it is identified uniquely by its type:
 
-```rust ignore
+```rust
+use bevy_ecs::prelude::*;
+
+// Bevy does provide its own more advanced Time as a resource, but we
+// use this for the example.
 #[derive(Default)]
 struct Time {
     seconds: f32,
 }
 
+let mut world = World::new();
+
 world.insert_resource(Time::default());
 
 let time = world.get_resource::<Time>().unwrap();
@@ -95,21 +114,14 @@ The built in "parallel stage" considers dependencies between systems and (by def
 
 Bevy ECS should feel very natural for those familiar with Rust syntax:
 
-```rust ignore
+```rust
 use bevy_ecs::prelude::*;
 
-struct Velocity {
-    x: f32,
-    y: f32,
-}
-
-struct Position {
-    x: f32,
-    y: f32,
-}
+struct Position { x: f32, y: f32 }
+struct Velocity { x: f32, y: f32 }
 
 // This system moves each entity with a Position and Velocity component
-fn movement(query: Query<(&mut Position, &Velocity)>) {
+fn movement(mut query: Query<(&mut Position, &Velocity)>) {
     for (mut position, velocity) in query.iter_mut() {
         position.x += velocity.x;
         position.y += velocity.y;
@@ -143,9 +155,16 @@ fn main() {
 
 ### Query Filters
 
-```rust ignore
-// Gets the Position component of all Entities with Player component and without the RedTeam component
-fn system(query: Query<&Position, (With<Player>, Without<RedTeam>)>) {
+```rust
+use bevy_ecs::prelude::*;
+
+struct Position { x: f32, y: f32 }
+struct Player;
+struct Alive;
+
+// Gets the Position component of all Entities with Player component and without the Alive
+// component. 
+fn system(query: Query<&Position, (With<Player>, Without<Alive>)>) {
     for position in query.iter() {
     }
 }
@@ -157,15 +176,20 @@ Bevy ECS tracks _all_ changes to Components and Resources.
 
 Queries can filter for changed Components:
 
-```rust ignore
+```rust
+use bevy_ecs::prelude::*;
+
+struct Position { x: f32, y: f32 }
+struct Velocity { x: f32, y: f32 }
+
 // Gets the Position component of all Entities whose Velocity has changed since the last run of the System
-fn system(query: Query<&Position, Changed<Velocity>>) {
+fn system_changed(query: Query<&Position, Changed<Velocity>>) {
     for position in query.iter() {
     }
 }
 
-// Gets the Position component of all Entities that had a Velocity component added since the last run of the System
-fn system(query: Query<&Position, Added<Velocity>>) {
+// Gets the i32 component of all Entities that had a f32 component added since the last run of the System
+fn system_added(query: Query<&Position, Added<Velocity>>) {
     for position in query.iter() {
     }
 }
@@ -173,7 +197,10 @@ fn system(query: Query<&Position, Added<Velocity>>) {
 
 Resources also expose change state:
 
-```rust ignore
+```rust
+use bevy_core::Time;
+use bevy_ecs::prelude::*;
+
 // Prints "time changed!" if the Time resource has changed since the last run of the System
 fn system(time: Res<Time>) {
     if time.is_changed() {
@@ -195,7 +222,14 @@ Components can be stored in:
 
 Component storage types are configurable, and they default to table storage if the storage is not manually defined. The [`component_storage.rs`](examples/component_storage.rs) example shows how to configure the storage type for a component.
 
-```rust ignore
+```rust
+use bevy_ecs::prelude::*;
+use bevy_ecs::component::{ComponentDescriptor, StorageType};
+
+struct Position { x: f32, y: f32 }
+
+let mut world = World::new();
+
 // store Position components in Sparse Sets
 world.register_component(ComponentDescriptor::new::<Position>(StorageType::SparseSet));
 ```
@@ -204,7 +238,16 @@ world.register_component(ComponentDescriptor::new::<Position>(StorageType::Spars
 
 Define sets of Components that should be added together.
 
-```rust ignore
+```rust
+use bevy_ecs::prelude::*;
+
+#[derive(Default)]
+struct Player;
+#[derive(Default)]
+struct Position { x: f32, y: f32 }
+#[derive(Default)]
+struct Velocity { x: f32, y: f32 }
+
 #[derive(Bundle, Default)]
 struct PlayerBundle {
     player: Player,
@@ -212,6 +255,8 @@ struct PlayerBundle {
     velocity: Velocity,
 }
 
+let mut world = World::new();
+
 // Spawn a new entity and insert the default PlayerBundle
 world.spawn().insert_bundle(PlayerBundle::default());
 
@@ -226,7 +271,9 @@ world.spawn().insert_bundle(PlayerBundle {
 
 Events offer a communication channel between one or more systems. Events can be sent using the system parameter `EventWriter` and received with `EventReader`.
 
-```rust ignore
+```rust
+use bevy_ecs::prelude::*;
+
 struct MyEvent {
     message: String,
 }

From bad2acd1d26c3f654ffeb46677ccfc3150358947 Mon Sep 17 00:00:00 2001
From: Daniel Nelsen <Hoidigan@users.noreply.github.com>
Date: Thu, 7 Oct 2021 12:20:24 -0700
Subject: [PATCH 5/8] fix bevy_ecs cargo.toml

---
 crates/bevy_ecs/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/Cargo.toml b/crates/bevy_ecs/Cargo.toml
index d9e3038dc83d2..17a78904d3e54 100644
--- a/crates/bevy_ecs/Cargo.toml
+++ b/crates/bevy_ecs/Cargo.toml
@@ -29,7 +29,7 @@ serde = "1"
 [dev-dependencies]
 parking_lot = "0.11"
 bevy_core = { path = "../bevy_core", version = "0.5.0" }
-rand = "0.8
+rand = "0.8"
 
 [[example]]
 name = "events"

From f99e5190b269e4a49f3b572df8512b5fa9db35fe Mon Sep 17 00:00:00 2001
From: Daniel Nelsen <Hoidigan@users.noreply.github.com>
Date: Thu, 7 Oct 2021 12:29:33 -0700
Subject: [PATCH 6/8] fix bevy_ecs readme tests

---
 crates/bevy_ecs/README.md | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_ecs/README.md b/crates/bevy_ecs/README.md
index 8c444640437b2..dca175e9387c1 100644
--- a/crates/bevy_ecs/README.md
+++ b/crates/bevy_ecs/README.md
@@ -25,6 +25,9 @@ Bevy ECS is Bevy's implementation of the ECS pattern. Unlike other Rust ECS impl
 Components are normal Rust structs. They are data stored in a `World` and specific instances of Components correlate to Entities.
 
 ```rust
+use bevy_ecs::prelude::*;
+
+#[derive(Component)]
 struct Position { x: f32, y: f32 }
 ```
 
@@ -45,7 +48,9 @@ Entities are unique identifiers that correlate to zero or more Components.
 ```rust
 use bevy_ecs::prelude::*;
 
+#[derive(Component)]
 struct Position { x: f32, y: f32 }
+#[derive(Component)]
 struct Velocity { x: f32, y: f32 }
 
 let mut world = World::new();
@@ -67,6 +72,7 @@ Systems are normal Rust functions. Thanks to the Rust type system, Bevy ECS can
 ```rust
 use bevy_ecs::prelude::*;
 
+#[derive(Component)]
 struct Position { x: f32, y: f32 }
 
 fn print_position(query: Query<(Entity, &Position)>) {
@@ -117,7 +123,9 @@ Bevy ECS should feel very natural for those familiar with Rust syntax:
 ```rust
 use bevy_ecs::prelude::*;
 
+#[derive(Component)]
 struct Position { x: f32, y: f32 }
+#[derive(Component)]
 struct Velocity { x: f32, y: f32 }
 
 // This system moves each entity with a Position and Velocity component
@@ -158,8 +166,11 @@ fn main() {
 ```rust
 use bevy_ecs::prelude::*;
 
+#[derive(Component)]
 struct Position { x: f32, y: f32 }
+#[derive(Component)]
 struct Player;
+#[derive(Component)]
 struct Alive;
 
 // Gets the Position component of all Entities with Player component and without the Alive
@@ -179,7 +190,9 @@ Queries can filter for changed Components:
 ```rust
 use bevy_ecs::prelude::*;
 
+#[derive(Component)]
 struct Position { x: f32, y: f32 }
+#[derive(Component)]
 struct Velocity { x: f32, y: f32 }
 
 // Gets the Position component of all Entities whose Velocity has changed since the last run of the System
@@ -240,11 +253,11 @@ Define sets of Components that should be added together.
 ```rust
 use bevy_ecs::prelude::*;
 
-#[derive(Default)]
+#[derive(Default, Component)]
 struct Player;
-#[derive(Default)]
+#[derive(Default, Component)]
 struct Position { x: f32, y: f32 }
-#[derive(Default)]
+#[derive(Default, Component)]
 struct Velocity { x: f32, y: f32 }
 
 #[derive(Bundle, Default)]

From 903e2a68a5fef334764111084aa41287efb09aaf Mon Sep 17 00:00:00 2001
From: Daniel Nelsen <Hoidigan@users.noreply.github.com>
Date: Fri, 8 Oct 2021 01:04:32 -0700
Subject: [PATCH 7/8] Remove bevy_core and update readme

---
 crates/bevy_ecs/Cargo.toml |  1 -
 crates/bevy_ecs/README.md  | 11 ++++-------
 2 files changed, 4 insertions(+), 8 deletions(-)

diff --git a/crates/bevy_ecs/Cargo.toml b/crates/bevy_ecs/Cargo.toml
index 17a78904d3e54..9c39a46e62d1c 100644
--- a/crates/bevy_ecs/Cargo.toml
+++ b/crates/bevy_ecs/Cargo.toml
@@ -28,7 +28,6 @@ serde = "1"
 
 [dev-dependencies]
 parking_lot = "0.11"
-bevy_core = { path = "../bevy_core", version = "0.5.0" }
 rand = "0.8"
 
 [[example]]
diff --git a/crates/bevy_ecs/README.md b/crates/bevy_ecs/README.md
index dca175e9387c1..51c54bc5c6c67 100644
--- a/crates/bevy_ecs/README.md
+++ b/crates/bevy_ecs/README.md
@@ -89,12 +89,8 @@ Apps often require unique resources, such as asset collections, renderers, audio
 ```rust
 use bevy_ecs::prelude::*;
 
-// Bevy does provide its own more advanced Time as a resource, but we
-// use this for the example.
 #[derive(Default)]
-struct Time {
-    seconds: f32,
-}
+struct Time(f32);
 
 let mut world = World::new();
 
@@ -104,7 +100,7 @@ let time = world.get_resource::<Time>().unwrap();
 
 // You can also access resources from Systems
 fn print_time(time: Res<Time>) {
-    println!("{}", time.seconds);
+    println!("{}", time.0);
 }
 ```
 
@@ -211,9 +207,10 @@ fn system_added(query: Query<&Position, Added<Velocity>>) {
 Resources also expose change state:
 
 ```rust
-use bevy_core::Time;
 use bevy_ecs::prelude::*;
 
+struct Time(f32);
+
 // Prints "time changed!" if the Time resource has changed since the last run of the System
 fn system(time: Res<Time>) {
     if time.is_changed() {

From 0743c59908febd42ceab150ee061d9a800959ecc Mon Sep 17 00:00:00 2001
From: Daniel Nelsen <57080125+Hoidigan@users.noreply.github.com>
Date: Sat, 18 Dec 2021 14:47:11 -0800
Subject: [PATCH 8/8] add suggested rename

---
 crates/bevy_ecs/README.md | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_ecs/README.md b/crates/bevy_ecs/README.md
index 51c54bc5c6c67..9c8a2c109c40f 100644
--- a/crates/bevy_ecs/README.md
+++ b/crates/bevy_ecs/README.md
@@ -90,7 +90,9 @@ Apps often require unique resources, such as asset collections, renderers, audio
 use bevy_ecs::prelude::*;
 
 #[derive(Default)]
-struct Time(f32);
+struct Time {
+    seconds: f32,
+}
 
 let mut world = World::new();
 
@@ -100,7 +102,7 @@ let time = world.get_resource::<Time>().unwrap();
 
 // You can also access resources from Systems
 fn print_time(time: Res<Time>) {
-    println!("{}", time.0);
+    println!("{}", time.seconds);
 }
 ```