clean up response examples

taylorotwell · taylorotwell · commit 0fd6501002f3 · 2023-02-18T19:59:29.000-06:00
diff --git a/authentication.md b/authentication.md
@@ -146,19 +146,21 @@ Alternatively, once a user is authenticated, you may access the authenticated us
 
     namespace App\Http\Controllers;
 
+    use Illuminate\Http\RedirectResponse;
     use Illuminate\Http\Request;
-    use Illuminate\Http\Response;
 
     class FlightController extends Controller
     {
         /**
          * Update the flight information for an existing flight.
          */
-        public function update(Request $request): Response
+        public function update(Request $request): RedirectResponse
         {
-            // $request->user()
+            $user = $request->user();
+
+            // ...
 
-            return response()->noContent();
+            return redirect('/flights');
         }
     }
 
diff --git a/authorization.md b/authorization.md
@@ -83,24 +83,24 @@ To authorize an action using gates, you should use the `allows` or `denies` meth
 
     use App\Http\Controllers\Controller;
     use App\Models\Post;
+    use Illuminate\Http\RedirectResponse;
     use Illuminate\Http\Request;
-    use Illuminate\Http\Response;
     use Illuminate\Support\Facades\Gate;
 
     class PostController extends Controller
     {
         /**
          * Update the given post.
          */
-        public function update(Request $request, Post $post): Response
+        public function update(Request $request, Post $post): RedirectResponse
         {
             if (! Gate::allows('update-post', $post)) {
                 abort(403);
             }
 
             // Update the post...
 
-            return response()->noContent();
+            return redirect('/posts');
         }
     }
 
@@ -511,23 +511,23 @@ The `App\Models\User` model that is included with your Laravel application inclu
 
     use App\Http\Controllers\Controller;
     use App\Models\Post;
+    use Illuminate\Http\RedirectResponse;
     use Illuminate\Http\Request;
-    use Illuminate\Http\Response;
 
     class PostController extends Controller
     {
         /**
          * Update the given post.
          */
-        public function update(Request $request, Post $post): Response
+        public function update(Request $request, Post $post): RedirectResponse
         {
             if ($request->user()->cannot('update', $post)) {
                 abort(403);
             }
 
             // Update the post...
 
-            return response()->noContent();
+            return redirect('/posts');
         }
     }
 
@@ -544,23 +544,23 @@ Remember, some actions may correspond to policy methods like `create` that do no
 
     use App\Http\Controllers\Controller;
     use App\Models\Post;
+    use Illuminate\Http\RedirectResponse;
     use Illuminate\Http\Request;
-    use Illuminate\Http\Response;
 
     class PostController extends Controller
     {
         /**
          * Create a post.
          */
-        public function store(Request $request): Response
+        public function store(Request $request): RedirectResponse
         {
             if ($request->user()->cannot('create', Post::class)) {
                 abort(403);
             }
 
             // Create the post...
 
-            return response()->noContent();
+            return redirect('/posts');
         }
     }
 
@@ -577,8 +577,8 @@ Like the `can` method, this method accepts the name of the action you wish to au
 
     use App\Http\Controllers\Controller;
     use App\Models\Post;
+    use Illuminate\Http\RedirectResponse;
     use Illuminate\Http\Request;
-    use Illuminate\Http\Response;
 
     class PostController extends Controller
     {
@@ -587,13 +587,13 @@ Like the `can` method, this method accepts the name of the action you wish to au
          *
          * @throws \Illuminate\Auth\Access\AuthorizationException
          */
-        public function update(Request $request, Post $post): Response
+        public function update(Request $request, Post $post): RedirectResponse
         {
             $this->authorize('update', $post);
 
             // The current user can update the blog post...
 
-            return response()->noContent();
+            return redirect('/posts');
         }
     }
 
@@ -603,21 +603,21 @@ Like the `can` method, this method accepts the name of the action you wish to au
 As previously discussed, some policy methods like `create` do not require a model instance. In these situations, you should pass a class name to the `authorize` method. The class name will be used to determine which policy to use when authorizing the action:
 
     use App\Models\Post;
