Here I described my thoughts about this topic
https://github.com/finom/function-decorators-proposal. The main idea of
moving forward with function decorators is to make them behave like there
were defined and wrapped by another function, not more, and get rid of any
hoisting when they're used.

Function expression and arrow functions

const foo = @decorator1 @decorator2 function bar() { return "Hello" }
// Will become:
const foo = decorate([decorator1, decorator2], function bar() { return
"Hello" });

And

const foo = @decorator1 @decorator2 () => "Hello"
// Will become:
const foo = decorate([decorator1, decorator2], () => "Hello");

<https://github.com/finom/function-decorators-proposal#function-declarations>Function
declarations

And this is the most important. I propose to make a decorated function
declaration behave as let definition.

@decorator1 @decorator2 function foo() { return "Hello" }
// Will become:
let foo = decorate([decorator1, decorator2], function foo() { return
"Hello" }); // no hoisting!
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20190904/741ba65c/attachment.html>

Here I described my thoughts about this topic
https://github.com/finom/function-decorators-proposal. The main idea of
moving forward with function decorators is to make them behave like there
were defined and wrapped by another function, not more, and get rid of any
hoisting when they're used.

# Function expressions and arrow functions

```js
const foo = @decorator1 @decorator2 function bar() { return "Hello" }

// Will become:

const foo = decorate([decorator1, decorator2], function bar() { return "Hello" });
```

And
```js
const foo = @decorator1 @decorator2 () => "Hello"

// Will become:

const foo = decorate([decorator1, decorator2], () => "Hello");
```

# Function declarations

And this is the most important. I propose to make a decorated function
declaration behave as let definition.

```js
@decorator1 @decorator2 function foo() { return "Hello" }

// Will become:

let foo = decorate([decorator1, decorator2], function foo() { return "Hello" }); // no hoisting!
```

Here I described my thoughts about this topic
https://github.com/finom/function-decorators-proposal. The main idea of
moving forward with function decorators is to make them behave like there
were defined and wrapped by another function, not more, and get rid of any
hoisting when they're used.

# Function expressions and arrow functions

```js
const foo = @decorator1 @decorator2 function bar() { return "Hello" }

// Will become:

const foo = decorate([decorator1, decorator2], function bar() { return
"Hello" });
```

And
```js
const foo = @decorator1 @decorator2 () => "Hello"

// Will become:

const foo = decorate([decorator1, decorator2], () => "Hello");
```

# Function declarations

And this is the most important. I propose to make a decorated function
declaration behave as let definition.

```js
@decorator1 @decorator2 function foo() { return "Hello" }

// Will become:

let foo = decorate([decorator1, decorator2], function foo() { return
"Hello" }); // no hoisting!
```

Here I described my thoughts about this topic
https://github.com/finom/function-decorators-proposal. The main idea of
moving forward with function decorators is to make them behave like there
were defined and wrapped by another function, not more, and get rid of any
hoisting when they're used.

# Function expressions and arrow functions

```js
const foo = @decorator1 @decorator2 function bar() { return "Hello" }
// Will become:
const foo = decorate([decorator1, decorator2], function bar() { return
"Hello" });
```

And
```js
const foo = @decorator1 @decorator2 () => "Hello"

// Will become:
const foo = decorate([decorator1, decorator2], () => "Hello");
```

# Function declarations

And this is the most important. I propose to make a decorated function
declaration behave as let definition.

```js
@decorator1 @decorator2 function foo() { return "Hello" }
// Will become:
let foo = decorate([decorator1, decorator2], function foo() { return
"Hello" }); // no hoisting!
```

Here I described my thoughts about this topic
https://github.com/finom/function-decorators-proposal. The main idea of
moving forward with function decorators is to make them behave like there
were defined and wrapped by another function, not more, and get rid of any
hoisting when they're used.

# Function expression and arrow functions

```js
const foo = @decorator1 @decorator2 function bar() { return "Hello" }
// Will become:
const foo = decorate([decorator1, decorator2], function bar() { return
"Hello" });
```

And
```js
const foo = @decorator1 @decorator2 () => "Hello"

// Will become:
const foo = decorate([decorator1, decorator2], () => "Hello");
```

# Function declarations

And this is the most important. I propose to make a decorated function
declaration behave as let definition.

```js
@decorator1 @decorator2 function foo() { return "Hello" }
// Will become:
let foo = decorate([decorator1, decorator2], function foo() { return
"Hello" }); // no hoisting!
```

Here I described my thoughts about this topic
https://github.com/finom/function-decorators-proposal. The main idea of
moving forward with function decorators is to make them behave like there
were defined and wrapped by another function, not more, and get rid of any
hoisting when they're used.

Function expression and arrow functions
```js
const foo = @decorator1 @decorator2 function bar() { return "Hello" }
// Will become:
const foo = decorate([decorator1, decorator2], function bar() { return
"Hello" });
```

And

const foo = @decorator1 @decorator2 () => "Hello"

// Will become:
const foo = decorate([decorator1, decorator2], () => "Hello");

<https://github.com/finom/function-decorators-proposal#function-declarations>Function

declarations

And this is the most important. I propose to make a decorated function
declaration behave as let definition.

@decorator1 @decorator2 function foo() { return "Hello" }
// Will become:
let foo = decorate([decorator1, decorator2], function foo() { return
"Hello" }); // no hoisting!