anchor.diff:  let notSpecial c = String.forall (fun d -> d <> c) (specChars + wsChars)
   let notSpecialWs c = String.forall (fun d -> d <> c) specChars
   
  -let parseArgList = inParens (sepBy (many1Satisfy notSpecialWs) (ws >>. pstring "," .>> ws))
  -let parseNamedView = many1Satisfy notSpecial |>> NamedView
  +let parseIdent = many1Satisfy notSpecial
  +
  +let parseArgList = inParens (sepBy (many1Satisfy notSpecialWs) (pstring "," .>> ws))
  +let parseNamedView = parseIdent |>> NamedView
   let parseUnit = pstring "emp" >>% Unit
   let parseBracketedView = inParens parseView
   let maybeAddArgs x =
       match x with
           | (v, Some args) -> Apply(v,args)
           | (v, None)      -> v
  +let tryWrapInApply parser = parser .>>. opt parseArgList .>> ws |>> maybeAddArgs
   let parseSimpleView = 
       choice [ parseUnit
              ; parseBracketedView
              ; parseNamedView
  -           ] .>>. ((parseArgList |>> Some <|>% None) .>> ws) |>> maybeAddArgs
  +           ] 
   do parseViewRef :=
  -    chainl1 parseSimpleView (pstring "*" .>> ws >>% fun x y -> Join(x, y))
  +    chainl1 (tryWrapInApply parseSimpleView) (pstring "*" .>> ws >>% fun x y -> Join(x, y))
  +
  +let parseMethod =
  +    // Example method:               'main (argc, argv) { skip }'
  +    pipe3 (parseIdent .>> ws)     // 'main '
  +          (parseArgList .>> ws)   //      '(argc, argv) '
  +          (inBraces parseCommand) //                   '{ skip }'
  +          (fun n ps b -> { Name = n; Params = ps; Body = b })
   
   let cas =
       Choice(Atomic("foo"), Skip)
  
positive.code: 
      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!")
      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
  
negative.code:     | PostViewCommand of Command * View
      | BothViewCommand of View * Command * View
  
  type Method = {
      Name   : string
      Params : string list
      Body   : Command
  }
  
  let wsChars = " \t\r\n"
  let wsc : Parser<char, unit> = anyOf wsChars
  let ws = spaces // skips over " \t\r\n" by definition
  let ws1 = many1Chars wsc
  
  let inBrackets bra ket = between (pstring bra .>> ws) (ws >>. pstring ket)
  let inParens p = inBrackets "(" ")" p
  let inBraces p = inBrackets "{" "}" p
  let inAngles p = inBrackets "<" ">" p
  
  let parseBin sep fn = pstring sep .>> ws >>% fun x y -> fn(x, y)
  
  