On Thursday, 22 September 2022 at 21:49:36 UTC, Ali Çehreli wrote:

It can be preferred in terms of working at ranges. But it isn't useful in terms of having more than one character and moving away from strings. For example:

    auto data = [ "hello", "and", "goodbye", "world" ];
    auto hasZeros = data.joiner("\0\0").text; // ("hello\0\0", "and\0\0", "goodbye\0\0", "world\0\0")

    assert(hasZeros.count('\0') == 7);
    assert(hasZeros.splitz.walkLength == data.length * 2 - 1);

    auto range = hasZeros.splitz; // ("hello", "", "and", "", "goodbye", "", "world")

SDB@79

On Thursday, 22 September 2022 at 10:53:32 UTC, Salih Dincer wrote:

Accurate? No. Your code works. Correct is correct, no matter efficiency or style.

You won’t do it any shorter than this if returning a range of dchar is fine:

auto removez(const(char)[] string, char ch = '\0')
{
    import std.algorithm.iteration;
    return string.splitter(ch).joiner;
}

If dchar is a problem and a range is not what you want,

inout(char)[] removez(inout(char)[] chars) @safe pure nothrow
{
    import std.array, std.algorithm.iteration;
    auto data = cast(const(ubyte)[])chars;
    auto result = data.splitter(0).joiner.array;
    return (() inout @trusted => cast(inout(char)[])result)();
}

Bonus: Works with any kind of array of qualified char. As string is simply immutable(char)[], removez returns a string given a string, but returns a char[] given a char[], etc.

Warning: I do not know if the @trusted expression is really okay. The cast is not @safe because of type qualifiers: If inout becomes nothing (i.e. mutable), the cast removes const. I suspect that it is still okay because the result of array is unique. Maybe others know better?

On Friday, 23 September 2022 at 08:50:42 UTC, Salih Dincer wrote:

    auto data = [ "hello", "and", "goodbye", "world" ];
    auto hasZeros = data.joiner("\0\0").text; // ("hello\0\0", "and\0\0", "goodbye\0\0", "world\0\0")

    assert(hasZeros.count('\0') == 7);
    assert(hasZeros.splitz.walkLength == data.length * 2 - 1);

    auto range = hasZeros.splitz; // ("hello", "", "and", "", "goodbye", "", "world")

You should be explicit with requirements. It was hard to tell if you original code was correct.

auto splitz(string s) {
    return s.splitter('\0')
   .filter!(x => !x.empty);
}

On Friday, 23 September 2022 at 14:38:35 UTC, Jesse Phillips wrote:

Sorry, generally what I speak is Turkish language. So, I speak English as a foreign language but it's clear I wrote. What do you think when you look at the text I've pointed to following?

On Thursday, 22 September 2022 at 10:53:32 UTC, Salih Dincer wrote:

• characterS
• at the END
• of the STRING

auto splitz(string s) {
    return s.splitter('\0')
   .filter!(x => !x.empty);
}

By the way, if we're going to filter, why are we splitting? Anyways! For this implementation, indexOf() is a powerful enough tool. In fact, it's pretty fast, as there is a maximum of the \0 8 characters possible and when those 8 '\0' are at the end of the string! For example:

void main()
{
  string[] samples = ["the one\0", "the two\0\0", "the three\0\0\0",
                      "the four\0\0\0\0", "the five\0\0\0\0\0",
                      "the six\0\0\0\0\0\0", "the seven\0\0\0\0\0\0\0",
                      "the eight\0\0\0\0\0\0\0\0"];

  import std.stdio : writefln;
  foreach(s; samples)
  {
    auto start = s.length - 8;
    string res = s.splitZeros!false(start);
    writefln("%(%02X%)", cast(ubyte[])res);
  }
}

string splitZeros(bool keepSep)(string s, size_t start = 0)
{
  auto keep = keepSep ? 0 : 1;

  import std.string : indexOf;
  if(auto seekPos = s.indexOf('\0', start) + 1)
  {
    return s[0..seekPos - keep];
  }
  return s;
}

SDB@79

On Friday, 23 September 2022 at 18:37:59 UTC, Salih Dincer wrote:

Apologies for the confusion. You can use stripRight for this:

import std.string: stripRight;
import std.stdio: writeln;

void main()
{
    string[] samples = [
        "the one\0", "the two\0\0", "the three\0\0\0", "the four\0\0\0\0",
        "the five\0\0\0\0\0", "the six\0\0\0\0\0\0",
        "the seven\0\0\0\0\0\0\0", "the eight\0\0\0\0\0\0\0\0"
    ];

    foreach (s; samples) {
        writeln(s.stripRight("\0"));
    }
}

On Friday, 23 September 2022 at 22:17:51 UTC, Paul Backus wrote:

We have a saying: Estaghfirullah!

Thank you all so much because it has been very useful for me.

I learned two things:

• First, we can use strip() functions with parameters:
  https://dlang.org/phobos/std_algorithm_mutation.html#.strip

(examples are very nice)

• Second, we could walk through the string in reverse and with indexOf():
  https://github.com/dlang/phobos/blob/master/std/string.d#L3418

Source Code:

//import std.string : stripRight;/*
string stripRight(string str, const(char)[] chars)
{
  import std.string : indexOf;
  for (; !str.empty; str.popBack())
  {
    if (chars.indexOf(str.back) == -1)
      break;
  }
  return str;
}//*/

Delicious...

SDB@79