anchor.diff:              let left, stmts = com.TransformAsExpr(ctx, expr)
               Expression.call (func, [ left ]), stmts
   
  +        | Fable.Call(Fable.Get(expr, Fable.FieldGet(fieldName="split"), _, _), { Args=[Fable.Value(kind=Fable.StringConstant(""))]}, _, range) ->
  +            let func = Expression.name("list")
  +            let value, stmts = com.TransformAsExpr(ctx, expr)
  +            Expression.call (func, [ value ]), stmts
  +
           | Fable.Call(Fable.Get(expr, Fable.FieldGet(fieldName="charCodeAt"), _, _), info, _, range) ->
               let func = Expression.name("ord")
               let value, stmts = com.TransformAsExpr(ctx, expr)
  
positive.code:                 stmts
                  @ stmts'
                  @ stmts''
                  @ [ Expression.ifExp(guardExpr', thenExpr', elseExpr', ?loc=r) |> resolveExpr thenExpr.Type returnStrategy ]
  
          | Fable.Sequential statements ->
              let lasti = (List.length statements) - 1
  
negative.code: 
          | Fable.TypeCast(e, t) ->
              let expr, stmts = transformCast com ctx t e
              stmts @ (expr |> resolveExpr ctx t returnStrategy)
  
          | Fable.Value(kind, r) ->
              let expr, stmts = transformValue com ctx r kind
              stmts @ (expr |> resolveExpr ctx kind.Type returnStrategy)
  
          | Fable.IdentExpr id ->
              identAsExpr com ctx id |> resolveExpr ctx id.Type returnStrategy
  
          | Fable.Import({ Selector = selector; Path = path }, t, r) ->
              transformImport com ctx r selector path |> resolveExpr ctx t returnStrategy
  
          | Fable.Test(expr, kind, range) ->
              let expr, stmts = transformTest com ctx range kind expr
              stmts @ (expr |> resolveExpr ctx Fable.Boolean returnStrategy)
  
          | Fable.Lambda(arg, body, name) ->
              let args, body = transformFunction com ctx name [arg] body
              let expr', stmts = makeArrowFunctionExpression args body
              stmts @ (expr' |> resolveExpr ctx expr.Type returnStrategy)
  
          | Fable.Delegate(args, body, name) ->
              let args, body = transformFunction com ctx name args body
              let expr', stmts = makeArrowFunctionExpression args body
              stmts @ (expr' |> resolveExpr ctx expr.Type returnStrategy)
  
          | Fable.ObjectExpr (members, t, baseCall) ->
              let expr, stmts = transformObjectExpr com ctx members baseCall
              stmts @ (expr |> resolveExpr ctx t returnStrategy)
  
          | Fable.Call(callee, info, typ, range) ->
              transformCallAsStatements com ctx range typ returnStrategy callee info
  