anchor.diff:      | _ -> 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
  +  type ParagraphSpansInfo = private PS of FountainBlockElement
  +  type ParagraphLeafInfo = private PL of FountainBlockElement
  +  type ParagraphNestedInfo = private PN of FountainBlockElement
   
     let (|ParagraphSpans|) par =
       match par with  
       | Section(_, spans)
  -    | Paragraph(spans)
  +    | Block(spans)
  +    | Lyric(spans)
       | Span(spans) ->
           ParagraphSpans(PS par, spans)
   
     let ParagraphSpans (PS(par), spans) = 
       match par with 
       | Section(a, _) -> Section(a, spans)
  -    | Paragraph(_) -> Paragraph(spans)
  +    | Block(_) -> Block(spans)
       | Span(_) -> Span(spans)
  +    | Lyric(_) -> Lyric(spans)
  +    | SceneHeading(_) -> SceneHeading(spans)
       //| _ -> invalidArg "" "Incorrect ParagraphSpansInfo." //commented out because it says the rule will never be matched.
   
     let ParagraphLeaf (PL(par)) = par
  
positive.code: 
  
  
  /// Represents inline formatting inside a paragraph. This can be literal (with text), various
  /// formattings (string, emphasis, etc.), hyperlinks, etc.
  type FountainSpan =
    | Literal of string
    | Strong of FountainSpans
    | Italic of FountainSpans
    | Underline of FountainSpans
    | HardLineBreak
  
  /// A type alias for a list of `FountainSpan` values
  and FountainSpans = list<FountainSpan>
  
  /// A paragraph represents a (possibly) multi-line element of a fountain document.
  /// Paragraphs are headings, action blocks, dialogue blocks, etc. 
  type FountainParagraph = 
    | Section of int * FountainSpans
    | Paragraph of FountainSpans
    | Span of FountainSpans
  
  // Document as a tree
  /// This module provides an easy way of processing Markdown documents.
  
negative.code: 
    // represents a Leaf in the tree; that is a node that doesn't have any children
    type SpanLeafInfo = 
      private SL of FountainSpanElement
  
    // represents a node that has children
    type SpanNodeInfo = 
      private SN of FountainSpanElement 
  
    // Active Pattern that returns either a SpanLeaf or SpanNode from a span
    let (|SpanLeaf|SpanNode|) span = 
      match span with
      | Literal _
      | Note _ //TODO: not sure what this should be
      | HardLineBreak ->
          SpanLeaf(SL span) //SpanLeafInfo or (SpanNodeInfo * FountainSpans)
      | Strong spans 
      | Italic spans ->
          SpanNode(SN span, spans)
      | Underline spans ->
          SpanNode(SN span, spans)
  