anchor.diff:              let value, stmts = com.TransformAsExpr(ctx, expr)
               Expression.attribute (value = value, attr = attr, ctx = Load), stmts
   
  +        | Fable.Get(expr, Fable.FieldGet(fieldName="toLocaleUpperCase"), _, _) ->
  +            let attr = Python.Identifier("upper")
  +            let value, stmts = com.TransformAsExpr(ctx, expr)
  +            Expression.attribute (value = value, attr = attr, ctx = Load), stmts
  +        | Fable.Get(expr, Fable.FieldGet(fieldName="toLocaleLowerCase"), _, _) ->
  +            let attr = Python.Identifier("lower")
  +            let value, stmts = com.TransformAsExpr(ctx, expr)
  +            Expression.attribute (value = value, attr = attr, ctx = Load), stmts
           | Fable.Get(expr, Fable.FieldGet(fieldName="indexOf"), _, _) ->
               let attr = Python.Identifier("find")
               let value, stmts = com.TransformAsExpr(ctx, expr)
               Expression.attribute (value = value, attr = attr, ctx = Load), stmts
   
  +        | Fable.Get(Fable.IdentExpr({Name = "String"}), Fable.FieldGet(fieldName="fromCharCode"), _, _) ->
  +            let func = Expression.name("chr")
  +            func, []
           | Fable.Get(expr, Fable.FieldGet(fieldName="length"), _, _) ->
               let func = Expression.name("len")
               let left, stmts = com.TransformAsExpr(ctx, expr)
               Expression.call (func, [ left ]), stmts
   
  +        | Fable.Get(Fable.IdentExpr({Name=name;Type=Fable.AnonymousRecordType(_)}) as expr, Fable.FieldGet(fieldName=index), _, _) ->
  +            let left, stmts = com.TransformAsExpr(ctx, expr)
  +            let index = Expression.constant(index)
  +            Expression.subscript (left, index), stmts
  +
           | Fable.Get(expr, kind, typ, range) ->
               transformGet com ctx range typ expr kind
   
  
positive.code:                     | Expression.Name({Id=id}) -> [ ctx.BoundVars.NonLocals([id]) |> Statement.nonLocal ]
                      | _ -> []
                  nonLocals @ stmts @ [ Statement.assign([target], value) ]
              | _ -> stmts @ [ expr' |> resolveExpr expr.Type returnStrategy ]
  
          | Fable.IfThenElse(guardExpr, thenExpr, elseExpr, r) ->
              let asStatement =
  
negative.code:             optimizeTailCall com ctx range tc args
          | _ ->
              let expr, stmts = transformCurriedApply com ctx range callee args
              stmts @ (expr |> resolveExpr ctx t returnStrategy)
  
      // When expecting a block, it's usually not necessary to wrap it
      // in a lambda to isolate its variable context
  