anchor.diff:      | Section(a, _) -> Section(a, spans)
       | Paragraph(_) -> Paragraph(spans)
       | Span(_) -> Span(spans)
  -    | _ -> invalidArg "" "Incorrect ParagraphSpansInfo."
  +    //| _ -> invalidArg "" "Incorrect ParagraphSpansInfo." //commented out because it says the rule will never be matched.
   
     let ParagraphLeaf (PL(par)) = par
   
  
positive.code:   | Underline of FountainSpans
    | HardLineBreak
  
  /// A type alias for a list of `MarkdownSpan` values
  and FountainSpans = list<FountainSpan>
  
  /// A paragraph represents a (possibly) multi-line element of a fountain document.
  
negative.code:     | HardLineBreak ->
          SpanLeaf(SL span) //SpanLeafInfo or (SpanNodeInfo * FountainSpans)
      | Strong spans 
      | Emphasis spans ->   
          SpanNode(SN span, spans)
      | Underline spans ->
          SpanNode(SN span, spans)
    
    //TODO: Question: what is happening here?
      // 1) isn't it backwards that the type is defined here? or is the active pattern itself
      // the definition of types?
      // 2) what is the syntax actually doing? why is it in parentheses?
    let SpanLeaf (SL(span)) = span
      // 3) so are SpanNodes only these formatted bits? what about non formatted bits?
    let SpanNode (SN(span), spans) =
      match span with
      | Strong _ -> Strong spans 
      | Emphasis _ -> Emphasis spans
      | Underline _ -> Underline spans
      | _ -> invalidArg "" "Incorrect SpanNodeInfo"
  
    // TODO: Question: marker types again?
    type ParagraphSpansInfo = private PS of FountainParagraph
    type ParagraphLeafInfo = private PL of FountainParagraph
    type ParagraphNestedInfo = private PN of FountainParagraph
  
    let (|ParagraphSpans|) par =
      match par with  
      | Section(_, spans)
  