December 11, 2017
On Monday, 11 December 2017 at 19:46:04 UTC, Vino wrote:

> import std.algorithm;
> import std.container.array;
> import std.file: SpanMode, dirEntries, isDir ;
> import std.stdio: writefln, writeln;
> import std.typecons: Tuple, tuple;
> import std.range: chain;
>
> void main () {
> auto FFs =  ["C:\\Temp\\BACKUP", "C:\\Temp\\EXPORT", "C:\\Temp\\PROD_TEAM"];
> foreach(d; FFs[]) {
> auto dFiles = Array!(Tuple!(string, SysTime))(dirEntries(d, SpanMode.shallow).filter!(a => a.isDir).map!(a => tuple(a.name, a.timeCreated)));
> writefln("%(%-(%-63s %s %)\n%)", chain(dFiles[]).sort!((a, b) => a[1] < b[1]));
> }
> }

So let's go through this code then, shall we?

Edited a bit for clarity:

    // For each directory (*one at a time*),
    foreach(d; FFs[]) {
        // List all the folders
        auto dFiles = Array!(Tuple!(string, SysTime))(
            dirEntries(d, SpanMode.shallow)
                // Not the files,
                .filter!(a => a.isDir)
                // Grab only the information we want,
                .map!(a => tuple(a.name, a.timeCreated)));
        // And print a sorted list of the subfolders of the current folder.
        writefln("%(%-(%-63s %s %)\n%)", chain(dFiles[]).sort!((a, b) => a[1] < b[1]));
    }

This will go through C:\Temp\BACKUP, and display a sorted list of all the subfolders in that folder. Then it will do the same for C:\Temp\EXPORT, and then for C:\Temp\PROD_TEAM.

No subfolder of C:\Temp\PROD_TEAM will be displayed before anything in C:\Temp\BACKUP, because you're sorting only one set of subfolders at a time.

What you're essentially doing, is sorting [6,2,4] and [3,5,1] separately, and printing them separately, giving the illusion of having sorted them into the array [2,4,6,1,3,5]. As you correctly point out, this is not what you wanted. The code I presented avoids this by joining the lists for all the folders.

Your code could also be simplified a bit - there's no need for the call to chain, and calling dirEntries.filter.map.array is easier to read and write than having Array!(Tuple!(string, SysTime)) at the front.

In case my code from earlier was hard to understand, here's another version~, more closely modeled to your code:

import std.algorithm : map, filter, sort;
import std.array : array;
import std.file : SpanMode, dirEntries, isDir;
import std.stdio : writefln;
import std.typecons : Tuple, tuple;
import std.datetime : SysTime;

