C#•11mo ago

✅ Separate local function with explicit 'return' statement

C#

string[] words = {"racecar" ,"talented", "deified", "tent", "tenet"};

Console.WriteLine("Is it a palindrome?");
foreach (string word in words) 
{
    Console.WriteLine($"{word}: {IsPalindrome(word)}");
}

bool IsPalindrome(string word)
{
    int startPointerIndex = 0;
    int endPointerIndex = word.Length - 1;
    for (int i = 0; i < word.Length - 1; i++)
    {
        if (word[startPointerIndex] == word[endPointerIndex] && startPointerIndex < endPointerIndex)
        {
            continue;
        }
        else
        {
            return false;
        }

        startPointerIndex++;
        endPointerIndex--;
    }

    return true;
}

C#

string[] words = {"racecar" ,"talented", "deified", "tent", "tenet"};

Console.WriteLine("Is it a palindrome?");
foreach (string word in words) 
{
    Console.WriteLine($"{word}: {IsPalindrome(word)}");
}

bool IsPalindrome(string word)
{
    int startPointerIndex = 0;
    int endPointerIndex = word.Length - 1;
    for (int i = 0; i < word.Length - 1; i++)
    {
        if (word[startPointerIndex] == word[endPointerIndex] && startPointerIndex < endPointerIndex)
        {
            continue;
        }
        else
        {
            return false;
        }

        startPointerIndex++;
        endPointerIndex--;
    }

    return true;
}

C#

string[] words = {"racecar" ,"talented", "deified", "tent", "tenet"};

Console.WriteLine("Is it a palindrome?");
foreach (string word in words) 
{
    Console.WriteLine($"{word}: {IsPalindrome(word)}");
}

bool IsPalindrome(string word)
{
    int startPointerIndex = 0;
    int endPointerIndex = word.Length - 1;
    for (int i = 0; i < word.Length - 1; i++)
    {
        if (word[startPointerIndex] == word[endPointerIndex] && startPointerIndex < endPointerIndex)
        {
            continue;
        }
        else
        {
            return false;
        }

        startPointerIndex++;
        endPointerIndex--;
    }

    return true;
}

C#

string[] words = {"racecar" ,"talented", "deified", "tent", "tenet"};

Console.WriteLine("Is it a palindrome?");
foreach (string word in words) 
{
    Console.WriteLine($"{word}: {IsPalindrome(word)}");
}

bool IsPalindrome(string word)
{
    int startPointerIndex = 0;
    int endPointerIndex = word.Length - 1;
    for (int i = 0; i < word.Length - 1; i++)
    {
        if (word[startPointerIndex] == word[endPointerIndex] && startPointerIndex < endPointerIndex)
        {
            continue;
        }
        else
        {
            return false;
        }

        startPointerIndex++;
        endPointerIndex--;
    }

    return true;
}

Hello guys, can someone explain why my IDE yells at me to use an "explicit" return statement pls. What is it trying to convey and why should I use it?

dcode1213•1/29/25, 6:31 PM

The reason your IDE is complaining about using an explicit return statement is due to how your IsPalindrome method is structured. Specifically, the problem is in the loop condition.

You have a loop that iterates with i, but inside the loop, you’re checking if the characters at startPointerIndex and endPointerIndex match. However, the loop itself runs one iteration too many, because the condition i < word.Length - 1 means that it will not check the last character properly.

Additionally, the loop structure and flow may result in the IDE warning you to use an explicit return statement, particularly because it expects that a value should be returned in all possible cases (even if you reach the end of the method). To resolve this issue, you should adjust the loop and the condition where the return statement is placed.

Ddcode1213 The reason your IDE is complaining about using an explicit return statement is d...

FakerOP•1/29/25, 8:52 PM

ahhh yeah true, I shouldn't have the word.Length -1 but word.Length. The problem was due to that? Like no taking into account all iterations possible? Because when I change it, the warning went away but still I don't get what the message is trying to say, for e.g. in the code above where would I put an explicit return statement pls

FakerOP•1/29/25, 8:53 PM

Also, does it matter if I ignore this warning ?

FFaker Also, does it matter if I ignore this warning ?

Mayor McCheese•1/30/25, 7:13 AM

you can safely ignore, you probably shouldn't, but you can

Mayor McCheese•1/30/25, 7:32 AM

@Faker It also has nothing to do with the internals of IsPalindrome. There is an analyzer suggesting a return such that any local functions are "unreachable code". In the example below, if you paste into an IDE you'll get the warning on line 9, and a slightly different warning on line 11.

string[] words = { "racecar", "talented", "deified", "tent", "tenet" };

Console.WriteLine("Is it a palindrome?");
foreach (string word in words)
{
    Console.WriteLine($"{word}: {IsPalindrome(word)}");
}

bool IsPalindrome(string word)
{
    bool CheckIsPalindrome()
    {
        for (int left = 0, right = word.Length - 1; left < right; left++, right--)
            if (char.ToLower(word[left]) != char.ToLower(word[right]))
                return false;

        return true;
    }

    return CheckIsPalindrome();
}

string[] words = { "racecar", "talented", "deified", "tent", "tenet" };

Console.WriteLine("Is it a palindrome?");
foreach (string word in words)
{
    Console.WriteLine($"{word}: {IsPalindrome(word)}");
}

bool IsPalindrome(string word)
{
    bool CheckIsPalindrome()
    {
        for (int left = 0, right = word.Length - 1; left < right; left++, right--)
            if (char.ToLower(word[left]) != char.ToLower(word[right]))
                return false;

        return true;
    }

    return CheckIsPalindrome();
}

