anchor.diff:          match body with
               | [ Statement.Return({Value=Some expr}) ] -> Expression.lambda(args, expr), []
               | _ ->
  -                let name = Helpers.getUniqueIdentifier "arrow"
  -                let func = FunctionDef.Create(name = name, args = args, body = body)
  -                Expression.name (name), [ func ]
  +                let ident = name |> Option.map Identifier |> Option.defaultWith (fun _ -> Helpers.getUniqueIdentifier "arrow")
  +                let func = FunctionDef.Create(name = ident, args = args, body = body)
  +                Expression.name ident, [ func ]
   
       let makeFunction name (args: Arguments, (body: Expression)) : Statement =
           // printfn "Name: %A" name
  
positive.code:     let wrapExprInBlockWithReturn (e, stmts) =
          stmts @ [ Statement.return'(e) ]
  
      let makeArrowFunctionExpression (args: Arguments) (body: Statement list) : Expression * Statement list =
          let args =
              match args.Args with
              | [] -> Arguments.arguments(args=[ Arg.arg(Identifier("_unit")) ], defaults=[ Expression.none() ])
  
negative.code: 
          | Fable.Lambda(arg, body, name) ->
              let args, body = transformFunction com ctx name [arg] body
              let expr', stmts = makeArrowFunctionExpression name 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 name args body
              stmts @ (expr' |> resolveExpr ctx expr.Type returnStrategy)
  
          | Fable.ObjectExpr (members, t, baseCall) ->
  