anchor.diff:              let pArgs : Parser<Expression list> = Primitives.sepBy pExpression (pKeywordComma .>> pWhitespace)
               pKeywordParensStart >>. pWhitespace >>. pArgs .>> pKeywordParensEnd .>> pWhitespace
           let pVariableOrCallExpression : Parser<Expression> =
  -            
  -            let pCall : Parser<PIndexOrCall> = pInvocation |>> (fun e -> Call e)
  -            let pIndex : Parser<PIndexOrCall> = pKeywordBracketStart >>. pWhitespace >>. pExpression .>> pKeywordBracketEnd .>> pWhitespace |>> (fun e -> Index e)
  -
  -            pMemberSegment .>>. (opt (pCall <|> pIndex))
  +            let pCall : Parser<Expression list> = pInvocation
  +
  +            pMemberSegment .>>. opt pCall
               |>> (fun (identifier, vc) ->
                   match vc with
  -                | Some callOrIndex -> 
  -                    match callOrIndex with
  -                    | Call args -> Expression.Call (Symbol(identifier), args)
  -                    | Index index -> Expression.Index (Symbol (identifier), index)                    
  +                | Some args -> Expression.Call (Symbol(identifier), args)
                   | _ ->  Expression.Symbol (identifier))
           let pScopedExpr : Parser<Expression> =
               between (pStrWhitespace "(") (pStrWhitespace ")") pExpression .>> pWhitespace
  
positive.code:     pVoid <|> pOther <?> "TypeName"
  
  type private PIndexOrCall = Call of Expression list | Index of Expression
  
  let pCodeBlock : Parser<Statement list> =
      let ((pExpression : Parser<Expression>), pExpressionImpl) = createParserForwardedToRef()
  
negative.code:             let pLeading = pKeywordPeriod >>. pMemberSegment
              many1 pLeading
          let term : Parser<Expression> =
              let pi = pKeywordBracketStart >>. pWhitespace >>. pExpression .>> pKeywordBracketEnd .>> pWhitespace
              let px = pMember .>>. opt pInvocation
              let py = pi .>>. opt px |>> Index
              let pxx = px |>> Member
  
              leaf .>>. opt (pxx <|> py)
              |>> fun (e,m) -> 
                  match m with
                  | Some im ->
                      match im with
                      | Index (ex, m) ->
                          let idx = Expression.Index (e, ex)
                          match m with
                          | Some (ml, el) ->
                              let mi = Expression.Member(idx, List.head ml)
                              let newList = List.skip 1 ml
                              let mr a b =
                                  Expression.Member (a, b)
                              let mm = List.fold mr mi newList 
                              match el with
                              | Some els ->
                                  Expression.Call(mm, els)
                              | _ -> mm
                          | _ ->
                              idx
  
                      | Member (ml, el) ->
                          let mi = Expression.Member(e, List.head ml)
                          let newList = List.skip 1 ml
                          let mr a b =
                              Expression.Member (a, b)
                          let mm = List.fold mr mi newList 
  
                          match el with
                              | Some els -> 
                                  Expression.Call(mm, els)
                              | _ ->
                                  mm
                  | _ ->
                      e
  
  