+    use Illuminate\Http\RedirectResponse;
     use Illuminate\Http\Request;
-    use Illuminate\Http\Response;
 
     /**
      * Create a new blog post.
      *
      * @throws \Illuminate\Auth\Access\AuthorizationException
      */
-    public function create(Request $request): Response
+    public function create(Request $request): RedirectResponse
     {
         $this->authorize('create', Post::class);
 
         // The current user can create blog posts...
 
-        return response()->noContent();
+        return redirect('/posts');
     }
 
 <a name="authorizing-resource-controllers"></a>
@@ -782,11 +782,11 @@ When attempting to determine if the authenticated user can update a given post,
      *
      * @throws \Illuminate\Auth\Access\AuthorizationException
      */
-    public function update(Request $request, Post $post): Response
+    public function update(Request $request, Post $post): RedirectResponse
     {
         $this->authorize('update', [$post, $request->category]);
 
         // The current user can update the blog post...
 
-        return response()->noContent();
+        return redirect('/posts');
     }
diff --git a/controllers.md b/controllers.md
@@ -77,11 +77,9 @@ If a controller action is particularly complex, you might find it convenient to
         /**
          * Provision a new web server.
          */
-        public function __invoke(): Response
+        public function __invoke()
         {
             // ...
-
-            return response()->noContent();
         }
     }
 
@@ -482,21 +480,21 @@ In addition to constructor injection, you may also type-hint dependencies on you
 
     namespace App\Http\Controllers;
 
+    use Illuminate\Http\RedirectResponse;
     use Illuminate\Http\Request;
-    use Illuminate\Http\Response;
 
     class UserController extends Controller
     {
         /**
          * Store a new user.
          */
-        public function store(Request $request): Response
+        public function store(Request $request): RedirectResponse
         {
             $name = $request->name;
 
-            // ...
+            // Store the user...
 
-            return response()->noContent();
+            return redirect('/users');
         }
     }
 
@@ -512,17 +510,18 @@ You may still type-hint the `Illuminate\Http\Request` and access your `id` param
 
     namespace App\Http\Controllers;
 
+    use Illuminate\Http\RedirectResponse;
     use Illuminate\Http\Request;
 
     class UserController extends Controller
     {
         /**
          * Update the given user.
          */
-        public function update(Request $request, string $id): Response
+        public function update(Request $request, string $id): RedirectResponse
         {
-            // ...
+            // Update the user...
 
-            return response()->noContent();
+            return redirect('/users');
         }
     }
diff --git a/eloquent.md b/eloquent.md
@@ -682,15 +682,15 @@ Of course, when using Eloquent, we don't only need to retrieve models from the d
 
     use App\Http\Controllers\Controller;
     use App\Models\Flight;
+    use Illuminate\Http\RedirectResponse;
     use Illuminate\Http\Request;
-    use Illuminate\Http\Response;
 
     class FlightController extends Controller
     {
         /**
          * Store a new flight in the database.
          */
-        public function store(Request $request): Response
+        public function store(Request $request): RedirectResponse
         {
             // Validate the request...
 
@@ -700,7 +700,7 @@ Of course, when using Eloquent, we don't only need to retrieve models from the d
 
             $flight->save();
 
-            return response()->noContent();
+            return redirect('/flights');
         }
     }
 
diff --git a/encryption.md b/encryption.md
@@ -28,22 +28,22 @@ You may encrypt a value using the `encryptString` method provided by the `Crypt`
 
     use App\Http\Controllers\Controller;
     use App\Models\User;
+    use Illuminate\Http\RedirectResponse;
     use Illuminate\Http\Request;
-    use Illuminate\Http\Response;
     use Illuminate\Support\Facades\Crypt;
 
     class DigitalOceanTokenController extends Controller
     {
         /**
          * Store a DigitalOcean API token for the user.
          */
-        public function storeSecret(Request $request): Response
+        public function store(Request $request): RedirectResponse
         {
             $request->user()->fill([
                 'token' => Crypt::encryptString($request->token),
             ])->save();
 
-            return response()->noContent();
+            return redirect('/secrets');
         }
     }
 
