Select types at runtime

Explain
1

Hi,

given the following function signature

pub fn process(S: type, T: type, samples: [] const S) void {
   //process samples using T as result type
}

and an application, where the user can choose among a set of types for both S and T independently through command line arguments. What options are available to select the types at runtime?

At the moment I have two enums that provide the possible options the user can choose for both types, e.g. like these:

const SampleType = enum { i16, i32};
const OutputType = enum { f32, f64};

and then have nested switches in function wrappers

pub SwitchOnInputType(s: InputType, t: OutputType, samples: [] const S) void {
    switch(s) {
        .i16 => SwitchOnOutputType(i16, t, samples),
        .i32 => SwitchOnOutputType(i32, t, samples),
}

pub SwitchOnOutputType(S: type, t: OutputType, samples: [] const S) void {
    switch(t) {
        .f32 => process(S, f32, samples),
        .f64 => process(S, f64, samples),
    }
}

How would you implement this? What are possible pros/cons?

EDIT: somehow I messed up the code sample for the function wrappers.

2

Use a tagged union ! You will need to specify all the types in advance and give each type an id. Then you can use switch with the tag names instead of raw types.
Relevant section of the langage reference: Documentation - The Zig Programming Language

3

technically? none. parameters of type type are always comptime. when these functions are compiled, a new version of the function is instantiated for each distinct comptime argument, and that “monomorphized” function contains the code that is actually run.

having satisfied my desire to be technically correct (the worst kind of correct?) i’ll say that there are very many. a tagged union is a great option, as @Etienne_Parmentier mentions. other kinds of runtime polymorphism are also possible, but if you need to reach for them, you’ll know.

1 Like
4

I can give the worst answer, std.json.Value :smile:

4 Likes
5

Guess what OP wants

const std = @import("std");
const SampleType = enum { i16, i32 };
const Samples = union(SampleType) {
    i16: []const i16,
    i32: []const i32,
};

const OutputType = enum {
    f32,
    f64,
    pub fn T(comptime self: OutputType) type {
        return switch (self) {
            .f32 => f32,
            .f64 => f64,
        };
    }
};

pub fn process(comptime S: type, comptime T: type, samples: []const S) void {
    //process samples using T as result type
    std.debug.print("{s}{s}", .{ @typeName(S), @typeName(T) });
    _ = samples;
}

pub fn switchOnOutputType(samples: Samples, t: OutputType) void {
    switch (t) {
        inline else => |ctt| {
            const T = ctt.T();
            switch (samples) {
                .i16 => process(i16, T, samples.i16),
                .i32 => process(i32, T, samples.i32),
            }
        },
    }
}

test switchOnOutputType {
    const raw = [_]i16{ -1, 0, 1, 2 };
    var samples: Samples = .{ .i16 = &raw };
    var t: OutputType = .f32;
    _ = &samples;
    _ = &t;
    switchOnOutputType(samples, t);
}
6

ok ok, you won! :grinning_face_with_smiling_eyes:

7

Thanks, @Etienne_Parmentier and @npc1054657282 ! I know tagged unions but did not consider them here. I will think about it.

8

Using a tagged union here can simplify the case, but what’s more noteworthy is the use of inline else, which successfully converts OutputType from a runtime value to a comptime value.
Of course, doing this often comes with code bloat. If there are many possible types, it is best to think more about how to simplify the situation.

9

Yes, there are a few more types that I have to switch on. But eventually they end up in only four or maybe six prongs. Within these prongs casting takes care of the rest.

Not sure, if it is really better, but what I like about the tagged union approach is that the type info comes with the runtime parameter itself. So I might be able to get rid of the additional comptime type parameter in some places. I will play arround with it

10

When I needed to switch types I was using a simple enum with a function to return a type I need from it

/// Enum for Zig supported hashing algorithms
pub const ChecksumAlgo = enum {
    blake3,
    sha256,
    sha512,
    sha1, // Legacy
    md5, // Legacy
    sha3_256,
    sha3_512,
    blake2b,
    blake2s,
    ascon_hash,
    xxh3,

    /// Return a type based upon an enum
    fn HashType(comptime self: ChecksumAlgo) type {
        return switch (self) {
            .blake3 => std.crypto.hash.Blake3,
            .sha256 => std.crypto.hash.sha2.Sha256,
            .sha512 => std.crypto.hash.sha2.Sha512,
            .md5 => std.crypto.hash.Md5,
            .sha1 => std.crypto.hash.Sha1,
            .sha3_256 => std.crypto.hash.sha3.Sha3_256,
            .sha3_512 => std.crypto.hash.sha3.Sha3_512,
            .blake2b => std.crypto.hash.blake2.Blake2b256,
            .blake2s => std.crypto.hash.blake2.Blake2s256,
            .ascon_hash => std.crypto.hash.ascon.AsconHash256,
            .xxh3 => std.hash.XxHash3,
        };
    }
};

Then I was passing it where I needed it and based upon returned type had a different logic for hashing:

/// Worker for hashing function
fn hashWorker(
    comptime T: type,
    reader: *Io.Reader,
    result: *[getDigestLen(T)]u8, // Pointer to store the final hash
    name: []const u8,
) !void {
    std.log.debug("Started hashWorker for {s}", .{name});

    //  Run hashStream and write directly into the result pointer
    const hash = try hashStream(T, reader);
    @memcpy(result, &hash);
    std.log.debug("Finished hashWorker for {s}", .{name});
}

/// Uses a userspace to calculate and return a hash for streams
fn hashStream(comptime T: type, instream: *Io.Reader) ![getDigestLen(T)]u8 {
    const digest_len = comptime getDigestLen(T);

    // Crypto hashes usually take Options; Non-crypto usually take a u64 seed.
    var h = if (@hasDecl(T, "Options"))
        T.init(.{})
    else if (@hasDecl(T, "init"))
        T.init(0)
    else
        T.init();

    var result: [digest_len]u8 = undefined;
    while (true) {
        const data = instream.take(instream.buffer.len) catch |err| switch (err) {
            error.EndOfStream => {
                const buffered = instream.buffered();
                if (buffered.len != 0) h.update(buffered);
                break;
            },
            else => return err,
        };
        h.update(data);
    }

    // Check return type of a hasher
    const FinalReturnType = @typeInfo(@TypeOf(T.final)).@"fn".return_type.?;

    if (FinalReturnType == void) {
        // Cryptographic hashing
        h.final(&result);
    } else {
        // Non-crypto hashing
        const digest = h.final();
        // Convert integer to bytes (Big Endian is standard for hash display)
        std.mem.writeInt(FinalReturnType, &result, digest, .big);
    }
    // Always return array of bytes
    return result;
}
11

Hm, not sure how to transfer that to my use case… But I can see that moving the switching on the enum into itself is a common pattern… which makes sense. Thanks!