void main() {
    // The folders we want to look in.
    auto folders = [`C:\Windows`, `C:\Program Files`, `C:\Users`];

    // We'll put all the subfolders we find here, so we can sort them in the end.
    Tuple!(string, SysTime)[] subFolders;

    // Look through each folder in turn.
    foreach (folder; folders) {
        // Get all entries in the folder,
        auto entries = dirEntries(folder, SpanMode.shallow);
        // Get rid of files,
        auto folderEntries = entries.filter!(a => a.isDir);
        // Grab the interesting parts,
        auto interestingParts = folderEntries.map!(a => tuple(a.name, a.timeCreated));
        // And add it to the array.
        subFolders ~= interestingParts.array;
    }
    // Sort the entire array.
    auto sorted = subFolders.sort!((a, b) => a[1] < b[1]);
    // And print it!
    writefln("%(%-(%-63s %s %)\n%)", sorted);
}
December 12, 2017
On Monday, 11 December 2017 at 20:58:31 UTC, Biotronic wrote:
> On Monday, 11 December 2017 at 19:46:04 UTC, Vino wrote:
>
>> import std.algorithm;
>> import std.container.array;
>> import std.file: SpanMode, dirEntries, isDir ;
>> import std.stdio: writefln, writeln;
>> import std.typecons: Tuple, tuple;
>> import std.range: chain;
>>
>> void main () {
>> auto FFs =  ["C:\\Temp\\BACKUP", "C:\\Temp\\EXPORT", "C:\\Temp\\PROD_TEAM"];
>> foreach(d; FFs[]) {
>> auto dFiles = Array!(Tuple!(string, SysTime))(dirEntries(d, SpanMode.shallow).filter!(a => a.isDir).map!(a => tuple(a.name, a.timeCreated)));
>> writefln("%(%-(%-63s %s %)\n%)", chain(dFiles[]).sort!((a, b) => a[1] < b[1]));
>> }
>> }
>
> So let's go through this code then, shall we?
>
> Edited a bit for clarity:
>
>     // For each directory (*one at a time*),
>     foreach(d; FFs[]) {
>         // List all the folders
>         auto dFiles = Array!(Tuple!(string, SysTime))(
>             dirEntries(d, SpanMode.shallow)
>                 // Not the files,
>                 .filter!(a => a.isDir)
>                 // Grab only the information we want,
>                 .map!(a => tuple(a.name, a.timeCreated)));
>         // And print a sorted list of the subfolders of the current folder.
>         writefln("%(%-(%-63s %s %)\n%)", chain(dFiles[]).sort!((a, b) => a[1] < b[1]));
>     }
>
> This will go through C:\Temp\BACKUP, and display a sorted list of all the subfolders in that folder. Then it will do the same for C:\Temp\EXPORT, and then for C:\Temp\PROD_TEAM.
>
> No subfolder of C:\Temp\PROD_TEAM will be displayed before anything in C:\Temp\BACKUP, because you're sorting only one set of subfolders at a time.
>
> What you're essentially doing, is sorting [6,2,4] and [3,5,1] separately, and printing them separately, giving the illusion of having sorted them into the array [2,4,6,1,3,5]. As you correctly point out, this is not what you wanted. The code I presented avoids this by joining the lists for all the folders.
>
> Your code could also be simplified a bit - there's no need for the call to chain, and calling dirEntries.filter.map.array is easier to read and write than having Array!(Tuple!(string, SysTime)) at the front.
>
> In case my code from earlier was hard to understand, here's another version~, more closely modeled to your code:
>
> import std.algorithm : map, filter, sort;
> import std.array : array;
> import std.file : SpanMode, dirEntries, isDir;
> import std.stdio : writefln;
> import std.typecons : Tuple, tuple;
> import std.datetime : SysTime;
>
> void main() {
>     // The folders we want to look in.
>     auto folders = [`C:\Windows`, `C:\Program Files`, `C:\Users`];
>
>     // We'll put all the subfolders we find here, so we can sort them in the end.
>     Tuple!(string, SysTime)[] subFolders;
>
>     // Look through each folder in turn.
>     foreach (folder; folders) {
>         // Get all entries in the folder,
>         auto entries = dirEntries(folder, SpanMode.shallow);
>         // Get rid of files,
>         auto folderEntries = entries.filter!(a => a.isDir);
>         // Grab the interesting parts,
>         auto interestingParts = folderEntries.map!(a => tuple(a.name, a.timeCreated));
>         // And add it to the array.
>         subFolders ~= interestingParts.array;
>     }
>     // Sort the entire array.
>     auto sorted = subFolders.sort!((a, b) => a[1] < b[1]);
>     // And print it!
>     writefln("%(%-(%-63s %s %)\n%)", sorted);
> }

Hi,

 Thank you very much , was able to resolve the issue using your logic with a bit of addition and not i am getting the sorted output as expected, except that the date and time are displayed as "2017-Sep-05 14:31:00.7037169" so may i know how do we get the output as
"2017-Sep-05 14:31:00".

Program:
import std.algorithm: filter, map, sort;
import std.container.array;
import std.file: SpanMode, dirEntries, isDir ;
import std.stdio: writefln;
import std.typecons: Tuple, tuple;
import std.datetime.systime: SysTime;