diff --git a/events.md b/events.md
@@ -495,23 +495,23 @@ To dispatch an event, you may call the static `dispatch` method on the event. Th
     use App\Events\OrderShipped;
     use App\Http\Controllers\Controller;
     use App\Models\Order;
+    use Illuminate\Http\RedirectResponse;
     use Illuminate\Http\Request;
-    use Illuminate\Http\Response;
 
     class OrderShipmentController extends Controller
     {
         /**
          * Ship the given order.
          */
-        public function store(Request $request): Response
+        public function store(Request $request): RedirectResponse
         {
             $order = Order::findOrFail($request->order_id);
 
             // Order shipment logic...
 
             OrderShipped::dispatch($order);
 
-            return response()->noContent();
+            return redirect('/orders');
         }
     }
     
diff --git a/hashing.md b/hashing.md
@@ -32,24 +32,24 @@ You may hash a password by calling the `make` method on the `Hash` facade:
     namespace App\Http\Controllers;
 
     use App\Http\Controllers\Controller;
+    use Illuminate\Http\RedirectResponse;
     use Illuminate\Http\Request;
-    use Illuminate\Http\Response;
     use Illuminate\Support\Facades\Hash;
 
     class PasswordController extends Controller
     {
         /**
          * Update the password for the user.
          */
-        public function update(Request $request): Response
+        public function update(Request $request): RedirectResponse
         {
             // Validate the new password length...
 
             $request->user()->fill([
                 'password' => Hash::make($request->newPassword)
             ])->save();
 
-            return response()->noContent();
+            return redirect('/profile');
         }
     }
 
