anchor.diff:  
       ctx.Dispose
   
  +let demoCommand line =
  +    match run parseCommand line with
  +        | Success(result, _, _)   -> printfn "Success: %A" result
  +        | Failure(errorMsg, _, _) -> printfn "Failure: %s" errorMsg
  +
   let main =
       Console.WriteLine("Hello, world!")
  -    match run parseCommand "<a := b> || <c := d>* + (<foo>; <bar>)" with
  -        | Success(result, _, _)   -> printfn "Success: %A" result
  -        | Failure(errorMsg, _, _) -> printfn "Failure: %s" errorMsg
  +    demoCommand "<a := b> || <c := d>* + (<foo>; <bar>)"
  +    demoCommand "{emp} <a := b> {fooBar()} || <c := d>* + (<foo>; <bar>)"
  +    demoCommand """
  +    {emp}
  +        <a := b>
  +    {holdTickIf(true, t)};
  +        (
  +            {holdTickIf(true, t)}
  +            <s = serving;>
  +            {holdTickIf(s != t) * holdLockIf(s = t) * termIf(s = t)}
  +        )*
  +    {holdLockIf(true)}
  +    """
       match run parseViewLine pv2 with
           | Success(result, _, _)   -> printfn "Success: %A" result
           | Failure(errorMsg, _, _) -> printfn "Failure: %s" errorMsg
  
positive.code: let inBraces p = inBrackets "{" "}" p
  
  let parseBin sep fn = pstring sep .>> ws >>% fun x y -> fn(x, y)
  
  let parseCommand, parseCommandRef = createParserForwardedToRef<Command, unit>()
  let parseAtomic = between (pstring "<") (pstring ">") (charsTillString ">" false 255) |>> Atomic
  let parseSkip = pstring "skip" >>% Skip
  let parseBracketedCommand = inParens parseCommand
  let maybeAddStar x =
      match x with
          | (v, Some _) -> Star v
          | (v, None)   -> v
  let parseSimpleCommand =
      choice [ parseAtomic
             ; parseSkip
             ; parseBracketedCommand
             ] .>>. ((pstring "*" |>> Some <|>% None) .>> ws) |>> maybeAddStar
  do parseCommandRef :=
      chainl1 parseSimpleCommand
          (choice [ parseBin ";" Seq
                  ; parseBin "||" Par
                  ; parseBin "+" Choice
                  ])
  
  let notSpecial c = c <> ',' && c <> '(' && c <> ')' && c <> ' ' && c <> '\t' && c <> '{' && c <> '}'
  
  let parseView, parseViewRef = createParserForwardedToRef<View, unit>()
  let parseArgList = inParens (sepBy (many1Satisfy notSpecial) (ws >>. pstring "," .>> ws))
  let parseNamedView = many1Satisfy notSpecial |>> NamedView
  let parseUnit = pstring "emp" >>% Unit
  let parseBracketedView = inParens parseView
  
negative.code: open FParsec
  open Microsoft.Z3
  
  type View =
      | Apply of View * args: string list
      | NamedView of string
      | Unit
      | Join of View * View
  and Command =
      | Atomic of string
      | Skip
      | Seq of Command * Command
      | Choice of Command * Command
      | Par of Command * Command
      | Star of Command
      | Viewed of ViewedCommand
  and ViewedCommand =
      | PreViewCommand of View * Command
      | PostViewCommand of Command * View
      | BothViewCommand of View * Command * View
  
  let wsChars = " \t\n"
  let wsc = anyOf wsChars
  let ws = manyChars wsc
  let ws1 = many1Chars wsc
  
  