anchor.diff:      let transformValue (com: IPythonCompiler) (ctx: Context) r value: Expression * Statement list =
           match value with
           | Fable.BaseValue(None,_) -> Expression.identifier("super().__init__"), []
  -        | Fable.BaseValue(Some boundIdent,_) -> identAsExpr boundIdent, []
  +        | Fable.BaseValue(Some boundIdent,_) -> identAsExpr com ctx boundIdent, []
           | Fable.ThisValue _ -> Expression.identifier("self"), []
           | Fable.TypeInfo t -> transformTypeInfo com ctx r Map.empty t
           | Fable.Null _t -> Expression.identifier("None", ?loc=r), []
  
positive.code:     let transformUnion (com: IPythonCompiler) ctx (ent: Fable.Entity) (entName: string) classMembers =
          let fieldIds = getUnionFieldsAsIdents com ctx ent
          let args =
              [ fieldIds.[0] |> ident |> Arg.arg
                fieldIds.[1] |> ident |> Arg.arg ] //restElement ]
          let body =
              [
                  yield callSuperAsStatement []
  
negative.code:             let args, stmts = transformFunction com ctx name args body
              makeArrowFunctionExpression args stmts
          | _ ->
              com.TransformAsExpr(ctx, value)
  
      let transformBindingAsExpr (com: IPythonCompiler) ctx (var: Fable.Ident) (value: Fable.Expr) =
          printfn "transformBindingAsExpr: %A" (var, value)
          let expr, stmts = transformBindingExprBody com ctx var value
          expr |> assign None (identAsExpr com ctx var), stmts
  
      let transformBindingAsStatements (com: IPythonCompiler) ctx (var: Fable.Ident) (value: Fable.Expr) =
          if isPyStatement ctx false value then
              printfn "Py statement"
              let varName, varExpr = Expression.name(var.Name), identAsExpr com ctx var
              ctx.BoundVars.Bind(var.Name)
              let decl = Statement.assign([varName], varExpr)
              let body = com.TransformAsStatements(ctx, Some(Assign varExpr), value)
  