anchor.diff:  show_indented(Nodes) -> show_indented(Nodes, 0).
   show_indented(Nodes, Indent) ->
       %% print out the contents of a tree of nodes, indented appropriately
  -    Show = fun(Node) ->
  -        io:fwrite("~s~n", [string:chars($\s, Indent, Node#node.content)]),
  -        show_indented(Node#node.children, Indent + 4)
  +    Show = fun({Content, Children}) ->
  +        io:fwrite("~s~n", [string:chars($\s, Indent, Content)]),
  +        show_indented(Children, Indent + 4)
       end,
       lists:map(Show, Nodes).
   
  -get_node_path(Node, "") -> Node#node.content;
  -get_node_path(Node, ParentPath) ->
  -    Content = Node#node.content,
  +get_node_path({Content, _Children}, "") -> Content;
  +get_node_path({Content, _Children}, ParentPath) ->
       string:join([ParentPath, Content], ":").
   
   show_path(Nodes) -> show_path(Nodes, "").
   show_path(Nodes, ParentPath) ->
       %% print out the leaves of a tree with their parent path (root::parent::child::leaf)
  -    Show = fun(Node) ->
  -        NodePath = get_node_path(Node, ParentPath),
  -        case Node#node.children of
  +    Show = fun({Content, Children}) ->
  +        NodePath = get_node_path({Content, Children}, ParentPath),
  +        case Children of
               [] -> io:fwrite("~s~n", [NodePath]);
  -            Children -> show_path(Children, NodePath)
  +            _ -> show_path(Children, NodePath)
           end
       end,
       lists:map(Show, Nodes).
  
positive.code: -export([main/1, show_path/1, show_indented/1, build_nodes/3]).
  %% Needs to be compiled so we can specify our output functions.
  -mode(compile).
  -record(line, {content, indent}).
  -record(node, {content, children}).
  
  
  parse_text_line(Text) ->
      %% converts "    text" to (:content "text" :indent 4)
      Content = string:strip(string:strip(Text, left), left, $\t),
      Indent = length(Text) - length(Content),
      #line{content=string:strip(Content, right, $\n), indent=Indent}.
  
  
  build_nodes(Parent, Group, []) -> Parent ! {Group, []};
  build_nodes(Parent, Group, [First|Rest]) ->
      %% split off our children from the rest of the Lines.
      %% the first line with an indent =< ours is a sibling, not a child
      IsChild = fun(L) -> L#line.indent > First#line.indent end,
      {ChildLines, SiblingLines} = lists:splitwith(IsChild, Rest),
      spawn(?MODULE, build_nodes, [self(), children, ChildLines]),
      spawn(?MODULE, build_nodes, [self(), siblings, SiblingLines]),
      receive
          {children, Children} ->
              Node = #node{content=First#line.content, children=Children}
      end,
      receive
          {siblings, Siblings} ->
              io:fwrite( "[~s] ~p~n", [Node#node.content, self()]),
              Parent ! {Group, [Node|Siblings]}
      end.
  
  
negative.code: get_all_lines(Stream) -> get_all_lines(Stream, []).
  get_all_lines(Stream, Lines) ->
      case io:get_line(Stream, "") of
          eof -> lists:reverse(Lines);
          Line -> get_all_lines(Stream, [Line|Lines])
      end.
  
  process_stream(Stream, ShowFunc) ->
  