Adding the local functions explicitly below the return leaves the logic of the function separated from the rest of the code giving you a cleaner separation.

string[] words = { "racecar", "talented", "deified", "tent", "tenet" };

Console.WriteLine("Is it a palindrome?");
foreach (string word in words)
{
    Console.WriteLine($"{word}: {IsPalindrome(word)}");
}

return;

bool IsPalindrome(string word)
{
    return CheckIsPalindrome();

    bool CheckIsPalindrome()
    {
        for (int left = 0, right = word.Length - 1; left < right; left++, right--)
            if (char.ToLower(word[left]) != char.ToLower(word[right]))
                return false;

        return true;
    }
}

string[] words = { "racecar", "talented", "deified", "tent", "tenet" };

Console.WriteLine("Is it a palindrome?");
foreach (string word in words)
{
    Console.WriteLine($"{word}: {IsPalindrome(word)}");
}

return;

bool IsPalindrome(string word)
{
    return CheckIsPalindrome();

    bool CheckIsPalindrome()
    {
        for (int left = 0, right = word.Length - 1; left < right; left++, right--)
            if (char.ToLower(word[left]) != char.ToLower(word[right]))
                return false;

        return true;
    }
}

TThaumanovic My question is why you're using local functions for this in the first place.

Mayor McCheese•1/30/25, 2:10 PM

The easy answer is they aren't intentionally. My example adds more clarity into why the message is coming up. This is just all top level statements.

MMayor McCheese @Faker It also has nothing to do with the internals of IsPalindrome. There is an...

FakerOP•1/30/25, 5:24 PM

yeah I see, the idea is the IDE expect that the code needs to run until the end, but the thing is at the end, we have a method definition; we just use return to indicate that we are leaving the "outer" method ?

TThaumanovic My question is why you're using local functions for this in the first place.

FakerOP•1/30/25, 5:25 PM

Hmm in the exercise template I used, I think they use the local function (function inside function); this isn't recommended or?

FakerOP•1/30/25, 6:05 PM

ahhh I see

FakerOP•1/30/25, 6:05 PM

yep noted, thanks !

FFaker yeah I see, the idea is the IDE expect that the code needs to run until the end,...

Mayor McCheese•1/30/25, 6:38 PM

Yesish, the compiler doesn't care either way, it's purely about readability from humans

Mayor McCheese•1/30/25, 6:40 PM

Local functions can damage human readability so should be used with care.

In rare cases the compiler won't be able to resolve a location function.

Mayor McCheese•1/30/25, 6:41 PM

Like Thaum says in general the use cases are pretty niche

FakerOP•1/30/25, 6:41 PM

yep I see, I just stick in writing functions on their own, like no nested functions for now then, unless I have a use case?

Mayor McCheese•1/30/25, 6:42 PM

Basically

Mayor McCheese•1/30/25, 6:43 PM

The thing I want to really call out, is the initial answer you got was "wrong"

FakerOP•1/30/25, 6:43 PM

hmm in what sense pls

Mayor McCheese•1/30/25, 6:44 PM

I'm not saying their statements were wrong about the loop complexity, but rather that the reason you got the analyzer warning had nothing to do with that

Mayor McCheese•1/30/25, 6:44 PM

Your loop complexity could be perfect and you'd still get it

FakerOP•1/30/25, 6:45 PM

Mayor McCheese•1/30/25, 6:46 PM

I'm not saying their advice was wrong, but that it didn't answer the question you had

FakerOP•1/30/25, 6:46 PM

yep I see

FakerOP•1/30/25, 6:46 PM

basically the answer was to mark the "end" of the "outer" function, for readability like you said?

Mayor McCheese•1/30/25, 6:47 PM

ipso facto, if you went with the initial answer every time you saw the analyzer get triggered you'd potentially end up looking for a problem that didn't exist

Mayor McCheese•1/30/25, 6:48 PM

If that makes a lick of sense

FakerOP•1/30/25, 6:48 PM

yeah true

Mayor McCheese•1/30/25, 7:27 PM

Anyway, if you're happy with the answer(s)
$close

MMayor McCheese Anyway, if you're happy with the answer(s) $close

MODiX•1/30/25, 7:27 PM

If you have no further questions, please use /close to mark the forum thread as answered

FakerOP•1/30/25, 7:27 PM

Yep, thanks !

string[] words = { "racecar", "talented", "deified", "tent", "tenet" }; Console.WriteLine("Is it a palindrome?"); foreach (string word in words) { Console.WriteLine($"{word}: {IsPalindrome(word)}"); } bool IsPalindrome(string word) { bool CheckIsPalindrome() { for (int left = 0, right = word.Length - 1; left < right; left++, right--) if (char.ToLower(word[left]) != char.ToLower(word[right])) return false; return true; } return CheckIsPalindrome(); }

string[] words = { "racecar", "talented", "deified", "tent", "tenet" }; Console.WriteLine("Is it a palindrome?"); foreach (string word in words) { Console.WriteLine($"{word}: {IsPalindrome(word)}"); } return; bool IsPalindrome(string word) { return CheckIsPalindrome(); bool CheckIsPalindrome() { for (int left = 0, right = word.Length - 1; left < right; left++, right--) if (char.ToLower(word[left]) != char.ToLower(word[right])) return false; return true; } }

✅ Separate local function with explicit 'return' statement

Similar Threads

Similar Threads

Similar Threads