This question belongs to View Building with SwiftUI , specifically the domain on extracting subviews to simplify the structure of an overlarge View .
When you create a custom SwiftUI view and add a stored property like:
let text: String
that property becomes part of the view's initializer. Since the property name is text, Swift expects you to pass the value using the parameter label text: when creating the view. So the correct call is:
BigGreenTextView(text: " That ' s all folks " )
That makes B the correct answer.
Why the others are wrong:
* A is incorrect because this is not using the expected parameter label.
* C would only be correct if there were already another variable named text in the calling scope and you wanted to pass that variable instead of the literal string shown in the question.
* D is incorrect because it omits the parameter label.
This is a standard SwiftUI pattern: extract reusable formatting into a separate custom View, give it an input property, and then pass the needed value through the initializer using the property label.

Explanation:

This question belongs to View Building with SwiftUI , specifically the domain on creating a multi-view app with navigation stacks, links, and sheets .
To present a modal view in SwiftUI when a Boolean state changes, the correct modifier is .sheet . The matching sheet API for a Boolean binding is:
sheet(isPresented: $showInfo) {
// modal content
}
So the first blank must be .sheet , and the second blank must be (isPresented: .
The logic works like this:
* @State stores the local Boolean that controls presentation.
* Pressing the button calls showInfo.toggle(), changing the value from false to true.
* When that Boolean becomes true, the .sheet(isPresented:) modifier presents the modal view.
* When the modal is dismissed, SwiftUI updates the Boolean back as needed.
There is also a typing issue in the screenshot: the state variable appears as ShowInfo, while the button and binding use showInfo. Swift is case-sensitive, so those names must match. The corrected code should use the same identifier consistently, such as:
@State var showInfo = false
Therefore, the correct dropdown selections are:
sheet
(isPresented:

This question belongs to Swift Programming Language , specifically the objective on managing data using collection types , including dictionaries and arrays . In the dictionary shown, the emojis are the keys and the text descriptions are the values . Swift provides a keys property on dictionaries that returns a collection containing all dictionary keys. To convert that keys collection into an array, you use the Array(...) initializer.
Therefore, the correct code is let emojis = Array(faces.keys). Apple documents both the Dictionary.keys property and the Array type used to store a sequence of values of the same type.
Option B is incorrect because faces.values would return the descriptions like " grinning " , " thinking " , and " happy " , not the emoji keys. Options A and C are incorrect because List is a SwiftUI view type, not the correct collection type for creating an array from dictionary contents. Also, the dictionary interface uses properties like .keys and .values, not method calls like .keys() or .values(). Apple's dictionary documentation makes clear that keys is a property returning a collection of the dictionary's keys.

This question belongs to Swift Programming Language , specifically the domain on functions , including internal and external parameter names and default parameter values .
The function is defined as:
func rightSum(_ num1: Int, by num2: Int, and num3: Int = 25) - > Int {
return num1 + num2 + num3
}
This means:
* the first parameter uses _, so it has no external label
* the second parameter must use the external label by
* the third parameter must use the external label and
* the third parameter also has a default value of 25, so it may be omitted Now evaluate each option:
* A is invalid because it uses num2: instead of the required external label by:
* B is valid because it correctly uses no label for the first argument, then by: and and:
* C is invalid because the first parameter cannot be called with num1: since the external label is omitted with _
* D is valid because it correctly passes the first argument unlabeled and the second with by:, while omitting the third argument so Swift uses the default value 25
* E is invalid because it uses num1: and num2: instead of the required calling syntax So the two correct function calls are B and D .