anchor.diff:  
       let get (propertyName:string) (target:obj) : 'TResult =
           target |> invocation (Member propertyName)
  -        
  -    let getChain (chainOfMembers:string seq) (target:obj) =
  +
  +    let getChain (chainOfMembers:string seq) (target:obj) : 'TResult =
           let chainOfMembers' = String.concat "." chainOfMembers 
           Dynamic.InvokeGetChain(target, chainOfMembers') |> invocation Direct
    
  
positive.code:     /// infered casting with automatic implicit convert.
      let invocation (memberName:Calling) (target:obj)  : 'TResult =
          let resultType = typeof<'TResult>
          let (|NoConversion| Conversion|) t = if t = typeof<obj> then NoConversion else Conversion
          let finalConvertResult finalType r :'TResult = 
              match finalType with
              | NoConversion -> r
  
negative.code:                                                     InvokeMemberName(name, null)
                                                  | Direct -> null
                      Invocation(k, memberName).Invoke(target, argArray)
                 let (|Action|Func|) t =
                      if t = typeof<unit> then Action else Func
                 let result =
                      try //Either it has a member or it's something directly callable
                          match (returnType, memberName) with
  