should automatically include most of the standard library so one doesn't have to constantly import them just to do basic playing around with the examples.

For example, I modified an example

import std.array : assocArray;
import std.range : enumerate;
import std.conv, std.algorithm, std.math;

auto aa = iota(1,20).map!(i => round(log(i))).take(10).array;
writeln(to!string(aa));

and had to import the 3rd line. This gets pretty annoying when playing around with the examples. The most common libs should automatically be imported and may be dependent on the library(e.g, if its std.traits maybe import std.meta and others related).

Also, this example works but in visual stupid the same code gives me an error:

Error: function X.Music.map!(Result).map need this to access member map
X.d(22): called from here: map(iota(1, 100))
X.d(22): called from here: take(map(iota(1, 100)), 30u)

The difference is that I'm trying to generate this sequence at compile time(it's initializing a struct member). It should be computable without issue and I'm just replacing hard coded array. Seems iota isn't being computed at compile time.

struct x
{
static:
auto a = iota(1,1000).map!(i => round(log(i))).take(30).array;
}

On Sunday, 29 January 2023 at 00:03:31 UTC, Karmello wrote:

You can just import std; if you want to play around and don't care much about the first compilation time. The following code also works:

import std;
void main(){
    auto aa = iota(1,20).map!(i => round(log(i))).take(10).array;
    writeln(to!string(aa));
}

On Sunday, 29 January 2023 at 03:49:04 UTC, Tejas wrote:

import std;
void main(){
    auto aa = iota(1,20).map!(i => round(log(i))).take(10).array;
    writeln(to!string(aa));
}

Yes, that code works, that code is not what I'm doing. They can add import std; to every line of all the examples.

The solution here to put the array code in to a function that returns it. It's excessive. Why map needs to be hidden inside a function to get it to compile is beyond me.

On 1/28/23 7:03 PM, Karmello wrote:

This is a bug in the compiler. Change your function to not be a templated lambda, and it works:

struct x
{
    static:
      auto a = iota(1,1000).map!((int i) => round(log(i))).take(30).array;
}

It can be reduced to:

struct x
{
   static:
       auto a = [1,2,3].map!(i => i);       // fails
       auto b = [1,2,3].map!((int i) => i); // works
}

From testing on run.dlang.io, this hasn't worked all the way back to 2.060.

There is already a bug report on this: https://issues.dlang.org/show_bug.cgi?id=20077

-Steve