An objective-c variable being assigned a value from a mutable array element is not being correctly assigned a type

I have a situation I can’t explain why is happening, can’t fix it, and can’t figure a work around for it. I have a mutable object array that holds a variable number of objects. Each object is either a string file name or a URL of a web location. I have another mutable array of integer objects that identifies the type of object at a particular index in the first array, either a 0 for string file name, or a 1 for a URL. Now, I need to access and use the elements in the first array. I index the objects and select an object with: myObject = [ArrayName objectAtIndex:index]. Monitoring the execution of this line of code reveals that myObject becomes a URL type object even if it has been defined as an NSString. If I attempt to use myObject as a string it throws an execution error saying myObject is a URL.

I’ve tried typedefing myObject as a string but it won’t take. Conversely if I attempt to convert myObject to a string using NSURL’s URLWithString or NSString’s stringWithContentsOfURL: encoding:error: which failed when using myObject as a URL. So I’m stuck, one set of methods thinks its another type of object, the other type of methods thinks its the other type of object. Where the debugger gets the ides that the string object is a URL I have no idea. Other questions don't exactly address this situation.
Any ideas or work arounds would be welcome.

I believe you have an NSArray like this (there's no important difference here between NSArray and NSMutableArray for this question):

NSArray *array = @[
    @"This is a string",
    [NSURL URLWithString:@"https://stackoverflow.com"],
];

Each element may be a different type. So when fetching elements, the only type you can really use is id ("some object"):

id item = array[0];

Now you need to figure out what type it is. You can do that with -isKindOfClass:. For example:

if ([item isKindOfClass:[NSString class]]) {
    // Since it's known to be an NSString, assign it a type to improve type-safety.
    // This way the compiler will provide warnings if incorrect methods are called.
    NSString *string = item;
    NSLog(@"This is a string with length: %lu", (unsigned long)[string length]);
} else if ([item isKindOfClass:[NSURL class]]) {
    NSURL *url = item;
    NSLog(@"This is a URL with absoluteString: %@", 
);
} else {
    NSLog(@"Unexpected type found in array: %@", [item class]);
}

If you write something like NSString *item = array[0], Objective-C will assume you know for certain that the element is an NSString. That does not make it an NSString. If you're wrong, and you send a message that NSString doesn't respond to, the program will crash.

Generally speaking, multi-type (heterogeneous) arrays are a bad idea. The compiler relies on the programmer to do everything correctly, and can't help very much. But in some cases they're extremely useful, and a powerful feature of Objective-C.

You should strongly avoid having a separate array that keeps track of the types. That's just begging to be out of sync and cause problems.