digitalmars.D - Bug or "hidden" feature?
- bauss (21/21) Nov 06 2017 If a function has an UDA you don't need to give the function a
- Temtaime (6/27) Nov 06 2017 Feature as return type is not necessary and considered auto when
- bauss (4/38) Nov 06 2017 Yeah I was aware of it for build-in attributes, but didn't know
- Jonathan M Davis (10/58) Nov 06 2017 The same goes for variables. The type is always infered if it's not
- Timon Gehr (5/18) Nov 06 2017 This is a common misconception. Auto means 'automatic storage' (a C
If a function has an UDA you don't need to give the function a return type. Is that a bug or a hidden feature? Example: ``` import std.stdio; struct A { } A test() { writeln("Called test()"); } A test2() { return true; } void main() { test(); writeln(test2()); } ```
Nov 06 2017
On Monday, 6 November 2017 at 09:44:24 UTC, bauss wrote:If a function has an UDA you don't need to give the function a return type. Is that a bug or a hidden feature? Example: ``` import std.stdio; struct A { } A test() { writeln("Called test()"); } A test2() { return true; } void main() { test(); writeln(test2()); } ```Feature as return type is not necessary and considered auto when some qualifiers are added const foo() {} property foo() {} etc
Nov 06 2017
On Monday, 6 November 2017 at 09:48:39 UTC, Temtaime wrote:On Monday, 6 November 2017 at 09:44:24 UTC, bauss wrote:Yeah I was aware of it for build-in attributes, but didn't know it applied to user-defined attributes. Always thought you had to be explicit about "auto" there, but I guess not.If a function has an UDA you don't need to give the function a return type. Is that a bug or a hidden feature? Example: ``` import std.stdio; struct A { } A test() { writeln("Called test()"); } A test2() { return true; } void main() { test(); writeln(test2()); } ```Feature as return type is not necessary and considered auto when some qualifiers are added const foo() {} property foo() {} etc
Nov 06 2017
On Monday, November 06, 2017 09:50:47 bauss via Digitalmars-d wrote:On Monday, 6 November 2017 at 09:48:39 UTC, Temtaime wrote:The same goes for variables. The type is always infered if it's not explicit. It's just that auto is required when there isn't something else there to indicate that it's a variable or function declaration. e.g. enum foo = "bar"; or static baz = 42; or immutable hello = "world"; - Jonathan M DavisOn Monday, 6 November 2017 at 09:44:24 UTC, bauss wrote:Yeah I was aware of it for build-in attributes, but didn't know it applied to user-defined attributes. Always thought you had to be explicit about "auto" there, but I guess not.If a function has an UDA you don't need to give the function a return type. Is that a bug or a hidden feature? Example: ``` import std.stdio; struct A { } A test() { writeln("Called test()"); } A test2() { return true; } void main() { test(); writeln(test2()); } ```Feature as return type is not necessary and considered auto when some qualifiers are added const foo() {} property foo() {} etc
Nov 06 2017
On 06.11.2017 10:50, bauss wrote:This is a common misconception. Auto means 'automatic storage' (a C leftover), not 'automatic type deduction'. 'auto' (or some other storage class/attribute) is only required to make it clear that what follows is a declaration. To enable type deduction, just don't specify the type.Yeah I was aware of it for build-in attributes, but didn't know it applied to user-defined attributes.Feature as return type is not necessary and considered auto when some qualifiers are added const foo() {} property foo() {} etc
Nov 06 2017