IndexSet is a collection of increasing integers, therefore you can map each index to the corresponding array element:

let array = ["sun", "moon", "star", "meteor"]
let indexSet: IndexSet = [2, 3]

let result = indexSet.map { array[$0] } // Magic happening here!
print(result) // ["star", "meteor"]

This assumes that all indices are valid for the given array. If that is not guaranteed then you can filter the indices (as @dfri correctly remarked):

let result = indexSet.filteredIndexSet { $0 < array.count }.map { array[$0] }

You can filter the indices of the array directly, it avoids the extra mapping.

let items = ["A", "B", "A", "C", "A", "D"]
let filteredIndices = items.indices.filter {items[$0] == "A"}

or as Array extension:

extension Array where Element: Equatable {

    func whatFunction(_ value :  Element) -> [Int] {
        return self.indices.filter {self[$0] == value}
    }

}

items.whatFunction("A") // -> [0, 2, 4]
items.whatFunction("B") // -> [1]

or still more generic

extension Collection where Element: Equatable {

    func whatFunction(_ value :  Element) -> [Index] {
        return self.indices.filter {self[$0] == value}
    }

}

Assuming that

• the given indices are in increasing order, and
• all indices are valid for the array (i.e. less than the number of elements),

then a simple map operation would work:

let indexes = [2, 4, 7]
let myArray = ["a", "b", "c", "d", "e", "f", "g", "h"]

let filtered = indexes.map { myArray[$0] }
print(filtered) //["c", "e", "h"]

Remark: In earlier Swift releases, there was a PermutationGenerator exactly for this purpose:

let filtered = Array(PermutationGenerator(elements: myArray, indices: indexes))
print(filtered) //["c", "e", "h"]

However, this has been deprecated in Swift 2.2 and will be removed in Swift 3. I haven't seen a Swift 3 replacement yet.

If I read the question correctly, you want to find the index of the array who's first element matches a search pattern. The following demonstrates how to do that:

var receivedList = [["Name1","Apple","Fresh"],["Name2","Orange","Rotten"],["Name3","Pear","Fresh"],["Name4","Grape","Rotten"]]
var searchText = "Name2"

let index = receivedList.index { $0[0] == searchText }

print(index)

The following will filter your list to only those whose first element contains the search text:

let matches = receivedList.filter { $0[0].contains(searchText) }

If you want the indexes that match, then you can use:

let matches = receivedList
    .enumerated()
    .filter { $0.1[0].contains(searchText) }
    .map { $0.0 }

The way you are doing it is not correct, you are altering an array while looping through it. When you remove an object from the array, the array count changes but the loop still run using the previously calculated array.count value.

There is a much simpler way of doing this, you just need to combine filter and contains functions together for achieving this:

func filterArray( _ x:  [Int], _ nums: Int...) -> [Int]
{
    let filteredArray = x.filter({ !nums.contains($0)})
    return filteredArray
}

I think the easiest way is this:

if let index = placeDataArray.indexOf ({ $0.description == "Afghanistan" })
{
    placeDataArray[index].selected = true
}

It does not require Equatable.

Similarly, you can use filter to show only selected items:

let selected = placeDataArray.filter { $0.selected == true }

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.

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

You don't need a filter. You can simply call removeSubrange.

myArray.removeSubrange(20..30)

And for the sake of completeness, here is an option using a filter:

myArray = myArray.enumerated().filter { $0.offset < 20 || $0.offset > 30 }.map { $0.element }

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"}]