anchor.diff:                          let body =
                               com.TransformAsStatements(ctx, returnStrategy, fd.Body)
   
  -                        let name = Helpers.cleanNameAsPythonIdentifier(fd.Id.Name)
  +                        let name =
  +                            Helpers.cleanNameAsPythonIdentifier (fd.Id.Name)
  +
                           yield FunctionDef(Identifier(name), arguments, body = body)
                       | :? Babel.ClassDeclaration as cd ->
                           printfn "TransformAsClassDef"
                           yield com.TransformAsClassDef(ctx, cd)
                       | _ -> failwith $"Unhandled Declaration: {decl.Declaration}"
   
  -                | :? Babel.ImportDeclaration as imp ->
  -                    yield com.TransformAsImport(ctx, imp)
  +                | :? Babel.ImportDeclaration as imp -> yield com.TransformAsImport(ctx, imp)
                   | :? Babel.PrivateModuleDeclaration as pmd ->
                       let st = pmd.Statement
                       yield! com.TransformAsStatements(ctx, returnStrategy, st)
  -                | _ ->
  -                    failwith $"Unknown module declaration: {md}" ]
  +                | _ -> failwith $"Unknown module declaration: {md}" ]
   
           Module(stmt)
   
  
positive.code:             //         | None -> upcast Babel.NullLiteral ()
              //member _.GetAllImports() = upcast imports.Values
              member bcom.TransformAsExpr(ctx, e) = transformAsExpr bcom ctx e
              member bcom.TransformAsStatements(ctx, ret, e) = transformExpressionAsStatements bcom ctx ret e
              member bcom.TransformAsStatements(ctx, ret, e) = transformStatementAsStatements bcom ctx ret e
              member bcom.TransformAsClassDef(ctx, cls) = transformAsClassDef bcom ctx cls
          //member bcom.TransformFunction(ctx, name, args, body) = transformFunction bcom ctx name args body
              member bcom.TransformAsImport(ctx, imp) = transformAsImport bcom ctx imp
  
          interface Compiler with
  
negative.code:             [ for st in bl.Body do
                  yield! com.TransformAsStatements(ctx, returnStrategy, st) ]
          | :? Babel.ReturnStatement as rtn ->
              let expr, stmts = transformAsExpr com ctx rtn.Argument
  
              match returnStrategy with
              | Some ReturnStrategy.ReturnUnit -> [ Expr(expr) ]
              | _ -> stmts @ [ Return(expr) ]
          | :? Babel.VariableDeclaration as vd ->
              [ for vd in vd.Declarations do
                  let targets: Expression list =
                      [ Name(id = Identifier(vd.Id.Name), ctx = Store()) ]
  
                  match vd.Init with
                  | Some value ->
                      let expr, stmts = com.TransformAsExpr(ctx, value)
                      yield! stmts
                      Assign(targets, expr)
                  | None -> () ]
  
          | :? Babel.ExpressionStatement as es ->
              // Handle Babel expressions that we need to transforme here as Python statements
              match es.Expression with
              | :? Babel.AssignmentExpression -> com.TransformAsStatements(ctx, returnStrategy, es.Expression)
              | _ ->
                  [ let expr, stmts = com.TransformAsExpr(ctx, es.Expression)
                    yield! stmts
                    Expr(expr) ]
          | :? Babel.IfStatement as iff ->
              let test, stmts = com.TransformAsExpr(ctx, iff.Test)
  
              let body =
                  com.TransformAsStatements(ctx, returnStrategy, iff.Consequent)
  
              let orElse =
                  match iff.Alternate with
                  | Some alt -> com.TransformAsStatements(ctx, returnStrategy, alt)
                  | _ -> []
  
              [ yield! stmts
                If(test = test, body = body, orelse = orElse) ]
          | :? Babel.WhileStatement as ws ->
              let expr, stmts = com.TransformAsExpr(ctx, ws.Test)
  
              let body =
                  com.TransformAsStatements(ctx, returnStrategy, ws.Body)
  
              [ yield! stmts
                While(test = expr, body = body, orelse = []) ]
          | _ -> failwith $"transformStatementAsStatements: Unhandled: {stmt}"
  
      /// Transform Babel program to Python module.
  