title: MapAnnotations Not Showing Up
body: <p>I have a function that takes my coordnaties that are stored inside of my Firebase Storage, and turns them into <code>MKPointAnnotations</code> For Some Reason I keep on getting the error <code>Type '()' cannot conform to 'View'</code></p>
  <p>Here is my code for the function:</p>
  <pre><code>
  import SwiftUI
  import MapKit
  import CoreLocationUI
  import Firebase
  import FirebaseFirestore
  
  struct Marker: Identifiable {
      let id = UUID()
      var coordinate : CLLocationCoordinate2D
  }
  
  struct MapView: View {
      
      @StateObject private var viewModel = ContentViewModel()
      
      //For GeoCoder
      let geocoder = CLGeocoder()
      @State private var result = &quot;result of lat &amp; long&quot;
      @State private var lat = 0.0
      @State private var long = 0.0
      @State private var country = &quot;country name&quot;
      @State private var state = &quot;state name&quot;
      @State private var zip = &quot;zip code&quot;
      
      //For Map Annotations
      @State var address = &quot;&quot;
      @State var realLat = 0.00
      @State var realLong = 0.00
      @State var email = &quot;&quot;
      
      //For TopBar
      @State var goToAddress = &quot;&quot;
      @State var filters = false
      
      var body: some View {
          
          let markers = [
              Marker(coordinate: CLLocationCoordinate2D(latitude: realLat, longitude: realLong))
          ]
          
          NavigationView {
              VStack {
                  ZStack (alignment: .bottom) {
                      LocationButton(.currentLocation) {
                          viewModel.requestAllowOnceLocationPermission()
                      }
                      .foregroundColor(.white)
                      .cornerRadius(8)
                      .labelStyle(.iconOnly)
                      .symbolVariant(.fill)
                      .tint(.pink)
                      .padding(.bottom)
                      .padding(.trailing, 300)
                      
                      getAnnotations { (annotations) in
                          if let annotations = annotations {
                              Map(coordinateRegion: $viewModel.region, showsUserLocation: true, annotationItems: MKPointAnnotation) { annotations in
                                  MapAnnotation(coordinate: annotations.coordinate) {
                                      Circle()
                                  }
                              }
                              .ignoresSafeArea()
                              .tint(.pink)
                          } else {
                              print(&quot;There has been an error with the annotations&quot;)
                          }
                      }
                  }
              }
          }
      }
      
      func getAnnotations(completion: @escaping (_ annotations: [MKPointAnnotation]?) -&gt; Void) {
          let db = Firestore.firestore()
          
          db.collection(&quot;annotations&quot;).addSnapshotListener { (querySnapshot, err) in
              guard let snapshot = querySnapshot else {
                  if let err = err {
                      print(err)
                  }
                  completion(nil) // return nil if error
                  return
              }
              guard !snapshot.isEmpty else {
                  completion([]) // return empty if no documents
                  return
              }
              var annotations = [MKPointAnnotation]()
              
              for doc in snapshot.documents {
                  if let lat = doc.get(&quot;lat&quot;) as? String,
                     let lon = doc.get(&quot;long&quot;) as? String,
                     let latitude =  Double(lat),
                     let longitude = Double(lon) {
                      let coord = CLLocationCoordinate2D(latitude: latitude, longitude: longitude)
                      let annotation = MKPointAnnotation()
                      annotation.coordinate = coord
                      annotations.append(annotation)
                  }
              }
              completion(annotations) // return array
          }
      }
      
      func goToTypedAddress() {
          geocoder.geocodeAddressString(goToAddress, completionHandler: {(placemarks, error) -&gt; Void in
              if((error) != nil){
                  print(&quot;Error&quot;, error ?? &quot;&quot;)
              }
              if let placemark = placemarks?.first {
                  let coordinates:CLLocationCoordinate2D = placemark.location!.coordinate
                  print(&quot;Lat: \(coordinates.latitude) -- Long: \(coordinates.longitude)&quot;)
                  //added code
                  result = &quot;Lat: \(coordinates.latitude) -- Long: \(coordinates.longitude)&quot;
                  lat = coordinates.latitude
                  long = coordinates.longitude
              }
          })
          print(&quot;\(lat)&quot;)
          print(&quot;\(long)&quot;)
      }
  }
  struct MapView_Previews: PreviewProvider {
      static var previews: some View {
          MapView()
      }
  }
  
  struct Item: Identifiable {
      let id = UUID()
      let text: String
  }
  
  
  //LocationButton
  final class ContentViewModel: NSObject, ObservableObject, CLLocationManagerDelegate  {
      @Published var region = MKCoordinateRegion(center: CLLocationCoordinate2D(latitude: 40, longitude: 120), span: MKCoordinateSpan(latitudeDelta: 100, longitudeDelta: 100))
      
      let locationManager = CLLocationManager()
      
      override init() {
          super.init()
          locationManager.delegate = self
      }
      
      func requestAllowOnceLocationPermission() {
          locationManager.requestLocation()
      }
      
      func locationManager( _ _manager:CLLocationManager, didUpdateLocations locations: [CLLocation]){
          guard let latestLocation = locations.first else {
              // show an error
              return
          }
          DispatchQueue.main.async{
              self.region = MKCoordinateRegion(
                  center: latestLocation.coordinate,
                  span:MKCoordinateSpan(latitudeDelta:0.05, longitudeDelta:0.05))
          }
      }
      
      func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
          print(error.localizedDescription)
      }
  }
  
  </code></pre>
  <p>The updated error is on line 50 now. Might be because of all of the new functions that I have. Also is the firebase function correct? I would like to make sure that it correct too.</p>