void main () {
auto FFs =  ["C:\\Temp\\sapnas2\\BACKUP", "C:\\Temp\\sapnas2\\EXPORT", "C:\\Temp\\sapnas2\\PROD_TEAM"];
Array!(Tuple!(string, SysTime)) Result;
foreach(d; FFs[]) {
	auto dFiles = Array!(Tuple!(string, SysTime))(dirEntries(d, SpanMode.shallow).filter!(a => a.isDir).map!(a => tuple(a.name, a.timeCreated)));
	foreach(e; dFiles) { Result ~= e; } }
    writefln("%(%-(%-63s %.20s %)\n%)", Result[].sort!((a, b) => a[1] < b[1]));
}

From,
Vino.B
December 12, 2017
On Tuesday, 12 December 2017 at 15:19:35 UTC, Vino wrote:
> import std.algorithm: filter, map, sort;
> import std.container.array;
> import std.file: SpanMode, dirEntries, isDir ;
> import std.stdio: writefln;
> import std.typecons: Tuple, tuple;
> import std.datetime.systime: SysTime;
>
> void main () {
> auto FFs =  ["C:\\Temp\\sapnas2\\BACKUP", "C:\\Temp\\sapnas2\\EXPORT", "C:\\Temp\\sapnas2\\PROD_TEAM"];
> Array!(Tuple!(string, SysTime)) Result;
> foreach(d; FFs[]) {
> 	auto dFiles = Array!(Tuple!(string, SysTime))(dirEntries(d, SpanMode.shallow).filter!(a => a.isDir).map!(a => tuple(a.name, a.timeCreated)));
> 	foreach(e; dFiles) { Result ~= e; } }
>     writefln("%(%-(%-63s %.20s %)\n%)", Result[].sort!((a, b) => a[1] < b[1]));
> }

Since there's little need to extract timeCreated and name before sorting, here's a version that doesn't:

import std.algorithm : map, filter, sort;
import std.array : array;
import std.range : join;
import std.file : SpanMode, dirEntries, isDir;
import std.stdio : writefln;
import std.typecons : tuple;

void main() {
    auto folders = [`C:\Windows`, `C:\Program Files`, `C:\Users`];

    auto sorted = folders
        .map!(f => f.dirEntries(SpanMode.shallow))
        .join
        .filter!(e => e.isDir)
        .array
        .sort!((a,b) => a.timeCreated < b.timeCreated)
        .map!(e => tuple(e.name, e.timeCreated.toSimpleString[0 .. 20]));

    writefln("%(%-(%-63s %s %)\n%)", sorted);
}

And a version with normal loops, since the heavily range-based version above can be a bit dense. These programs do essentially the same thing:

import std.algorithm : sort;
import std.array : array;
import std.file : SpanMode, dirEntries, DirEntry, isDir;
import std.stdio : writefln;
import std.typecons : tuple, Tuple;

void main() {
    auto folders = [`C:\Windows`, `C:\Program Files`, `C:\Users`];

    DirEntry[] subFolders;

    foreach (folder; folders) {
        auto children = dirEntries(folder, SpanMode.shallow);
        foreach (child; children) {
            if (child.isDir) subFolders ~= child;
        }
    }

    subFolders.sort!((a,b) => a.timeCreated < b.timeCreated);
    Tuple!(string, string)[] interestingParts;

    foreach (subFolder; subFolders) {
        interestingParts ~= tuple(subFolder.name, subFolder.timeCreated.toSimpleString[0..20]);
    }

    writefln("%(%-(%-63s %s %)\n%)", interestingParts);
}

As you can see, I'm just chopping off the parts I don't like from toSimpleString. It seems a good format function for dates does not exist in Phobos.

--
  Biotronic
