Advent of Code 2019: Day 6 (with Trees)
break and span
When we try to split a string in Haskell, we're a little bit out of luck if we only use the trusty Prelude and base. Handy functions like split or splitOn  are in the adaptly named split package, and parser combinators are completely other beasts and an oribtal (heh) laser cannon on this problem.
However, there are two functions that provide almost exactly what parseOrbit is trying to achieve: splitting a string on a single character:
span, break :: (a -&gt; Bool) -&gt; [a] -&gt; ([a], [a])
span  f xs = (takeWhile f xs, dropWhile f xs)
break f xs = span (not . f)

We can simplify parseOrbit therefore to
parseOrbit :: String -&gt; Orbit
parseOrbit s = let (a, _:b) = break (==')') s in (a, b)

However, you seem to prefer where, so let's use a where clause instead:
parseOrbit :: String -&gt; Orbit
parseOrbit s = (a, b)
    where (a, _:b) = break (==')') s

Type signatures in where clauses
As we have seen above, (a, _:b) had no type signature. Type signatures in where clasues are usually omitted. There is some controversy about that, however there are some things to keep in mind:

GHC never warns about missing type signatures in where clauses
functions with type parameters cannot have a type without ScopedTypeSignatures (see this SO question for an example)
a change in the top level type signature might need a lot of changes in where clauses
if a function is complex enough to need a type, it might be reasonable to promote it into a top-level function. That way it can also be tested.

I personally therefore omit type signatures in where clauses (ST shenengians aside).