chore: simplify receiver description in intermediate tour

Author: sarahhaggarty

docs/images/tour/receiver-highlight.png

@@ -19,26 +19,21 @@ can help you use efficient design patterns to take your projects to the next lev
 
 ## Extension functions
 
-In software development, you often need to modify the behavior of a program without altering the original source code. 
-For example, in your project, you might want to add extra functionality to a class from a third-party library.
+In software development, you often need to modify a program's behavior without changing the original source code. 
+For example, you might want to add extra functionality to a class from a third-party library.
 
-Extension functions allow you to extend a class with additional functionality. You call extension functions the same way 
-you call member functions of a class.
+You can do this by adding _extension functions_ to extend a class. You call extension functions the same way 
+you call member functions of a class, using a period `.`.
 
-Before introducing the syntax for extension functions, you need to understand the terms **receiver type** and 
-**receiver object**.
-
-The receiver object is what the function is called on. In other words, the receiver is where or with whom the information is shared.
+Before introducing the complete syntax for extension functions, you need to understand what a **receiver** is.
+The receiver is what the function is called on. In other words, the receiver is where or with whom the information is shared.
 
 ![An example of sender and receiver](receiver-highlight.png){width="500"}
 
-In this example, the `main()` function calls the [`.first()`](https://kotlinlang.org/api/core/kotlin-stdlib/kotlin.collections/first.html) function.
+In this example, the `main()` function calls the [`.first()`](https://kotlinlang.org/api/core/kotlin-stdlib/kotlin.collections/first.html) function to return the first element in a list.
 The `.first()` function is called **on** the `readOnlyShapes` variable, so the `readOnlyShapes` variable is the receiver.
 
-The receiver object has a **type** so that the compiler understands when the function can be used.
-
-This example uses the `.first()` function from the standard library to return the first element in a list. To create
-your own extension function, write the name of the class that you want to extend followed by a `.` and the name of
+To create an extension function, write the name of the class that you want to extend followed by a `.` and the name of
 your function. Continue with the rest of the function declaration, including its arguments and return type.
 
 For example:
@@ -47,7 +42,7 @@ For example:
 fun String.bold(): String = "<b>$this</b>"
 
 fun main() {
-    // "hello" is the receiver object
+    // "hello" is the receiver
     println("hello".bold())
     // <b>hello</b>
 }
@@ -56,11 +51,11 @@ fun main() {
 
 In this example:
 
-* `String` is the extended class, also known as the receiver type.
+* `String` is the extended class.
 * `bold` is the name of the extension function. 
 * The `.bold()` extension function's return type is `String`.
-* `"hello"`, an instance of `String`, is the receiver object.
-* The receiver object is accessed inside the body by the [keyword](keyword-reference.md): `this`.
+* `"hello"`, an instance of `String`, as the receiver.
+* The receiver is accessed inside the body by the [keyword](keyword-reference.md): `this`.
 * A string template (`$`) is used to access the value of `this`.
 * The `.bold()` extension function takes a string and returns it in a `<b>` HTML element for bold text.
 

docs/topics/tour/kotlin-tour-intermediate-extension-functions.md

@@ -14,7 +14,7 @@
         <img src="icon-9-todo.svg" width="20" alt="Ninth step" /> <a href="kotlin-tour-intermediate-libraries-and-apis.md">Libraries and APIs</a></p>
 </tldr>
 
-In this chapter, you'll learn how to use receiver objects with another type of function, lambda expressions, and how they
+In this chapter, you'll learn how to use receivers with another type of function, lambda expressions, and how they
 can help you create a domain-specific language.
 
 ## Lambda expressions with receiver
@@ -80,7 +80,7 @@ In this example:
   directly as if they are inside the `Canvas` class.
 
 Lambda expressions with receiver are helpful when you want to create a domain-specific language (DSL). Since you have
-access to the receiver object's member functions and properties without explicitly referencing the receiver, your code 
+access to the receiver's member functions and properties without explicitly referencing the receiver, your code 
 becomes leaner.
 
 To demonstrate this, consider an example that configures items in a menu. Let's begin with a `MenuItem` class and a 

docs/topics/tour/kotlin-tour-intermediate-lambdas-receiver.md

@@ -126,7 +126,7 @@ fields. This means that you need to write the `get()` and `set()` functions your
 field means that they can't hold any state.
 
 To declare an extension property, write the name of the class that you want to extend followed by a `.` and the name of
-your property. Just like with normal class properties, you need to declare a receiver type for your property. 
+your property. Just like with normal class properties, you need to declare a type for your property. 
 For example:
 
 ```kotlin
@@ -135,7 +135,7 @@ val String.lastChar: Char
 {validate="false"}
 
 Extension properties are most useful when you want a property to contain a computed value without using inheritance.
-You can think of extension properties working like a function with only one parameter: the receiver object.
+You can think of extension properties working like a function with only one parameter: the receiver.
 
 For example, let's say that you have a data class called `Person` with two properties: `firstName` and `lastName`.
 

docs/topics/tour/kotlin-tour-intermediate-properties.md

@@ -392,7 +392,7 @@ fun main() {
 {kotlin-runnable="true" id="kotlin-tour-scope-function-with-after"}
 
 This example:
-* Uses the `with` scope function with the `mainMonitorSecondaryBufferBackedCanvas` instance as the receiver object.
+* Uses the `with` scope function with the `mainMonitorSecondaryBufferBackedCanvas` instance as the receiver.
 * Creates a temporary scope within the `with` scope function so that you don't have to explicitly refer to the `mainMonitorSecondaryBufferBackedCanvas` instance when calling its member functions.
 * Passes a lambda expression to the `with` scope function that calls a sequence of member functions with different function parameters.