as a part of getting a new job at IT, I got an online coding task from a future employer

I coded the solution, run the tests, they all passed

after I submitted the solution (which you cannot take back) I got a bad feeling

after two hours I realized that my "solution" was in fact a heuristics that works 90% of the time, but there are some corner cases in which it does not work

...but what I did not realize is that Microsoft will copy my solution right away :)

I was watching tsoding's crust stream and I thought it would be so funny if I extended c to have generics. Here is the result of that abomination

#include <stdio.h>

// you can define your own operator in fortran .op. style with a trait
trait<T> DotP {
    // for parsing reasons any dot-op must have whitespaces around it in any context
    T .dot. (Self self, Self other);
}

// using a very similar syntax to rust, you can add generics to structs
typedef<T> struct {
    T x;
    T y;
    T z;
} Vector<T>;

// and by appling the trait to your struct (with generic parmeters)
// you can define what your operator should do.
impl<T> DotP<T> for Vector<T> {
    T .dot. (Self self, Self other){
        return self.x * other.x + self.y * other.y + self.z * other.z;
    }
}

int main(void) {
    // by concretly defining which type you want to use as the generic
    // you create in generated c a struct with that/those type(s)
    Vector<float> fv = {1.0, 2.0, 3.0};
    printf("Dot product of fv^2: %f\n", fv .dot. fv);
    Vector<int> iv = {1, 2, 3};
    printf("Dot product of iv^2: %d\n", iv .dot. iv);
}

// The generated c code looks something like this:

// /* Generated by typedc. */
// #ifndef TYPEDC_SIMPLE_GENERICS_H
// #define TYPEDC_SIMPLE_GENERICS_H
//
// #include <stdio.h>
//
// typedef struct float_Vector float_Vector;
// typedef struct int_Vector int_Vector;
//
// struct float_Vector {
//     float x;
//     float y;
//     float z;
// };
//
// struct int_Vector {
//     int x;
//     int y;
//     int z;
// };
//
// int main(void);
// static inline float float_dot(float_Vector self, float_Vector other);
// static inline int int_dot(int_Vector self, int_Vector other);
//
// int main(void) {
//     float_Vector fv = {1.0, 2.0, 3.0};
//     printf("Dot product of fv^2: %f\n", float_dot(fv, fv));
//     int_Vector iv = {1, 2, 3};
//     printf("Dot product of iv^2: %d\n", int_dot(iv, iv));
// }
//
// static inline float float_dot(float_Vector self, float_Vector other) {
//     return self.x * other.x + self.y * other.y + self.z * other.z;
// }
//
// static inline int int_dot(int_Vector self, int_Vector other) {
//     return self.x * other.x + self.y * other.y + self.z * other.z;
// }
//
// #endif /* TYPEDC_SIMPLE_GENERICS_H */

https://github.com/HyperRays/typedc

• Python is like your kindergarten teacher.

• Rust is like your drill sergeant(the mean one).

For some reason, I've always envisioned HTTP requests in my head like this. ⚔️🐎🏰 Sorry. 😂
(AI declaration per rule 7: Generated via Higgsfield / Kling 4.0)