December 13, 2017
On Tuesday, 12 December 2017 at 19:00:01 UTC, Biotronic wrote:
> On Tuesday, 12 December 2017 at 15:19:35 UTC, Vino wrote:
>> import std.algorithm: filter, map, sort;
>> import std.container.array;
>> import std.file: SpanMode, dirEntries, isDir ;
>> import std.stdio: writefln;
>> import std.typecons: Tuple, tuple;
>> import std.datetime.systime: SysTime;
>>
>> void main () {
>> auto FFs =  ["C:\\Temp\\sapnas2\\BACKUP", "C:\\Temp\\sapnas2\\EXPORT", "C:\\Temp\\sapnas2\\PROD_TEAM"];
>> Array!(Tuple!(string, SysTime)) Result;
>> foreach(d; FFs[]) {
>> 	auto dFiles = Array!(Tuple!(string, SysTime))(dirEntries(d, SpanMode.shallow).filter!(a => a.isDir).map!(a => tuple(a.name, a.timeCreated)));
>> 	foreach(e; dFiles) { Result ~= e; } }
>>     writefln("%(%-(%-63s %.20s %)\n%)", Result[].sort!((a, b) => a[1] < b[1]));
>> }
>
> Since there's little need to extract timeCreated and name before sorting, here's a version that doesn't:
>
> import std.algorithm : map, filter, sort;
> import std.array : array;
> import std.range : join;
> import std.file : SpanMode, dirEntries, isDir;
> import std.stdio : writefln;
> import std.typecons : tuple;
>
> void main() {
>     auto folders = [`C:\Windows`, `C:\Program Files`, `C:\Users`];
>
>     auto sorted = folders
>         .map!(f => f.dirEntries(SpanMode.shallow))
>         .join
>         .filter!(e => e.isDir)
>         .array
>         .sort!((a,b) => a.timeCreated < b.timeCreated)
>         .map!(e => tuple(e.name, e.timeCreated.toSimpleString[0 .. 20]));
>
>     writefln("%(%-(%-63s %s %)\n%)", sorted);
> }
>
> And a version with normal loops, since the heavily range-based version above can be a bit dense. These programs do essentially the same thing:
>
> import std.algorithm : sort;
> import std.array : array;
> import std.file : SpanMode, dirEntries, DirEntry, isDir;
> import std.stdio : writefln;
> import std.typecons : tuple, Tuple;
>
> void main() {
>     auto folders = [`C:\Windows`, `C:\Program Files`, `C:\Users`];
>
>     DirEntry[] subFolders;
>
>     foreach (folder; folders) {
>         auto children = dirEntries(folder, SpanMode.shallow);
>         foreach (child; children) {
>             if (child.isDir) subFolders ~= child;
>         }
>     }
>
>     subFolders.sort!((a,b) => a.timeCreated < b.timeCreated);
>     Tuple!(string, string)[] interestingParts;
>
>     foreach (subFolder; subFolders) {
>         interestingParts ~= tuple(subFolder.name, subFolder.timeCreated.toSimpleString[0..20]);
>     }
>
>     writefln("%(%-(%-63s %s %)\n%)", interestingParts);
> }
>
> As you can see, I'm just chopping off the parts I don't like from toSimpleString. It seems a good format function for dates does not exist in Phobos.
>
> --
>   Biotronic

Hi Biotronic,

 I was able to find a solution using container array and also date formatting, below is the code, please do let me know if you find any issue, as i have tested the script and it is working as expected.

Program:
import std.algorithm: filter, map, sort, each;
import std.container.array;
import std.file: SpanMode, dirEntries, isDir ;
import std.stdio: writeln,writefln;
import std.typecons: Tuple, tuple;
import std.datetime.systime: SysTime;
import std.conv;
void main () {
auto FFs =  ["C:\\Temp\\sapnas2\\BACKUP", "C:\\Temp\\sapnas2\\EXPORT"];
Array!(Tuple!(string, SysTime)) Sorted;
foreach(d; FFs[]) {
auto dFiles = Array!(Tuple!(string, SysTime))(dirEntries(d, SpanMode.shallow).filter!(a => a.isDir).map!(a => tuple(a.name, a.timeCreated)));
foreach(i; dFiles[]){ Sorted ~= i; }
Sorted[].sort!((a,b) => a[1] > b[1]).each!(e => writefln!"%-63s %.20s"(e[0], e[1].to!string));
}
}

From,
Vino.B
December 15, 2017
On Tuesday, 12 December 2017 at 19:00:01 UTC, Biotronic wrote:
> On Tuesday, 12 December 2017 at 15:19:35 UTC, Vino wrote:
>> import std.algorithm: filter, map, sort;
>> import std.container.array;
>> import std.file: SpanMode, dirEntries, isDir ;
>> import std.stdio: writefln;
>> import std.typecons: Tuple, tuple;
>> import std.datetime.systime: SysTime;
>>
>> void main () {
>> auto FFs =  ["C:\\Temp\\sapnas2\\BACKUP", "C:\\Temp\\sapnas2\\EXPORT", "C:\\Temp\\sapnas2\\PROD_TEAM"];
>> Array!(Tuple!(string, SysTime)) Result;
>> foreach(d; FFs[]) {
>> 	auto dFiles = Array!(Tuple!(string, SysTime))(dirEntries(d, SpanMode.shallow).filter!(a => a.isDir).map!(a => tuple(a.name, a.timeCreated)));
>> 	foreach(e; dFiles) { Result ~= e; } }
>>     writefln("%(%-(%-63s %.20s %)\n%)", Result[].sort!((a, b) => a[1] < b[1]));
>> }
>
> Since there's little need to extract timeCreated and name before sorting, here's a version that doesn't:
>
> import std.algorithm : map, filter, sort;
> import std.array : array;
> import std.range : join;
> import std.file : SpanMode, dirEntries, isDir;
> import std.stdio : writefln;
> import std.typecons : tuple;
>
> void main() {
>     auto folders = [`C:\Windows`, `C:\Program Files`, `C:\Users`];
>
>     auto sorted = folders
>         .map!(f => f.dirEntries(SpanMode.shallow))
>         .join
>         .filter!(e => e.isDir)
>         .array
>         .sort!((a,b) => a.timeCreated < b.timeCreated)
>         .map!(e => tuple(e.name, e.timeCreated.toSimpleString[0 .. 20]));
>
>     writefln("%(%-(%-63s %s %)\n%)", sorted);
> }
>
> And a version with normal loops, since the heavily range-based version above can be a bit dense. These programs do essentially the same thing:
>
> import std.algorithm : sort;
> import std.array : array;
> import std.file : SpanMode, dirEntries, DirEntry, isDir;
> import std.stdio : writefln;
> import std.typecons : tuple, Tuple;
>
> void main() {
>     auto folders = [`C:\Windows`, `C:\Program Files`, `C:\Users`];
>
>     DirEntry[] subFolders;
>
>     foreach (folder; folders) {
>         auto children = dirEntries(folder, SpanMode.shallow);
>         foreach (child; children) {
>             if (child.isDir) subFolders ~= child;
>         }
>     }
>
>     subFolders.sort!((a,b) => a.timeCreated < b.timeCreated);
>     Tuple!(string, string)[] interestingParts;
>
>     foreach (subFolder; subFolders) {
>         interestingParts ~= tuple(subFolder.name, subFolder.timeCreated.toSimpleString[0..20]);
>     }
>
>     writefln("%(%-(%-63s %s %)\n%)", interestingParts);
> }
>
> As you can see, I'm just chopping off the parts I don't like from toSimpleString. It seems a good format function for dates does not exist in Phobos.
>
> --
>   Biotronic

Hi Biotronic,

 I was able to find a solution using container array and also date formatting, below is the code, please do let me know if you find any issue, as i have tested the script and it is working as expected.

Program:
import std.algorithm: filter, map, sort, each;
import std.container.array;
import std.file: SpanMode, dirEntries, isDir ;
import std.stdio: writeln,writefln;
import std.typecons: Tuple, tuple;
import std.datetime.systime: SysTime;
import std.conv;
void main () {
auto FFs =  ["C:\\Temp\\sapnas2\\BACKUP", "C:\\Temp\\sapnas2\\EXPORT"];
Array!(Tuple!(string, SysTime)) Sorted;
foreach(d; FFs[]) {
auto dFiles = Array!(Tuple!(string, SysTime))(dirEntries(d, SpanMode.shallow).filter!(a => a.isDir).map!(a => tuple(a.name, a.timeCreated)));
foreach(i; dFiles[]){ Sorted ~= i; }
Sorted[].sort!((a,b) => a[1] > b[1]).each!(e => writefln!"%-63s %.20s"(e[0], e[1].to!string));
}
}

From,
Vino.B
December 15, 2017
On Friday, 15 December 2017 at 17:24:33 UTC, Vino wrote:
> Hi Biotronic,
>
>  I was able to find a solution using container array and also date formatting, below is the code, please do let me know if you find any issue, as i have tested the script and it is working as expected.
>
> Program:
> import std.algorithm: filter, map, sort, each;
> import std.container.array;
> import std.file: SpanMode, dirEntries, isDir ;
> import std.stdio: writeln,writefln;
> import std.typecons: Tuple, tuple;
> import std.datetime.systime: SysTime;
> import std.conv;
> void main () {
> auto FFs =  ["C:\\Temp\\sapnas2\\BACKUP", "C:\\Temp\\sapnas2\\EXPORT"];
> Array!(Tuple!(string, SysTime)) Sorted;
> foreach(d; FFs[]) {
> auto dFiles = Array!(Tuple!(string, SysTime))(dirEntries(d,

Why specify Array!(Tuple!(string, SysTime)) here? The return value from map should be perfectly fine, and if you really want an array I'd suggest writing
dirEntries(d, SpanMode.shallow)
    .filter!(a => a.isDir)
    .map!(a => tuple(a.name, a.timeCreated)))
    .array;
It's shorter, easier to read, and the speed difference should be miniscule at best. The same comment applies to Sorted, above, which could be defined as Tuple!(string, SysTime)[].

> SpanMode.shallow).filter!(a => a.isDir).map!(a => tuple(a.name, a.timeCreated)));
> foreach(i; dFiles[]){ Sorted ~= i; }

No need for a foreach here, you can just do Sorted ~= dFiles.

> Sorted[].sort!((a,b) => a[1] > b[1]).each!(e => writefln!"%-63s %.20s"(e[0], e[1].to!string));

You seem to be sorting and printing the Sorted array once per folder. Going back to [3,5,1], [6,2,4] example, this will print 1,3,5,1,2,3,4,5,6. That is, it sorts [3,5,1], then prints the result. Then it sorts [1,3,5,6,2,4], and prints that. If you move the sorting and priting outside the loop (so it's the last line before leaving main), you should get the correct result, and and not waste time sorting the array multiple times.

> }
> }

In total, the changes I propose would lead to this code:

import std.algorithm: filter, map, sort, each;
import std.array : array;
import std.file: SpanMode, dirEntries, isDir ;
import std.stdio: writefln;
import std.typecons: Tuple, tuple;
import std.datetime.systime: SysTime;
import std.conv : to;
void main () {
    auto FFs =  ["C:\\Temp\\sapnas2\\BACKUP", "C:\\Temp\\sapnas2\\EXPORT"];
    Tuple!(string, SysTime)[] Sorted;
    foreach(d; FFs[]) {
        auto dFiles = dirEntries(d, SpanMode.shallow)
            .filter!(a => a.isDir)
            .map!(a => tuple(a.name, a.timeCreated))
            .array;
        Sorted ~= dFiles;
    }
    Sorted[].sort!((a,b) => a[1] > b[1])
        .each!(e => writefln!"%-63s %.20s"(e[0], e[1].to!string));
}

--
  Biotronic
1 2
Next ›   Last »