anchor.diff:  /// Takes a string on the stack, scan for words, and place the individual 
   /// words on the stack
   let scan () = 
  -    split ' '
  +    push ' '; split()
       unaryOp2 (fun (arr : string[]) -> 
           for word in arr do push <| word.ToLower())
   
   let removeStopWords () =
  -    push stopWords
  -    readFile()
  -    split ','
  +    push stopWords; readFile()
  +    push ','; split()
   
       unaryOp2 (fun (arr : string[]) -> 
           arr |> Set.ofArray |> store "stop_words")                
  
positive.code:     while len() > 0 do
          load<Set<string>> "stop_words"
          binOp (fun (stopWords : Set<string>) word -> 
              if stopWords.Contains word |> not && word.Length >= 2
              then Some word
              else None)
  
          load<string list> "words"
          binOp2 (fun (words : string list) word ->
              match word with
              | Some word -> store "words" <| word::words
              | _ -> ())
  
      load<string list> "words"
      unaryOp2 (fun (words : string list) -> words |> List.iter push)
  
  let frequencies () =
      store "word_freqs" <| new Dictionary<string, int>()
  
      while len() > 0 do
          load "word_freqs"
          binOp (fun (wordFreqs : Dictionary<string, int>) word ->
              if wordFreqs.ContainsKey word
              then word, wordFreqs.[word] + 1
              else word, 1)
  
          load "word_freqs"
          binOp (fun (wordFreqs : Dictionary<string, int>) (word, newCount) -> 
              wordFreqs.[word] <- newCount
              wordFreqs)
  
          unaryOp2 (store "word_freqs")
  
  let sort () =
      load "word_freqs"
      unaryOp2 (fun (wordFreqs : Dictionary<string, int>) ->
          let len = min wordFreqs.Count 25
          wordFreqs 
          |> Seq.sortByDescending (fun kvp -> kvp.Value)
          |> Seq.take len
          |> Seq.rev
          |> Seq.iter (fun kvp -> push (kvp.Key, kvp.Value)))
  
  push ``pride and prejudice``
  readFile(); replaceNonAlphanumeric(); scan(); removeStopWords(); frequencies(); sort()
  
  while len() > 0 do
      unaryOp2 (fun (word : string, count : int) -> printfn "%s - %d" word count)
negative.code:     let mutable private heap = Map.empty<string, obj>
  
      /// Pops the HEAD of the stack
      let private pop<'a> () =
          let hd::tl = stack
          stack <- tl
          hd :?> 'a
  