const std = @import( "std" );
const print = std.debug.print;

pub fn main() !void {
    print( "hello world\n", .{} );

    var alpha = Alpha {};
    print( "alpha: {d}\n", .{ alpha.a } );
    alpha_inc( &alpha );
    print( "alpha: {d}\n", .{ alpha.a } );

    var beta = Beta {};
    print( "beta: {d}\n", .{ beta.b } );
    beta_dec( &beta );
    print( "beta: {d}\n", .{ beta.b } );
}

const Alpha = struct {
    a :usize = 0,
    fn inc( this :*Alpha ) void {
        this.*.a += 1;
    }
};
fn alpha_inc( alpha :anytype ) void {
    alpha.inc();
    print( "here: {d}\n", .{ alpha.a } );
}

const Beta = struct {
    b :isize = 0,
    fn dec( this :*Beta ) void {
        this.*.b -= 1;
    }
};
fn has_dec( comptime t :type ) type {
    // var info :std.builtin.Type = @typeInfo( t );
    // how to work with `info`...

    // TODO review `fmt` code regarding meta logic
    // https://ziglang.org/documentation/master/std/#src/std/fmt.zig
    if( false ) {
        @compileError( "something is wrong" );
    }
    switch( @typeInfo( t ) ) {
        .@"Struct" => {
        },
        .Pointer => {
            @compileLog( "hello from struct info", .{ .t = t, .i = @typeInfo( t ) } );
            @compileLog( "maybe a Pointer ?" );
        },
        else => @compileLog( "apparently not a struct..." ),
    }

    // return anytype; // bad syntax
    return t;
}
fn beta_dec( beta :anytype ) void { return _beta_dec( beta, beta ); }
fn _beta_dec( beta :anytype, _ :has_dec( @TypeOf( beta ) ) ) void {
    beta.dec();
    // beta.mul();
}