On Friday, 6 October 2023 at 13:44:14 UTC, d007 wrote:
I am search for a fast 128bit integer ucent boolfilter, used
for server side duplicate request filter.
Is 128bit boolfilter a doable thing? or it will not work or
will be much more slow compare to 64 bit solution?
Can you describe or
Does anybody know of an autoformatted of SDLang, specifically for
dub.sdl?
On Wednesday, 19 April 2023 at 10:35:31 UTC, Per Nordlöw wrote:
On Wednesday, 19 April 2023 at 09:39:19 UTC, Per Nordlöw wrote:
On Wednesday, 19 April 2023 at 09:37:56 UTC, Per Nordlöw wrote:
. Has anybody gotten these things to work?
I'm gonna try `lsp-mode` instead of `eglot`.
I believe
On Wednesday, 19 April 2023 at 10:35:31 UTC, Per Nordlöw wrote:
I believe this should work
```elisp
(defun serve-d-command ()
"Shell command to start serve-d."
'("dub" "run" "--vquiet" "serve-d"))
(when (require 'lsp nil t)
(dolist (mode '(d-mode d-ts-mode))
(add-hook mode #'lsp)
On Wednesday, 19 April 2023 at 09:39:19 UTC, Per Nordlöw wrote:
On Wednesday, 19 April 2023 at 09:37:56 UTC, Per Nordlöw wrote:
. Has anybody gotten these things to work?
I'm gonna try `lsp-mode` instead of `eglot`.
I believe this should work
```elisp
(defun serve-d-command ()
"Shell
On Wednesday, 19 April 2023 at 09:37:56 UTC, Per Nordlöw wrote:
. Has anybody gotten these things to work?
I'm gonna try `lsp-mode` instead of `eglot`.
On Wednesday, 28 April 2021 at 23:04:27 UTC, Christian Köstlin
wrote:
if you configure it yourself, feel free to share the
configuration and maybe PR it to serve-d repo.
Its a little tricky, because the basic setup works e.g. with
emacs 27.2 or newer, but not with 27.1.
All that is needed (if
I just tried activating Linux and Windows CI for
https://code.dlang.org/packages/gmp-d
via
https://github.com/nordlow/gmp-d/.github/workflows/d.yml
Linux passes but the Windows builds all fail because `gmp.lib` is
not provisioned in the Windows CI. This is new to me so I need
some initial
On Monday, 12 December 2022 at 17:29:00 UTC, Steven Schveighoffer
wrote:
Removing keys while iterating is not supported. It will break,
in confusing ways, and possibly include a null pointer
dereference.
IRC, the specs says that it's an error to modify a foreach
aggregate but the compiler
On Tuesday, 13 December 2022 at 11:22:35 UTC, Per Nordlöw wrote:
IRC, the specs says that it's an error to modify a foreach
aggregate but the compiler curretly doesn't diagnose it.
I believe it should.
On Tuesday, 6 December 2022 at 01:48:54 UTC, ryuukk_ wrote:
Have you tried this?
https://github.com/Pure-D/serve-d/blob/master/editor-emacs.md
It should be similar for lsp-mode make sure you provide the
proper parameters
Ok, thanks.
On Monday, 5 December 2022 at 12:38:07 UTC, Per Nordlöw wrote:
On Monday, 5 December 2022 at 12:23:24 UTC, Per Nordlöw wrote:
Is there a D lsp-server available? I couldn't find anything at
https://code.dlang.org/search?q=lsp. Am I not using the
correct search terms?
Ahh, it's at
On Monday, 5 December 2022 at 12:23:24 UTC, Per Nordlöw wrote:
Is there a D lsp-server available? I couldn't find anything at
https://code.dlang.org/search?q=lsp. Am I not using the correct
search terms?
Ahh, it's at https://code.dlang.org/packages/serve-d.
Is there a D lsp-server available? I couldn't find anything at
https://code.dlang.org/search?q=lsp. Am I not using the correct
search terms?
On Tuesday, 29 November 2022 at 00:50:54 UTC, Paul Backus wrote:
If your goal is to avoid calling the copy constructor (and, I
assume, to avoid unnecessary instantiations of `move`), then
yeah, `isPOD` is the one you want.
Thanks.
On Monday, 28 November 2022 at 22:59:13 UTC, Paul Backus wrote:
Lots of types. For example, types with copy constructors or
destructors are not POD but may still be copyable.
This should be obvious if you read the definition of POD linked
from the language spec:
On Monday, 28 November 2022 at 20:58:43 UTC, Per Nordlöw wrote:
For which types `T` does
```d
__traits(isCopyable, T)
```
differ from
```d
__traits(isPOD, T)
```
?
I'm asking because I have code like
```d
static if (__traits(isCopyable, Element))
On Tuesday, 15 November 2022 at 22:15:36 UTC, Per Nordlöw wrote:
On Tuesday, 15 November 2022 at 21:03:24 UTC, Per Nordlöw wrote:
This is what I have so far.
Found some issues but still cannot instantiate my solution at
https://github.com/nordlow/phobos-next/blob/master/src/nxt/sorted.d#L15
On Tuesday, 15 November 2022 at 21:03:24 UTC, Per Nordlöw wrote:
This is what I have so far.
Found some issues but still cannot instantiate my solution at
https://github.com/nordlow/phobos-next/blob/master/src/nxt/sorted.d#L15
when I uncomment the line containing
```d
// TODO:
This is what I have so far.
```d
import std.algorithm.mutation : SwapStrategy;
/** Wrapper container around array (slice) or array-like
(container) `A`.
*
* See_Also: https://en.wikipedia.org/wiki/Sorted_array
*/
struct Sorted(A, alias less = "a < b", SwapStrategy ss =
On Monday, 14 November 2022 at 00:29:40 UTC, Tejas wrote:
He said on Discord he want contiguous data structure, rbtree
allocates too much
rbtree has it's uses cases. I wanted a sorted array because I
want to include it in a benchmark suite and study it's time and
space complexity. No
Have anybody created a wrapper container
```d
struct Sorted(ArrayLike, alias lessThanPred)
```
that wraps an array-like type `ArrayLike` so that it's always
sorted according to the binary predicate `lessThanPred`?
When is it preferrable to use
```d
struct S { private T t; alias t this; }
```
instead of
```d
struct S { public T t; alias t this; }
```
for any given type `T`?
On Monday, 24 October 2022 at 20:43:45 UTC, ryuukk_ wrote:
I wish we could do ``version(DebugFast | Release)``
Moreover, I've been using, for instance,
```d
version(D_Coverage) {} else pragma(inline, true);
void foo() {}
```
to get correct coverage inclusion of `foo()`. Is this still neeed?
What property of a container (type) `T` enables iteration as
```d
foreach (k, v; T.init)
{
...
}
```
? I thought it sufficed to define `T.byKeyValue` but its presence
seem to have no effect.
In dub, is it possible to override the dflags, in my case `-cov`,
for a single file only without it affecting the rest of the
compiling and linking? Currently, dub enforces static linking of
the dependencies when the `-cov` flag is set via `dflags "-cov"`
in dub.sdl which makes our build
On Sunday, 18 September 2022 at 08:24:27 UTC, Per Nordlöw wrote:
Given shared library `X` depending on other shared libraries
`Ys`, is it possible, using dub, to use extra `dflags` `F` when
building the sources of `X` only and not have those extra flags
`F` be used when (re)compiling `Ys`. In
Given shared library `X` depending on other shared libraries
`Ys`, is it possible, using dub, to use extra `dflags` `F` when
building the sources of `X` only and not have those extra flags
`F` be used when (re)compiling `Ys`. In my specific case those
flags are `-fsanitize=address` and `-cov`.
On Sunday, 14 August 2022 at 10:41:20 UTC, ag0aep6g wrote:
On 14.08.22 12:08, Per Nordlöw wrote:
How do I index an `AliasSeq` with an integer known at run-time?
Thanks
How do I index an `AliasSeq` with an integer known at run-time?
On Friday, 3 September 2021 at 23:39:44 UTC, Per Nordlöw wrote:
When is a phobos unittest supposed to be qualified with version
`(StdUnittest)`? Ideally, always? I don't see that their
current use is consistenly following a rule. If so, is the
purpose of its presence to reduce the burden of
On Monday, 6 September 2021 at 15:46:52 UTC, Paul Backus wrote:
* `void allocate(size_t size)`
Should be
* `void[] allocate(size_t size)`
Thanks. Here's what I have so far
```d
enum isAllocator(T) = (is(typeof(T.allocate(size_t.init)) ==
void[]) &&
On Saturday, 4 September 2021 at 20:05:17 UTC, Per Nordlöw wrote:
```sh
time dmd import_std.d -o-
```
should be
```sh
time dmd -unittest import_std.d -o-
```
On Saturday, 4 September 2021 at 13:12:49 UTC, Steven
Schveighoffer wrote:
Note that lexing and parsing is extremely quick, and I wouldn't
focus on trying to trim this out, you won't get much
performance out of that.
-Steve
For the record, a D file containing only `import std;` type
checks
Is there a reason for the absence of an `isAllocator` trait under
`std.experimental.allocator`?
On Saturday, 4 September 2021 at 12:40:02 UTC, Per Nordlöw wrote:
Omg. It really seems like it's motivated to do a benchmark with
phobos unittests prefixed with
Should have been a reply to
The "never" is false, https://d.godbolt.org/z/c4oeYM7rG
On Saturday, 4 September 2021 at 12:40:02 UTC, Per Nordlöw wrote:
then. I can make that refactoring in my favorite choice of
editor and see the result differ. In terms of binary size, and
speed and memory usage of check, build and link time.
Automated that is.
If we want this, shall we
On Saturday, 4 September 2021 at 12:31:33 UTC, Dennis wrote:
On Saturday, 4 September 2021 at 09:42:46 UTC, Per Nordlöw
wrote:
Yes, but they are lexed and parsed, right?
Right, but that's the case regardless of `version(StdUnittest)`.
Omg. It really seems like it's motivated to do a
On Saturday, 4 September 2021 at 12:31:33 UTC, Dennis wrote:
Right, but that's the case regardless of `version(StdUnittest)`.
I don't think so. My guess is that `version(StdUnittest)` does
maximum parsing, maybe only lexing. How can one easily determine
if this is the fact? Behaviour of
On Saturday, 4 September 2021 at 03:18:01 UTC, Paul Backus wrote:
As Steven Schveighoffer [pointed out][1], Phobos unittests are
never included in user code, regardless of whether
`StdUnittest` is used.
Yes, but they are lexed and parsed, right?
When is a phobos unittest supposed to be qualified with version
`(StdUnittest)`? Ideally, always? I don't see that their current
use is consistenly following a rule. If so, is the purpose of its
presence to reduce the burden of the compiler when the
application using phobos is compiled with
On Wednesday, 1 September 2021 at 22:51:40 UTC, Per Nordlöw wrote:
Can somebody explain the need for
Ok, `__traits(isSame)` always returns false for values.
This is very unfortunate as `std.traits.isSame` is one of the
most used template instances in typical std.meta-programming and
has a
Can somebody explain the need for
```d
private template isSame(alias a, alias b)
{
static if (!is(typeof( && )) // at least one is an rvalue
&& __traits(compiles, { enum isSame = a == b; })) //
c-t comparable
{
enum isSame = a == b;
}
else
{
enum
On Monday, 30 August 2021 at 20:32:28 UTC, Adam D Ruppe wrote:
You can define one yourself of course with overrides in child
classes to update those kinds of things. But doing it
automatically is tricky.
Yes, thanks. I was interested in the possibility of a single
non-member function,
Why doesn't `Object` have an auto-defined `.dup` property? It
would be useful when dealing with, for instance, handling of
`Throwable`'s in multi-threaded contexts.
On Wednesday, 28 July 2021 at 21:39:43 UTC, jfondren wrote:
I don't know, but .byValue is @safe and returns a forward
range, so you could use `.init.byValue.array` instead.
Great point. Thanks.
Why is call to `values` in, for instance,
```d
auto _ = string[string].init.values;
```
not `@safe`?
On Thursday, 15 July 2021 at 11:08:25 UTC, Per Nordlöw wrote:
The adding of copy construtors to `Service` defined as
```d
@safe struct Service {
this(ref return scope typeof(this) rhs) {}
this(const ref return scope typeof(this) rhs) const {}
}
Using `inout` as
```d
@safe struct
On Thursday, 15 July 2021 at 11:08:25 UTC, Per Nordlöw wrote:
fails in the same way. What's wrong?
```d
@safe struct Service {
this(ref typeof(this) rhs) {}
this(const ref typeof(this) rhs) const {}
}
```
also fails. On the other hand, using a postblit as
```
@safe struct Service {
The adding of copy construtors to `Service` defined as
```d
@safe struct Service {
this(ref return scope typeof(this) rhs) {}
this(const ref return scope typeof(this) rhs) const {}
}
@safe struct Session {
void openAndGetService(in string key) scope {
import
Given
```d
import std.range.primitives : isInputRange;
enum isDumb(Args...) = (Args.length == 2 && Args.length == 3);
void f(Args...)(Args args)
if (isDumb!(Args))
{
}
void g(Arg)(Arg arg)
if (isInputRange!(Arg))
{
}
@safe pure unittest
{
f(2, 3);
g(2);
}
```
`dmd` diagnoses the
On Thursday, 6 May 2021 at 01:04:02 UTC, Jack wrote:
Does it allocate the object rather on stack, like auto scope a
= new A or what?
Further note that
auto scope a = new A;
can be written shorter as
scope a = new A;
On Monday, 4 March 2019 at 00:07:39 UTC, r-const-dev wrote:
I'm trying to implement a thread safe class, guarding data
access with synchronized and atomicOp.
To get more help with memory safety checking from the compiler,
please instead use `@safe` as
```d
import std.typecons : Nullable;
On Monday, 12 April 2021 at 20:50:49 UTC, Per Nordlöw wrote:
more aggressive collections when nearing it.
What is a more aggressive collection compared to a normal
collection? Unfortunately we still have no move support in D's GC
because of its impreciseness.
On Monday, 12 April 2021 at 20:50:49 UTC, Per Nordlöw wrote:
I'm surprised there is no such functionality available.
It doesn't sound to me like it's that difficult to implement.
Afaict, we're looking for a way to call `GC.collect()` when
`GC.Status.usedSize` [1] reaches a certain threshold.
On Monday, 12 April 2021 at 07:03:02 UTC, Sebastiaan Koppe wrote:
On side-note, it would also be good if the GC can be aware of
the max memory it is allotted so that it knows it needs to do
more aggressive collections when nearing it.
I'm surprised there is no such functionality available.
It
Inside dmd source tree, under sub-directory test, I do
./run.d compilable/
. This errors as
```
... compilable/json.d -d -preview=dip1000 -o- -X
-Xf/home/per/Work/dmd/test/test_results/compilable/json.out
-fPIC ()==
Test 'compilable/json.d'
https://forum.dlang.org/post/rkxnfxsjvkffxufok...@forum.dlang.org
On Thursday, 1 January 2015 at 19:18:34 UTC, Nordlöw wrote:
Do we really need Append and Prepend (along with append and
prepend) here? Doesn't [cC]hain already fulfill the needs of a
lazy range in this case inplace of Append?
On Sunday, 4 April 2021 at 11:48:37 UTC, Imperatorn wrote:
On Sunday, 4 April 2021 at 11:12:36 UTC, Per Nordlöw wrote:
Trying to access https://dlang.slack.com/ hangs for minutes on
my machine.
I'm only using the app, same thing there for you? 樂
I was trying the desktop version. Works now.
Trying to access https://dlang.slack.com/ hangs for minutes on my
machine.
On Wednesday, 24 March 2021 at 10:25:21 UTC, Basile B. wrote:
In now way. But in your question you mentioned @nogc nothrow
and not @safe and pure.
Ok, thanks.
Note that core.exception.onOutOfMemoryError is already qualified
as @nogc nothrow pure @trusted.
On Wednesday, 24 March 2021 at 08:31:19 UTC, Basile B. wrote:
There are several ways to do that. In addition to
onOutOfMemoryError, you can use a static instance
void v() @nogc nothrow
{
__gshared oom = new OutOfMemoryError();
auto X* = X_create();
if (X is null)
throw
When wrapping C code that tries to allocate memory resources via
functions such as
X* X_create();
should one call `onOutOfMemoryError();` upon null return?
Making more D wrappers `nothrow @nogc`.
On Tuesday, 23 March 2021 at 01:07:15 UTC, Steven Schveighoffer
wrote:
And the answer is complex. You can't accept a const range,
because they don't work. The only way to have purity infer
uniqueness is to accept paramters that the result could not
have come from. Usually this means accepting
On Tuesday, 23 March 2021 at 01:07:15 UTC, Steven Schveighoffer
wrote:
const(char)[] x = "foo";
string chained = chainPath(x, "bar").array;
that calls the template overload
ForeachType!Range[] array(Range)(Range r)
if (isIterable!Range && !isAutodecodableString!Range &&
!isInfinite!Range)
On Monday, 22 March 2021 at 20:38:36 UTC, Per Nordlöw wrote:
chainPath(...).array
To clarify, for instance, given
string s;
const(char)[] c;
all the calls
chainPath(s, s).array
chainPath(c, c).array
chainPath(s, c).array
chainPath(c, s).array
return
Am I the only one being annoyed by the fact that
chainPath(...).array
doesn't implicit convert to string despite the array returned
from .array is allocated by the GC.
Yes, I know that I should do
chainPath(...).array.assumeUnique
but the uniqueness of .array (and in turn implicit
On Tuesday, 16 March 2021 at 13:31:34 UTC, Imperatorn wrote:
foreach(0..n) could work. Why though.
When performing a side-effect n times.
I find myself writing
foreach (_; 0 .. n)
doSomething(); // no using the variable `_`
.
What about relaxing the syntax to allow
foreach (; 0 .. n)
and/or
foreach (0 .. n)
?
Thereby making the `ForeachTypeList` of `AggregateForeach` in the
grammar rule [1] optional.
[1]
On Tuesday, 9 February 2021 at 03:05:10 UTC, frame wrote:
On Sunday, 7 February 2021 at 14:13:18 UTC, vitamin wrote:
Why using 'new' is allowed in pure functions but calling
GC.addRange or GC.removeRange isn't allowed?
Would making
`new T[]` inject a call to `GC.addRange` based on `T` (and
On Monday, 1 February 2021 at 15:47:33 UTC, Steven Schveighoffer
wrote:
"Concatenation always creates a copy of its operands, even if
one of the operands is a 0 length array"
Btw, does
x ~ y ~ z ~ ...
result in a single allocation?
On Monday, 1 February 2021 at 16:30:31 UTC, Per Nordlöw wrote:
Btw, does
x ~ y ~ z ~ ...
result in a single allocation?
Provided all the operands has a `length` property.
On Monday, 1 February 2021 at 10:27:29 UTC, Jacob Carlborg wrote:
Why isn't
"Name " ~ name ~ " could not be found"
implicitly convertible to `string`?
Because if you have arrays of reference types, it's possible to
change an element of the mutable array, which will affect the
immutable
On Monday, 1 February 2021 at 10:24:59 UTC, Mike Parker wrote:
There is no "extra" instance because there's no single instance
of an enum value. They have no address. When you use one, it's
just as if you were writing the literal instead of the enum
name. In other words:
enum ea = [1, 2, 3];
On Monday, 1 February 2021 at 11:37:49 UTC, Per Nordlöw wrote:
Ok, so then my follow-up question becomes, does the right hand
sides of these two assignment share the same AST node? If not,
why?
Because such a shared AST node could be potentially mutated in
different ways in different
On Monday, 1 February 2021 at 09:52:07 UTC, Jacob Carlborg wrote:
If you don't want a new instance, then don't use `enum`. Use
`immutable` instead.
Agreed. My question is why does an `enum` require an extra
instance from a compiler architecture point of view? Do all
compilers handle
An enum only exists at compile-time, and does not occupy any
space. Each time it's referenced, a new instance of the value
is created. Why is that? Seems like a waste of resources to the
compiler.
Given
char x[];
why is
typeof("a" ~ x)
`char[]` when
typeof("a" ~ x.idup)
is
`string`?
My case is
class NameLookupException : Exception
{
this(string name) {
super("Name " ~ name ~ " could not be found");
}
this(scope const(char)[] name) {
On Tuesday, 19 January 2021 at 21:04:51 UTC, kdevel wrote:
And then? I mean: What do you want to do with the long what
could not
be done with the double in the first place?
Motivated question.
We want to propagate to our system locally that a double received
from a network communication
On Tuesday, 19 January 2021 at 16:14:17 UTC, drug wrote:
https://dlang.org/phobos/std_bitmanip.html#FloatRep
Doesn't this pattern already cover all possible cases of `value`
needed?
void f(double value)
{
auto lvalue = cast(long)value;
if (lvalue == value) // `value` lacks
On Tuesday, 19 January 2021 at 17:03:53 UTC, Ali Çehreli wrote:
I think it would be a useful improvement.
Indeed. Maybe Ilya could help out adding this to dmd.
On Tuesday, 19 January 2021 at 13:36:58 UTC, Steven Schveighoffer
wrote:
Use a cast instead.
const lvalue = cast(long)value;
Ahh, good point.
Followd by a compare of the original value I presume.
I want to convert a double to a long if conversion is lossless
(without fractional part, non-nan, non-inf, within long-range,
etc).
I currently have
void foo()
{
const double value = 10.1;
try
{
import std.conv : to;
const lvalue = value.to!long;
if (lvalue
On Sunday, 3 January 2021 at 18:26:44 UTC, Per Nordlöw wrote:
alias Matcher = Match function(Matcher[] matchers...);
but it errors as
recursive alias declaration
Preferrably I wanted a non-templated definition.
How can I define a function type `Matcher` that takes an array of
`Matcher`s and returns an instance of a `struct Match` defined as
struct Match
{
@safe pure nothrow @nogc:
static Match zero()
{
return typeof(return)(0);
}
static Match none()
{
return
On Wednesday, 18 November 2020 at 23:43:15 UTC, Petar Kirov
[ZombineDev] wrote:
https://gist.github.com/PetarKirov/b4c8b64e7fc9bb7391901bcb541ddf3a
Thanks a lot!
On Monday, 16 November 2020 at 10:21:27 UTC, Per Nordlöw wrote:
Which DUB packages do you prefer?
https://code.dlang.org/packages/dlibgit seems good. But that
requires `libgit` to be installed. It would be nice to have a
fallback to calling `git`.
I need a function that gets the relative path of a file in a
Git-repo and preferrably also its status.
Either via an external call to `git` or optionally via `libgit`
(if available).
Which DUB packages do you prefer?
On Monday, 9 November 2020 at 16:39:49 UTC, Boris Carvajal wrote:
There's also:
dchar(0xd8000)
Thanks
On Thursday, 12 November 2020 at 09:22:10 UTC, Per Nordlöw wrote:
Why don't I get a stack trace on Memory allocation exceptions?
Is it because the stack may be corrupted?
Why don't I get a stack trace on Memory allocation exceptions?
In my case I only get:
src/core/exception.d(647): [unittest] Memory allocation failed
core.exception.OutOfMemoryError@src/core/exception.d(647): Memory
allocation failed
On Monday, 9 November 2020 at 17:06:50 UTC, H. S. Teoh wrote:
I'm pretty sure std.regex already supports Unicode regexes.
Yep [1].
Thanks
[1]
https://dlang.org/phobos/std_regex.html#Syntax%20and%20general%20information
Is there any library that can deal with decoding and generating
character matchers for Unicode regular expression described at
https://www.regular-expressions.info/unicode.html
On Sunday, 8 November 2020 at 10:47:34 UTC, Per Nordlöw wrote:
cast(dchar)0xd8000
To clarify,
enum dch1 = cast(dchar)0xa0a0;
enum dch2 = '\ua0a0';
assert(dch1 == dch2);
works. Can I use the first-variant if I want to postpone these
encoding questions for now?
On Saturday, 7 November 2020 at 17:49:54 UTC, Jacob Carlborg
wrote:
[1] https://en.wikipedia.org/wiki/UTF-16#U+D800_to_U+DFFF
Thanks!
I'm only using these UTF characters to create ranges that source
code characters as checked against during parsing. Therefore I
would like to just convert
I'm writing a parser generator for ANTLR-grammars and have come
across the rule
fragment Letter
: [a-zA-Z$_] // these are below 0x7F
| ~[\u-\u007F\uD800-\uDBFF] // covers all characters
above 0x7F which are not a surrogate
| [\uD800-\uDBFF] [\uDC00-\uDFFF] // covers UTF-16
On Tuesday, 27 October 2020 at 10:46:42 UTC, Jacob Carlborg wrote:
[1] http://mustache.github.io/mustache.5.html
[2] https://code.dlang.org/packages/mustache-d
Thanks
I'm looking for elegant ways of expressing expansion of
parameterized strings written to a file at run-time. My primary
use case is run-time generation of D code. In the lazy case,
something like
import std.file : write;
import std.algorithm : substitute;
const s = q{int $X =
I need a string template system for generation of parsers in D
code to compiled in separate phase (not Pegged).
What packages is there for this?
If I want GC-free string formatting and outputting to
stdout/stderr what packages should I prefer at code.dlang.org?
1 - 100 of 845 matches
Mail list logo
