anchor.diff:          if isPyStatement ctx false value then
               let varName, varExpr = Expression.name(var.Name), identAsExpr com ctx var
               ctx.BoundVars.Bind(var.Name)
  -            let decl = Statement.assign([varName], varExpr)
  +
  +            let decl = Statement.assign([varName], Expression.none ())
               let body = com.TransformAsStatements(ctx, Some(Assign varExpr), value)
               List.append [ decl ] body
           else
  
positive.code:             |> fun (ids, values, ids') ->
                  ctx.BoundVars.Bind(ids')
                  (Expression.tuple(ids), Expression.tuple(values))
          [ Statement.assign([ids], values) ]
  
      let varDeclaration (ctx: Context) (var: Expression) (isMutable: bool) value =
          match var with
          | Name({Id=id}) -> ctx.BoundVars.Bind([id])
          | _ -> ()
  
          [ Statement.assign([var], value) ]
  
      let restElement (var: Python.Identifier) =
  
negative.code: 
          | Fable.Operation(kind, _, range) ->
              transformOperation com ctx range kind
  
          | Fable.Get(expr, Fable.FieldGet(fieldName="push"), _, _) ->
              let attr = Python.Identifier("append")
              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(expr, Fable.FieldGet(fieldName="length"), _, _) ->
              let func = Expression.name("len")
              let left, stmts = com.TransformAsExpr(ctx, expr)
              Expression.call (func, [ left ]), stmts
  
          | Fable.Get(expr, kind, typ, range) ->
              transformGet com ctx range typ expr kind
  