Parsing DAG from text
Make things easier on yourself by separating concerns. E.g., each line encodes a position in its amount of leading whitespace followed by an identifier. Parse this representation into a more manipulable form in a single function invocation, don't thread it through your algorithm logic which shouldn't care about serialized representation.

type SerializedGraph = String -- Aliases for pedagogical clarity
type Indentation = Int
type Symbol = String

parse :: SerializedGraph -&gt; [(Indentation, Symbol)]
parse = map (first length . span (== ' ')) . lines
    where first :: (a -&gt; b) -&gt; (a, c) -&gt; (b, c)
          first f (a, c) = (f a, c)


Now consider intermediate representations that can get you closer to your goal. Remember that it's easy to construct a map from an association list with fromList, so let's make that our end goal. Write out the types for a roadmap from where we are to where we want to be.

    [(Indentation, Symbol)] -- [(Hint, Key)]
==&gt; ???
==&gt; [(Symbol, [Symbol])] -- [(Key, [Value])]


If that final representation has only unique keys, then a reasonable intermediary would be one that hasn't had values which share a key accumulated yet. I.e., [(Symbol, Symbol)] -- [(Key, Value)].

associate :: [(Int, String)] -&gt; [(String, String)]
associate []          = []
associate ((i, s):ss) = [(s, t) | (j, t) &lt;- descendants, j == i + 1]
                     ++ associate descendants
                     ++ associate siblings
    where (descendants, siblings) = span ((&gt; i) . fst) ss


Now all that's left to do is create a Map. We could accumulate values on our own, but really that's what fromListWith is for.

toMap :: [(String, String)] -&gt; Map String [String]
toMap = fromListWith (++) . map (second (:[]))
    where second f (a, b) = (a, f b)


All that's left is composing these functions together.

readGraph :: String -&gt; Map String [String]
readGraph = toMap . associate . parse