diff --git a/mail.md b/mail.md
@@ -736,24 +736,24 @@ To send a message, use the `to` method on the `Mail` [facade](/docs/{{version}}/
     use App\Http\Controllers\Controller;
     use App\Mail\OrderShipped;
     use App\Models\Order;
+    use Illuminate\Http\RedirectResponse;
     use Illuminate\Http\Request;
-    use Illuminate\Http\Response;
     use Illuminate\Support\Facades\Mail;
 
     class OrderShipmentController extends Controller
     {
         /**
          * Ship the given order.
          */
-        public function store(Request $request): Response
+        public function store(Request $request): RedirectResponse
         {
             $order = Order::findOrFail($request->order_id);
 
             // Ship the order...
 
             Mail::to($request->user())->send(new OrderShipped($order));
 
-            return response()->noContent();
+            return redirect('/orders');
         }
     }
 
diff --git a/queues.md b/queues.md
diff --git a/releases.md b/releases.md
diff --git a/requests.md b/requests.md
diff --git a/validation.md b/validation.md

Original file line number	Diff line number	Diff line change
`@@ -146,19 +146,21 @@ Alternatively, once a user is authenticated, you may access the authenticated us`
`146`	`146`
`147`	`147`	`namespace App\Http\Controllers;`
`148`	`148`
	`149`	`+ use Illuminate\Http\RedirectResponse;`
`149`	`150`	`use Illuminate\Http\Request;`
`150`		`- use Illuminate\Http\Response;`
`151`	`151`
`152`	`152`	`class FlightController extends Controller`
`153`	`153`	`{`
`154`	`154`	`/**`
`155`	`155`	`* Update the flight information for an existing flight.`
`156`	`156`	`*/`
`157`		`- public function update(Request $request): Response`
	`157`	`+ public function update(Request $request): RedirectResponse`
`158`	`158`	`{`
`159`		`- // $request->user()`
	`159`	`+ $user = $request->user();`
	`160`	`+`
	`161`	`+ // ...`
`160`	`162`
`161`		`- return response()->noContent();`
	`163`	`+ return redirect('/flights');`
`162`	`164`	`}`
`163`	`165`	`}`
`164`	`166`
Original file line number	Diff line number	Diff line change
@@ -83,24 +83,24 @@ To authorize an action using gates, you should use the `allows` or `denies` meth
`83`	`83`
`84`	`84`	`use App\Http\Controllers\Controller;`
`85`	`85`	`use App\Models\Post;`
	`86`	`+ use Illuminate\Http\RedirectResponse;`
`86`	`87`	`use Illuminate\Http\Request;`
`87`		`- use Illuminate\Http\Response;`
`88`	`88`	`use Illuminate\Support\Facades\Gate;`
`89`	`89`
`90`	`90`	`class PostController extends Controller`
`91`	`91`	`{`
`92`	`92`	`/**`
`93`	`93`	`* Update the given post.`
`94`	`94`	`*/`
`95`		`- public function update(Request $request, Post $post): Response`
	`95`	`+ public function update(Request $request, Post $post): RedirectResponse`
`96`	`96`	`{`
`97`	`97`	`if (! Gate::allows('update-post', $post)) {`
`98`	`98`	`abort(403);`
`99`	`99`	`}`
`100`	`100`
`101`	`101`	`// Update the post...`
`102`	`102`
`103`		`- return response()->noContent();`
	`103`	`+ return redirect('/posts');`
`104`	`104`	`}`
`105`	`105`	`}`
`106`	`106`
@@ -511,23 +511,23 @@ The `App\Models\User` model that is included with your Laravel application inclu
`511`	`511`
`512`	`512`	`use App\Http\Controllers\Controller;`
`513`	`513`	`use App\Models\Post;`
	`514`	`+ use Illuminate\Http\RedirectResponse;`
`514`	`515`	`use Illuminate\Http\Request;`
`515`		`- use Illuminate\Http\Response;`
`516`	`516`
`517`	`517`	`class PostController extends Controller`
`518`	`518`	`{`
`519`	`519`	`/**`
`520`	`520`	`* Update the given post.`
`521`	`521`	`*/`
`522`		`- public function update(Request $request, Post $post): Response`
	`522`	`+ public function update(Request $request, Post $post): RedirectResponse`
`523`	`523`	`{`
`524`	`524`	`if ($request->user()->cannot('update', $post)) {`
`525`	`525`	`abort(403);`
`526`	`526`	`}`
`527`	`527`
`528`	`528`	`// Update the post...`
`529`	`529`
`530`		`- return response()->noContent();`
	`530`	`+ return redirect('/posts');`
`531`	`531`	`}`
`532`	`532`	`}`
`533`	`533`
@@ -544,23 +544,23 @@ Remember, some actions may correspond to policy methods like `create` that do no
`544`	`544`
`545`	`545`	`use App\Http\Controllers\Controller;`
`546`	`546`	`use App\Models\Post;`
	`547`	`+ use Illuminate\Http\RedirectResponse;`
`547`	`548`	`use Illuminate\Http\Request;`
`548`		`- use Illuminate\Http\Response;`
`549`	`549`
`550`	`550`	`class PostController extends Controller`
`551`	`551`	`{`
`552`	`552`	`/**`
`553`	`553`	`* Create a post.`
`554`	`554`	`*/`
`555`		`- public function store(Request $request): Response`
	`555`	`+ public function store(Request $request): RedirectResponse`
`556`	`556`	`{`
`557`	`557`	`if ($request->user()->cannot('create', Post::class)) {`
`558`	`558`	`abort(403);`
`559`	`559`	`}`
`560`	`560`
`561`	`561`	`// Create the post...`
`562`	`562`
`563`		`- return response()->noContent();`
	`563`	`+ return redirect('/posts');`
`564`	`564`	`}`
`565`	`565`	`}`
`566`	`566`
@@ -577,8 +577,8 @@ Like the `can` method, this method accepts the name of the action you wish to au
`577`	`577`
`578`	`578`	`use App\Http\Controllers\Controller;`
`579`	`579`	`use App\Models\Post;`
	`580`	`+ use Illuminate\Http\RedirectResponse;`
`580`	`581`	`use Illuminate\Http\Request;`
`581`		`- use Illuminate\Http\Response;`
`582`	`582`
`583`	`583`	`class PostController extends Controller`
`584`	`584`	`{`
@@ -587,13 +587,13 @@ Like the `can` method, this method accepts the name of the action you wish to au
`587`	`587`	`*`
`588`	`588`	`* @throws \Illuminate\Auth\Access\AuthorizationException`
`589`	`589`	`*/`
`590`		`- public function update(Request $request, Post $post): Response`
	`590`	`+ public function update(Request $request, Post $post): RedirectResponse`
`591`	`591`	`{`
`592`	`592`	`$this->authorize('update', $post);`
`593`	`593`
`594`	`594`	`// The current user can update the blog post...`
`595`	`595`
`596`		`- return response()->noContent();`
	`596`	`+ return redirect('/posts');`
`597`	`597`	`}`
`598`	`598`	`}`
`599`	`599`
@@ -603,21 +603,21 @@ Like the `can` method, this method accepts the name of the action you wish to au
`603`	`603`	As previously discussed, some policy methods like `create` do not require a model instance. In these situations, you should pass a class name to the `authorize` method. The class name will be used to determine which policy to use when authorizing the action:
`604`	`604`
`605`	`605`	`use App\Models\Post;`
	`606`	`+ use Illuminate\Http\RedirectResponse;`
`606`	`607`	`use Illuminate\Http\Request;`
`607`		`- use Illuminate\Http\Response;`
`608`	`608`
`609`	`609`	`/**`
`610`	`610`	`* Create a new blog post.`
`611`	`611`	`*`
`612`	`612`	`* @throws \Illuminate\Auth\Access\AuthorizationException`
`613`	`613`	`*/`
`614`		`- public function create(Request $request): Response`
	`614`	`+ public function create(Request $request): RedirectResponse`
`615`	`615`	`{`
`616`	`616`	`$this->authorize('create', Post::class);`
`617`	`617`
`618`	`618`	`// The current user can create blog posts...`
`619`	`619`
`620`		`- return response()->noContent();`
	`620`	`+ return redirect('/posts');`
`621`	`621`	`}`
`622`	`622`
`623`	`623`	`<a name="authorizing-resource-controllers"></a>`
`@@ -782,11 +782,11 @@ When attempting to determine if the authenticated user can update a given post,`
`782`	`782`	`*`
`783`	`783`	`* @throws \Illuminate\Auth\Access\AuthorizationException`
`784`	`784`	`*/`
`785`		`- public function update(Request $request, Post $post): Response`
	`785`	`+ public function update(Request $request, Post $post): RedirectResponse`
`786`	`786`	`{`
`787`	`787`	`$this->authorize('update', [$post, $request->category]);`
`788`	`788`
`789`	`789`	`// The current user can update the blog post...`
`790`	`790`
`791`		`- return response()->noContent();`
	`791`	`+ return redirect('/posts');`
`792`	`792`	`}`
Original file line number	Diff line number	Diff line change
`@@ -77,11 +77,9 @@ If a controller action is particularly complex, you might find it convenient to`
`77`	`77`	`/**`
`78`	`78`	`* Provision a new web server.`
`79`	`79`	`*/`
`80`		`- public function __invoke(): Response`
	`80`	`+ public function __invoke()`
`81`	`81`	`{`
`82`	`82`	`// ...`
`83`		`-`
`84`		`- return response()->noContent();`
`85`	`83`	`}`
`86`	`84`	`}`
`87`	`85`
`@@ -482,21 +480,21 @@ In addition to constructor injection, you may also type-hint dependencies on you`
`482`	`480`
`483`	`481`	`namespace App\Http\Controllers;`
`484`	`482`
	`483`	`+ use Illuminate\Http\RedirectResponse;`
`485`	`484`	`use Illuminate\Http\Request;`
`486`		`- use Illuminate\Http\Response;`
`487`	`485`
`488`	`486`	`class UserController extends Controller`
`489`	`487`	`{`
`490`	`488`	`/**`
`491`	`489`	`* Store a new user.`
`492`	`490`	`*/`
`493`		`- public function store(Request $request): Response`
	`491`	`+ public function store(Request $request): RedirectResponse`
`494`	`492`	`{`
`495`	`493`	`$name = $request->name;`
`496`	`494`
`497`		`- // ...`
	`495`	`+ // Store the user...`
`498`	`496`
`499`		`- return response()->noContent();`
	`497`	`+ return redirect('/users');`
`500`	`498`	`}`
`501`	`499`	`}`
`502`	`500`
@@ -512,17 +510,18 @@ You may still type-hint the `Illuminate\Http\Request` and access your `id` param
`512`	`510`
`513`	`511`	`namespace App\Http\Controllers;`
`514`	`512`
	`513`	`+ use Illuminate\Http\RedirectResponse;`
`515`	`514`	`use Illuminate\Http\Request;`
`516`	`515`
`517`	`516`	`class UserController extends Controller`
`518`	`517`	`{`
`519`	`518`	`/**`
`520`	`519`	`* Update the given user.`
`521`	`520`	`*/`
`522`		`- public function update(Request $request, string $id): Response`
	`521`	`+ public function update(Request $request, string $id): RedirectResponse`
`523`	`522`	`{`
`524`		`- // ...`
	`523`	`+ // Update the user...`
`525`	`524`
`526`		`- return response()->noContent();`
	`525`	`+ return redirect('/users');`
`527`	`526`	`}`
`528`	`527`	`}`
Original file line number	Diff line number	Diff line change
`@@ -682,15 +682,15 @@ Of course, when using Eloquent, we don't only need to retrieve models from the d`
`682`	`682`
`683`	`683`	`use App\Http\Controllers\Controller;`
`684`	`684`	`use App\Models\Flight;`
	`685`	`+ use Illuminate\Http\RedirectResponse;`
`685`	`686`	`use Illuminate\Http\Request;`
`686`		`- use Illuminate\Http\Response;`
`687`	`687`
`688`	`688`	`class FlightController extends Controller`
`689`	`689`	`{`
`690`	`690`	`/**`
`691`	`691`	`* Store a new flight in the database.`
`692`	`692`	`*/`
`693`		`- public function store(Request $request): Response`
	`693`	`+ public function store(Request $request): RedirectResponse`
`694`	`694`	`{`
`695`	`695`	`// Validate the request...`
`696`	`696`
`@@ -700,7 +700,7 @@ Of course, when using Eloquent, we don't only need to retrieve models from the d`
`700`	`700`
`701`	`701`	`$flight->save();`
`702`	`702`
`703`		`- return response()->noContent();`
	`703`	`+ return redirect('/flights');`
`704`	`704`	`}`
`705`	`705`	`}`
`706`	`706`
Original file line number	Diff line number	Diff line change
@@ -28,22 +28,22 @@ You may encrypt a value using the `encryptString` method provided by the `Crypt`
`28`	`28`
`29`	`29`	`use App\Http\Controllers\Controller;`
`30`	`30`	`use App\Models\User;`
	`31`	`+ use Illuminate\Http\RedirectResponse;`
`31`	`32`	`use Illuminate\Http\Request;`
`32`		`- use Illuminate\Http\Response;`
`33`	`33`	`use Illuminate\Support\Facades\Crypt;`
`34`	`34`
`35`	`35`	`class DigitalOceanTokenController extends Controller`
`36`	`36`	`{`
`37`	`37`	`/**`
`38`	`38`	`* Store a DigitalOcean API token for the user.`
`39`	`39`	`*/`
`40`		`- public function storeSecret(Request $request): Response`
	`40`	`+ public function store(Request $request): RedirectResponse`
`41`	`41`	`{`
`42`	`42`	`$request->user()->fill([`
`43`	`43`	`'token' => Crypt::encryptString($request->token),`
`44`	`44`	`])->save();`
`45`	`45`
`46`		`- return response()->noContent();`
	`46`	`+ return redirect('/secrets');`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`
Original file line number	Diff line number	Diff line change
@@ -495,23 +495,23 @@ To dispatch an event, you may call the static `dispatch` method on the event. Th
`495`	`495`	`use App\Events\OrderShipped;`
`496`	`496`	`use App\Http\Controllers\Controller;`
`497`	`497`	`use App\Models\Order;`
	`498`	`+ use Illuminate\Http\RedirectResponse;`
`498`	`499`	`use Illuminate\Http\Request;`
`499`		`- use Illuminate\Http\Response;`
`500`	`500`
`501`	`501`	`class OrderShipmentController extends Controller`
`502`	`502`	`{`
`503`	`503`	`/**`
`504`	`504`	`* Ship the given order.`
`505`	`505`	`*/`
`506`		`- public function store(Request $request): Response`
	`506`	`+ public function store(Request $request): RedirectResponse`
`507`	`507`	`{`
`508`	`508`	`$order = Order::findOrFail($request->order_id);`
`509`	`509`
`510`	`510`	`// Order shipment logic...`
`511`	`511`
`512`	`512`	`OrderShipped::dispatch($order);`
`513`	`513`
`514`		`- return response()->noContent();`
	`514`	`+ return redirect('/orders');`
`515`	`515`	`}`
`516`	`516`	`}`
`517`	`517`
Original file line number	Diff line number	Diff line change
@@ -32,24 +32,24 @@ You may hash a password by calling the `make` method on the `Hash` facade:
`32`	`32`	`namespace App\Http\Controllers;`
`33`	`33`
`34`	`34`	`use App\Http\Controllers\Controller;`
	`35`	`+ use Illuminate\Http\RedirectResponse;`
`35`	`36`	`use Illuminate\Http\Request;`
`36`		`- use Illuminate\Http\Response;`
`37`	`37`	`use Illuminate\Support\Facades\Hash;`
`38`	`38`
`39`	`39`	`class PasswordController extends Controller`
`40`	`40`	`{`
`41`	`41`	`/**`
`42`	`42`	`* Update the password for the user.`
`43`	`43`	`*/`
`44`		`- public function update(Request $request): Response`
	`44`	`+ public function update(Request $request): RedirectResponse`
`45`	`45`	`{`
`46`	`46`	`// Validate the new password length...`
`47`	`47`
`48`	`48`	`$request->user()->fill([`
`49`	`49`	`'password' => Hash::make($request->newPassword)`
`50`	`50`	`])->save();`
`51`	`51`
`52`		`- return response()->noContent();`
	`52`	`+ return redirect('/profile');`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`
Original file line number	Diff line number	Diff line change
@@ -736,24 +736,24 @@ To send a message, use the `to` method on the `Mail` [facade](/docs/{{version}}/
`736`	`736`	`use App\Http\Controllers\Controller;`
`737`	`737`	`use App\Mail\OrderShipped;`
`738`	`738`	`use App\Models\Order;`
	`739`	`+ use Illuminate\Http\RedirectResponse;`
`739`	`740`	`use Illuminate\Http\Request;`
`740`		`- use Illuminate\Http\Response;`
`741`	`741`	`use Illuminate\Support\Facades\Mail;`
`742`	`742`
`743`	`743`	`class OrderShipmentController extends Controller`
`744`	`744`	`{`
`745`	`745`	`/**`
`746`	`746`	`* Ship the given order.`
`747`	`747`	`*/`
`748`		`- public function store(Request $request): Response`
	`748`	`+ public function store(Request $request): RedirectResponse`
`749`	`749`	`{`
`750`	`750`	`$order = Order::findOrFail($request->order_id);`
`751`	`751`
`752`	`752`	`// Ship the order...`
`753`	`753`
`754`	`754`	`Mail::to($request->user())->send(new OrderShipped($order));`
`755`	`755`
`756`		`- return response()->noContent();`
	`756`	`+ return redirect('/orders');`
`757`	`757`	`}`
`758`	`758`	`}`
`759`	`759`