private String gender;

I for one identify as false

That should be private string? Gender. Explicit nullables are your friends.

let gender: Option<string>;

I like rust.
yeah don't even force people into identifying their gender as empty string since it's a social construct anyway
Which language(s) have <type>? now? Is that a new Java thing? JS/TS thing? I've never seen it.

Edit: formatting
- C#. Until semi-recently it was only used for value types (as reference types are supposed to be nullable by default) but these days you can enable explicit nullables, which means that you have to explicitly specify nullability even for reference types.
  
  I like explicit nullables. It's not much more work to type those question marks and it adds a safeguard against null showing up where it shouldn't.
  
  I specifically ~~inspired~~ insisted on it for this picture because the code on the sign uses capitalized names for something that isn't a class, which is a very C# thing to do.
- Kotlin has it as well
- I'm a novice in these matters, but it's definitely a thing in C#.

I fucking knew when I came into this thread it would just be nerds arguing over how wrong the joke is.

pub trait Gender {}

// implement your own gender, and if u want, publish online! :3
pub struct Masculine;
impl Gender for Masculine {}
pub struct Feminine;
impl Gender for Feminine {}

// removed old api:
// fn two_lovers(one: Masculine, two: Feminine)
// srry not srry for breaking backwards compat
// new version has more flexible api!<3
fn two_lovers(one: Box<dyn Gender>, two: Box<dyn Gender>) {
    println!("smooch~");
}

// todo: other functions!!

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn me_and_who() {
        two_lovers(Box::new(Feminine), Box::new(Feminine));
    }
}

PR: support polyamory

This also changes the API to take a shared reference rather than ownership of the lovers :3

pub fn lovers(partners: &[&dyn Gender]) { println!("smooch~"); }

Oh and while we're at it, for our agender users:

impl Gender for () {}
- PR: Merged
  
  Good call with using a shared reference so now we can kiss our partner(s) more than once!!
  
  Kissing many partners with one big smooch might be hard tho, maybe we need to change the implementation to use combinatorics so that everyone kisses each of their partners at least once.
  
  Since there's no way to tell who kisses who, i can cheat by printing nCr times :3
  
  pub fn lovers(partners: &[&dyn Gender]) { match partners.len() { 0 => { println!("ghost smooch~"); } 1 => { println!("mirror smooch~"); } p => { // p >= 2, safe to unwrap for _ in 0..ncr(p, 2).unwrap() { println!("smooch~"); } } } }

Should be enum.
And don't capitalize your variables.

enum implies that you cant change it, unless you were referring to the bool then true.
- Yes, instead of boolean. But instead of String, too, for optimization reasons. You could always just add more enum constants to it.
C# disagrees
- Idk C#, could you explain?

hehe that's good

Shouldn't it be protected and not private?

Also, a static gender would be pretty funny imo
- Our gender

Why are we even recording that?