(&cli.App{}).Run(os.Args) - why first () are needed?

[abitrolly]

I came here to ask for urfave_cli_no_docs to be added into https://cli.urfave.org/v2/getting-started/ but then looking at this line

(&cli.App{}).Run(os.Args)

I couldn't resist asking the question. Why first parens () are needed? Is it the same as?

&cli.App{}.Run(os.Args)

[arturtamborski]

Run() can be called only on a pointer to App struct

cli/app.go

Line 308 in c023d9b

func (a *App) Run(arguments []string) (err error) {

notice it has the * (asterisk) character, meaning it takes a pointer. Pointer values are addresses, and you get these addresses by prefixing your values with the & character.

so to correctly

1. call the Run()'s definition, you need to
2. feed it a pointer (an address)
3. to a value of type App.

The line you're asking about is doing this exact thing:

(&cli.App{}).Run(os.Args)
  ^^^^^^^^^ - 3
 ^ - 2
             ^^^^^^^^^^^^ - 1

the parentheses are there to help with operation ordering.

Going from left to right, depth first:

• create a object of type App (3)
• immediately after it's creation get it's address with & (2)
• wrap that nicely with a (), so the real value we're operating on is the address
• call the Run, which will feed it the address, just as it wants it. (1)

---

Now, to explain your question bit more:

you can't have:

&cli.App{}.Run(os.Args)

because the order is not correct. What will really happen is this:

&(cli.App{}.Run(os.Args))

so we'd create an object of type App (that's good), but then we'd feed it directly into Run(), which is wrong, because it expected an address of the object, not the object itself.
And then (assuming it would work), we'd take the address of whatever the Run() function returned, and immediately trashed the value, because it wasn't assigned to any variable.

cli.App{}.Run(os.Args)

this also won't work because again, we're feeding into Run() the object itself, not it's address.

you could split this operation into two steps (and in fact that what happens later in the link you've posted), but you still need the address:

app := &cli.App{}
app.Run(os.Args)

notice we first create an object cli.App{}, then we get it's address with & and put that value into app, effectively making the variable app a pointer. And since it's a pointer, that's exactly what Run() wants, so we can safely do app.Run(), because app's value is already an address. No need for any other operations.

Last example:

app := cli.App{}    // no & !!!
(&app).Run(os.Args) // wrapping needed!

Try explaining why the () and & is needed here.
And to work this out a bit more, consider the following:

&app.Run(os.Args)      // 1 
&(app.Run(os.Args))    // 2
(&app).Run(os.Args)    // 3
(*app).Run(os.Args)    // 4
(&(*app)).Run(os.Args) // 5

another important part of this whole thing is the syntax sugar around OOP calls, but in short:

(&cli.App{}).Run(os.Args) // 1
Run(&cli.App{}, os.Args)  // 2

are technically equivalent. 2 won't work in Go, but it will in similar languages like Python, JS or C++. The details here are less important than the pointer magic explained above, but it's worth having in head that the following are pretty much always the same in most general purpose programming languages:

object.method(args)
method(object, args)

[abitrolly]

That's a very thorough answer! Thanks a lot. I will use it as a reference.