Parse a nested parentheses Objective
Mimic Haskell's reads :: ReadS ().
Or in other words, parse nested parentheses. Since the target type is () (the type with one possible value), &quot;parsing&quot; means discarding a leading nested parentheses.
Valid Input
&quot;Nested parentheses&quot; means (), (()), ((())), and so on. That is, leading nonzero (s and trailing )s of the same number.
But there's a twist. The parser must munch also leading or intercalated whitespaces. So for example, the following strings are valid to be munched:

( )
 ()
  (  ()    )

Note that trailing whitespaces are not to be munched.
Whitespaces
The following ASCII characters are always considered a whitespace:

\t U+0009; Horizontal Tab
\n U+000A; Line Feed
\v U+000B; Vertical Tab
\f U+000C; Form Feed
\r U+000D; Carriage Return
  U+0020; Space

For each of the following Unicode characters, it is implementation-defined to consider it a whitespace:

U+0085; Next Line
U+00A0; No-Break Space
U+1680; Ogham Space Mark
U+2000; En Quad
U+2001; Em Quad
U+2002; En Space
U+2003; Em Space
U+2004; Three-Per-Em Space
U+2005; Four-Per-Em Space
U+2006; Six-Per-Em Space
U+2007; Figure Space
U+2008; Punctuation Space
U+2009; Thin Space
U+200A; Hair Space
U+2028; Line Separator
U+2029; Paragraph Separator
U+202F; Narrow No-Break Space
U+205F; Medium Mathematical Space
U+3000; Ideographic Space

All other characters are never considered a whitespace.
Error
If the string doesn't start with a nested parentheses, the parser shall fall in an erroneous state. Ways that indicates an error include:

Monadic failing
Returning an erroneous value
Raising/Throwing an error

Output
When the parser successfully munched a nested parentheses, the parser shall output the unmunched part of string.
Examples
Valid example

When given (), the output is an empty string.
When given  ( ) Hello, the output is  Hello. Note the leading whitespace of the output.
when given ((())))), the output is )).

Erroneous example

Empty string
((()
(()())
(H)
Hello, world!

Ungolfed solution
C
Returns a null pointer for an error.
#include &lt;stdbool.h&gt;
#include &lt;stdlib.h&gt;

char *readMaybeUnit(char *str) {
    bool p = false;
    unsigned c = 0;
    while (*str != '\0') {
        switch (*str) {
        case '(':
            p = true;
            ++c;
            // FALLTHRU
        case '\t': case '\n': case '\v': case '\f': case '\r': case ' ':
            break;
        default:
            goto parseRightParentheses;
        }
        ++str;
    }
    parseRightParentheses: while (*str != '\0') {
        switch (*str) {
        case ')':
            if (1 &gt;= c) {
                if (1 == c)
                    ++str;
                c = 0;
                goto returnReadMaybeUnit;
            }
            --c;
            // FALLTHRU
        case '\t': case '\n': case '\v': case '\f': case '\r': case ' ':
            break;
        default:
            goto returnReadMaybeUnit;
        }
        ++str;
    }
    returnReadMaybeUnit: return p &amp;&amp; 0 == c ? str : NULL;
}
Retina 0.8.2, 32 31 bytes
^(\s*\()+(?&lt;-1&gt;\s*\))+(?(1)$.)


Try it online! Link includes test cases. Returns the original string on error. Considers the given control characters as white space, plus any Unicode characters (such as space) in the Separator group, plus U+0085. If only the minimal white space is desired, this can be achieved by prefixing e`. Explanation:
^(\s*\()+

Match some open parentheses at the start of the string.
(?&lt;-1&gt;\s*\))+

Match some close parentheses.
(?(1)$.)

Check that the same number of open and close parentheses were matched.


Delete the matched parentheses.
Alternative solution, also 31 bytes:
r`^(?&lt;-1&gt;\s*\()+(\s*\))+(.*)
$2

Try it online! Link includes test cases. If only the minimal white space is desired, this can be achieved by prefixing e. Explanation:
r`

Start matching at the end of the string and work backwards (like a lookbehind would).
(.*)

Match as much result as possible.
(\s*\))+

Match some close parentheses.
^(?&lt;-1&gt;\s*\()+

Match the open parentheses at the start of the string. The number of close parentheses must be at least as many as the number of open parentheses for the balancing group to succeed, but it can't be more because the (.*) ensures that as few close parentheses are matched as possible.
$2

Keep everything except the matched parentheses.
Previous 32-byte solution that returns the empty string on error:
1!`(?&lt;=^(?&lt;-1&gt;\s*\()+(\s*\))+).*

Try it online! Link includes test cases. If only the minimal white space is desired, this can be achieved by prefixing e. Explanation:
1!`

Output the matched part of the first match.
(?&lt;=^(?&lt;-1&gt;\s*\()+(\s*\))+)

Ensure that the match starts after balanced parentheses. Note that this is a lookbehind, so the match is processed right-to-left - the )s are matched first, then a ( can be matched for each ). There can't be too many )s because the lookbehind would have matched earlier, meaning that this is no longer the first match.
.*

Match the rest of the string. This actually counts as part of the match, and therefore becomes the resulting output.