quirks 0.6.2

Metaprogramming library for the D language

To use this package, run the following command in your project's root directory:

Manual usage
Put the following dependency into your project's dependences section:



Build Status Github Actions codecov

quirks is a small library to simplify programming with traits and mixins.

See https://lljochemll.github.io/quirks/ for documentation and examples

For a list of "weird" things, look at the bottom


Quirks template

Swiss army knife for getting information about things

import quirks;
import std.stdio;

class User {
    uint age;
    string name;

    void talk(string message) {
        import std.stdio : writeln;


    bool isSitting() {
        return false;

auto userInstance = new User;

// can use both type and variable
alias info = Quirks!userInstance; // also works with Quirks!User

// Works at compile and runtime
pragma(msg, info.methods.length); // 2
pragma(msg, info.fields.length); // 2
pragma(msg, info.members.length); // 4
pragma(msg, info.isAggregate); // true
pragma(msg, info.methods[0].name); // talk
pragma(msg, info.methods[0].parameters[0].name); // message
pragma(msg, info.methods.filter!(m => is(m.returnType == bool)).filter!(m => true)[0].name); // isSitting
pragma(msg, info.methods.filter!(m => m.parameters.filter!(p => p.name == "message").length > 0)[0].name); // talk 


Adds string interpolation to mixins

import quirks;
import std.stdio;

class Foo {
    int id = 1;
    uint age = 23;
    string name = "foo";

auto foo = new Foo;

// version with interpolateMixin
static foreach (member; FieldNameTuple!(Foo)) {
        writeln("Field ${member} has a value of: ", foo.${member});

// version without
static foreach (member; FieldNameTuple!(Foo)) {
        writeln("Field ` ~ member ~ ` has a value of: ", foo.` ~ member ~ `);

hasMember, hasField, hasMethod

import quirks;

struct Foo {
    long id;
    string name() {
        return "name";

static assert(hasMember!(S, "id"));
static assert(hasMember!(S, "name"));
static assert(!hasMember!(S, "doesNotExist"));

static assert(hasField!(S, "id"));
static assert(!hasField!(S, "name"));
static assert(!hasField!(S, "doesNotExist"));

static assert(!hasMethod!(S, "id"));
static assert(hasMethod!(S, "name"));
static assert(!hasMethod!(S, "doesNotExist"));
static assert(hasMethod!(S, method => is(method.returnType == string)));


import quirks;
import std.stdio;

uint calculateAge(long birthYear, string planet = "earth");

alias parameters = Parameters!calculateAge;

static foreach (parameter; parameters) {
    write("Parameter " , parameter.name, " has a type of ", parameter.type.stringof);

    static if (parameter.hasDefaultValue) {
        writeln(" and a default value of ", parameter.defaultValue);
    } else {
        writeln(" and no default value");

Weird things


TL;DR: use .tuple if you want to be sure it will always work

While it is possible to do this:

alias things = AliasTuple!(bool, string, "hi");

pragma(msg, things[0]); // displays bool pragma(msg, things[2].length); // displays 2

This will not work:

alias things = AliasTuple!(bool, string, "hi");

pragma(msg, is(things[0] == bool); // displays false

But this will:

alias things = AliasTuple!(bool, string, "hi");

pragma(msg, is(things.tuple[0] == bool); // displays true pragma(msg, things[2].length == 2); // displays true pragma(msg, things.tuple[2].length == 2); // displays true

### Modules
While using this library on a module will work, it is far from perfect. For now only use ```MemberNames``` if you want to know what is inside a module. other methods like ```Members``` or ```Fields``` might compile but probably won't result in what you'd think.
  • lljochemll
0.7.0 2020-May-22
0.6.2 2020-Feb-03
0.6.1 2020-Jan-04
0.6.0 2019-Dec-16
0.5.3 2019-Nov-25
Show all 18 versions
Download Stats:
  • 0 downloads today

  • 0 downloads this week

  • 0 downloads this month

  • 36 downloads total

Short URL: