This is what I have working in a playground, any reason why this is no good?

class Book {
    var author = String()

    init(author:String){
        self.author = author
    }
}

var allBooks: [Book] = []

allBooks.append(Book(author: "John Smith"))
allBooks.append(Book(author: "Arthur Price"))
allBooks.append(Book(author: "David Jones"))
allBooks.append(Book(author: "Somebody Else"))

let authors = ["Arthur Price", "David Jones"]

let filteredBooks = allBooks.filter({authors.contains($0.author)})

filteredBooks       // [{author "Arthur Price"}, {author "David Jones"}]

contains() checks if a sequence contains a given element, e.g. if a String contains a given Character.

If your intention is to find all books where the name contains the substring "rt", then you can use rangeOfString():

var arr = englishBooks.filter {
    $0.nameOfBook.rangeOfString("rt") != nil
}

or for case-insensitive comparison:

var arr = englishBooks.filter {
    $0.nameOfBook.rangeOfString("rt", options: .CaseInsensitiveSearch) != nil
}

As of Swift 2, you can use

nameOfBook.containsString("rt") // or
nameOfBook.localizedCaseInsensitiveContainsString("rt")

and in Swift 3 this is

nameOfBook.contains("rt") // or
nameOfBook.localizedStandardContains("rt") // or
nameOfBook.range(of: "rt", options: .caseInsensitive) != nil

try this

let filteredArray = self.originalArray.filter({($0.itemCategory.localizedCaseInsensitiveContains(searchText))!})

This is unnecessarily complex. There's no need for NSPredicate here.

var studios = [Studio]()
var filteredStudios = [Studio]()
var studiosToDisplay = [Studio]()

func updateSearchResultsForSearchController(searchController: UISearchController) {
    let searchText = searchController.searchBar.text

    print("SEARCH TEXT: \(searchText)")

    if let searchText = searchText, !searchText.isEmpty {
        studiosToDisplay = studios.filter{ $0.studioName.contains(searchText) }
    }
    else {
        studiosToDisplay = studios
        NSNotificationCenter.defaultCenter().postNotificationName("showResultsBeforeSearchingNotification", object: nil) //Calls SearchVC
    }

    self.resultTableView.reloadData()
}

// this is not working - NSArray is not a subtype of Images- so what if there is only 1 possible result?

You have no way to prove at compile-time that there is only one possible result on an array. What you're actually asking for is the first matching result. The easiest (though not the fastest) is to just take the first element of the result of filter:

let imageObject = questionImageObjects.filter{ $0.imageUUID == imageUUID }.first

imageObject will now be an optional of course, since it's possible that nothing matches.

If searching the whole array is time consuming, of course you can easily create a firstMatching function that will return the (optional) first element matching the closure, but for short arrays this is fine and simple.

As charles notes, in Swift 3 this is built in:

questionImageObjects.first(where: { $0.imageUUID == imageUUID })

import UIKit

First of all you don't need to inherit from NSObject. Also, if you don't need reference semantics, use structs instead.

struct TicketsCellModel {
  var title: String?
  var text: String?
  var price: String?
  var tintColor: UIColor?
  var quantity: Int?
}

It's not really necessary to use a closure to create an [TicketsCellModel]. Just assign the elements directly. Since we're using structs we don't need to create a separate init.

var ticketCellModels = [
  TicketsCellModel(
    title: "Standard Entry",
    text: "This is aa standard entry ticket, it's not sutiable for special events please see the plus ticket for that.",
    price: "£8.35",
    tintColor: UIColor.white,
    quantity: 0
  ),
  TicketsCellModel(
    title: "Standard with re-entry",
    text: "This is a standard entry ticket but you can come and go as you please during the night.",
    price: "£8.99",
    tintColor: UIColor.white,
    quantity: 2
  ),
  TicketsCellModel(
    title: "Plus Entry",
    text: "This is the plus entry ticket for special events.",
    price: "£9.99",
    tintColor: UIColor.white,
    quantity: 0
  ),
  TicketsCellModel(
    title: "VIP Entry",
    text: "Here is some more text that is to act as a description for this thing you will purchase.",
    price: "£12.99",
    tintColor: UIColor.white,
    quantity: 4
  )
]

Now, if you need to access an optional, you will have to unwrap it first. The safest way to do this is using the if let construct or using the nil-coalescing operator.

let filteredTicketCellModels = ticketCellModels.filter { $0.quantity ?? 0 > 0 }

print(filteredTicketCellModels)

In the example above there are no unknown variables during initialization, so maybe non-optional properties might be better suited. Then you don't have to unwrap anything.

Leo Dabus adds that it is recommended that all properties be constants. The way to do this is to replace all vars with lets. If you need to change a property you can create a new object copying the properties from the old one and adding the new values to the properties that have changed.

You could do something like:

let monsters: [Monster] = ...

let monsterNames: [String] = ...

let filteredMonsters = monsters.filter { monsterNames.contains($0.name) }

This doesn't perform all that well, since it will go over the names array up to n times for each monster, but if your names arrays is small, this won't be a problem.

One approach is to update your filter to see if any value in pets is in the petArr array:

users = users.filter { $0.pets.contains(where: { petArr.contains($0) }) }

The first $0 is from the filter and it represents each User.

The second $0 is from the first contains and it represents each pet within the pets array of the current User.