I was scrolling through popular and ran into this post (yeah I know, it's from conspiracy).

Anyway, upon looking at the sources, it seems like future variants of covid will have more variation in the spike protein. Also, it looks like the spike protein had more mutations before vaccines were even accessible yet. As a matter of fact, the N-protein had MORE selective pressure from the presence of natural immunity at the time (because it was the only type of immunity) and STILL was less mutable than the spike protein. And now, the spike protein is mutating even MORE with the vaccine. Could I be looking at the article incorrectly? It's like the vaccine is doomed to some (un)planned obsolescence when using the spike protein.

So I have two questions, why would they select the most mutating protein, and why would the selective pressures from natural immunity not be as strong?

I've just finished a very simple and easy to use library that allows you to get as man̸͖̓ÿ̸̹́ ̸̬̆m̸̝̆ụ̵͛t̵̩͠a̴̘͒b̵̢̒l̸͚̄ë̵̹́ ̷̼͑r̶̨̽ḙ̷̊f̵̼̎e̴̩̾r̵̡͘e̷͚͠ǹ̵̞ces as you need and solves all your so̷r̴r̷o̸w̶ ̷c̶h̴e̴c̶k̴e̴r̸ and thread/resource sharing p̴̙̲͐̂r̸̹̟͂̎ỏ̶̞̙̑b̵̟͐̄ḹ̵̤͠ę̴̭̓̂m̸̩͖̀̑s̷͙̆!

https://github.com/Eugeny/rust-sinner

Please try it and l̸e̶a̶v̴e̶ ̶y̸o̶u̷r̸ ̴f̴e̸e̶d̶b̵a̵c̸k̴ j̷̭͋u̸̪͑s̴̭͆t̶̞̽ ̵̘̏p̵͓͝ĺ̶͎e̵̫͗ạ̵̄s̷̠̿e̷͎͑ ̵͇͘d̴͕̅ǒ̵̼n̴̢̿'̸̂ͅt̶̥̄ ̸̞͗f̴̛̭̖͚̞͗́̈́͜e̶̝͑̅̈́͘͘ͅę̶̮̮̮̺̇̿̇̓ḑ̸̙̺͉͋ ̷̲͔̇̽̊͑͝ȉ̶͇̹̅̽t̸̡͗̇̍̐̒ ̸̠͓̖̥͊̿͐͜ḁ̷̽͆͘͘ ̷͔̱̹̂̆̾́̃s̴̺̦̲͇̃̏̚͘ṯ̸̫̆̈́̉͝r̸̢͖͇̒ä̶͇͎͙́͝y̷̝̋̈́̉̉ ̴̭̖̙̦̈͋̽͐̑p̵̻͍͗ͅo̷͉͈̰͖͘i̴̮̗͓̘̋̓͆ṋ̴̄͋̔t̷̯͙̬̦̰̿̑͗̌̈e̵͔̖̿r̴̥͙͙͗̃̀̋ p̴̡̛̱̤̭̮̺͎̝̟̩̲̾͋̉͆͛͗͑̉̊͝͝l̵̡͙͙̪̩̱̭̝̹̹͂̀̈͛͂̾̽̾͊ͅẽ̵̡̙̱͇̫̟͙͎̫̏̓ȃ̶͓̘̙̘͓̆s̵̮̪͂̔̑́̍̅ͅͅê̸̢̨͔͍̦̳̭̂̊́̈́̇͛͜͠ͅ ̷̤͖͇̄͛̒̾̋̇́͂̎o̴̧̮̠̠͍̺̥̺͆̓͗̒̓h̷̹̭̍ ̷̛̣̠͌̋͌̍̅͆́͊̄̿ģ̵͖͉͈͈͙͙͍̥̉͒̈̚ͅǫ̷͔̗͇̅̏̃͊̄̈̚d̵̤͓̺̳̯͕̖͚͍͕͎̈́̍̌̉̏̏ ̴̟̐̈̇̀̍͌͗͂̂͝Ì̸͇̯̼̞̳͙̘͍͇̮̅̀̅ ̶̠̞̮̟͍̙̗̰̈́̉̅͋͂͝͝c̶̠̩̋̌͜a̴͙͇̣̟̩̎͆͐̓͋̈͌̃̚n̴̥͍͔̏̈̓̌̅̈̾̐̊̎̒͂͠'̴̜̥̻͔̭̄̆̇̊̂͆͐̕͘͝͠t̸̮̝̲̻̙͒̓̓̆̌̅̈́͒̋̚͠ t̸̛̮͔̟̒̏̌̒̏̍͛̚a̶̢̫̞̳̝̠͒̎͂̍͋̆͑̓͘k̵̨̛̰̫̖̦̯̞̻̓̄̉̀̎̔̎́̀͊̾͝ȩ̸̢͍̦̲͇͇͕̟͙͚̘̼̬̙̑ ̷̢̢̱̱̗̱̖̙̱̹͎̬͂͋̑̃̑͜͝ͅi̴̛̟̲̙̘̹͔͍͕̠̪̱̖̒̈́̓̓͒̽̎̎̽̉̍̐̈̚ͅͅt̸̢͓̻̤͚̘̂͝ ̷̠̲̼̘̗́̍ạ̸̯̍̆̾ṋ̸̒̋͑̈́̓y̵̯͖̺̤̞͚͖̤͍͛̈̓ͅm̸̯̠̹̬͎̮̪̮̀̎͛̆̔̀̍̈́͌͌̓͘͝ȍ̸̢̢̬̻̫̗̟̞̫̟̙̼̠͕̰͙͑̆̏͋͗̓̚͜r̶̛̖̻̋̏͂͑̊̀̔̃͂̎̔͆̒̃̑e̴̛̻͌̊͋͝

You may have seen this post where someone asked Reddit to create a deck by commenting cards. This redditor chose meren, a pretty good card, I want to try this with [[Chromium, the mutable]] who I like the concept of, I just can never find a way to make this guy work as a commander. So let’s try the same thing the other post did! Build me a chromium deck Reddit! The top 99 comments with be the 99 cards in the deck so upvote what you like to make sure it gets in the deck.

First, I know "mutable state" is against functional programming principles. Please read this post before responding.

I have become quite fond of functional programming paradigms to the point where I try to write all my code in the functional style. I primarily work in non-pure-functional languages, but it's usually possible.

In a lot of cases, this is pretty straightforward: create a chain of functions that communicate with data via IO, do their thing, and then write out the result via IO. Nice and simple.

Recently though I was dealing with a situation where it seemed optimal to hold onto some data in-memory, rather than just rely on reading/writing via IO. This is where I got a bit confused. If I was to hold this data in-memory, then at some point in my application I would need mutable state. As in, there would need to be a shared reference somewhere in my application that would need to be modified as the data changes.

Obviously this goes against functional programming principles, but I did it anyway because working code is always my top priority, vs theoretical correctness. That being said, I really want to learn how to handle this better for the next time this comes up.

One thing I've been thinking about is caching. Basically have a caching layer between the app and the data source, so that the functional code could just do IO while preserving the performance benefits of in-memory operations. This is just one thought that I have.

I'm just hoping for guidance on the best way to handle in-memory data manipulation without compromising functional purity and a no-mutation coding approach. Thanks.

I'm trying to do Advent of Code day 22 in Rust and running into an issue with the borrow checker that I can't find my way around. I'm actually somewhat experienced in using Rust for these problems so I'm not sure if I'm having a brain fart or if I truly just don't know how to handle this.

What I need to do is iterate through the variable steps mutably, and alter each step based on the steps processed so far (hence the [0..i] bit). I'm not able to do the let other_steps = steps.clone(); part since that takes an immutable borrow. Is there a way to do what I want to do?

let mut i = 0;
for step in &mut steps {
    let other_steps = steps.clone();
    for other_step in &other_steps[0..i] {
        if step.intersects(&other_step) {
            for intersect in step.intersection_cuboids(&other_step) {
                step.subcuboids.push(intersect);
            }
        }
    }
    i += 1;
}

Disclaimer: the ugly use of the separate i for enumeration rather than using .iter().enumerate() is because I was initially hoping that would avoid some of the borrowing issues.

This code snippet (example 1) works:

let output:Output = Command::new("echo")
    .arg("hello world")
    .output()
    .expect("execution failure");

Now, if I want a reference to the Command structure used in that expression, as a Rust newbie I naturally tried this (example 2):

let command = Command::new("echo")
    .arg("hello world");
let output = command.output()
    .expect("execution failure");

This fails to compile because Command::new creates a temporary, and arg() returns a reference to that temporary, but the temporary is deallocated after that, which would leave a dangling reference (please correct me if I haven't described this correctly.)

Here's one way to fix this (example 3):

let mut command = Command::new("echo");
command.arg("hello world");
let output = command.output()
    .expect("execution failure");

Is there a simpler way to write example 3 that looks more like example 2, i.e. with a single statement instead of two? E.g., using * or something like that? My attempts at that have failed, but this may be due to unfamiliarity. There may be other specifics involved here, e.g. the returned reference is mutable, Command doesn't implement Copy, etc...?

Essentially, I have an expression which returns a (mutable) reference to a temporary, and I want to store the referenced temporary in a variable. It seems like it ought to be possible for the language to handle that for me in a single statement. If it can, great! If it can't, I'm curious to understand why not.

Hello,

I have been turning my wheels with this for a few days now and any help would be really helpful!

The gist of the problem is that I have a big array and I want to update sections of it in parallel (probably using threads) without any any locks. I would love to be able to just spin up the threads and have them all update their sections of data all at the same time.

Is there a way to achieve this in Rust?

I was trying out crossbeam, but I keep getting cannot borrow "\*write\_cube.matrix" as mutable more than once at a time. Where write\_cube.matrix is a $mut Cube. (If you noticed the var name I'm actually dealing with a 3d array, but that does not really have to do with the core issue.)

I rebooted my (void-linux) PC after upgrading the system packages. I now run into an error before the boot sequence can fully resolve.

ERROR: cannot import name 'MutableMapping' from 'collections' (/usr/lib/python3.10/collections/__init__.py)

I don't know enough about Python to try and rectify this issue and all the research I've done has led me to specific application issues ... nothing really relevant to my case here. My understanding it that the __init__.py upgrades itself after python upgrades so the issue might be with another software not being updated yet.

Any help would be appreciated! What can I do or look for to fix this error?

Solution:

Disabling fail2ban fixed this issue

Thank you

The context is the Bronze GC user study. A number of commentators have remarked that adding support for multiple mutable aliases to an object is unsound in Rust.

As an outsider: Why? I'm well aware of the borrow checker's enforcement of the single-writer principle. What I want to understand is which aspects of rust rely on that principle for their soundness. Are single-threaded programs also rendered unsound when multiple mutable aliases to an object are outstanding within the lifetime of the object?

Thanks!

I just recently started learning rust but I'm a bit confused to why this error exists as detailed in this blog: https://oribenshir.github.io/afternoon_rusting/blog/mutable-reference. I've run into a similar issue and the only solution posed here is essentially a workaround for limitations of the compiler. What is the compiler trying to protect against? At the moment while there's a lot to like with rust, working with ownership rules and the borrow checker is at the moment more annoying than it's worth.

Can someone please explain the reasoning behind this error? I'm considering going back to C# for hobby projects just because I feel like I fight the language less.

I expect that it may be more difficult for someone to embrace life lessons when in fixed signs vs mutable or cardinal? How much do you resist or go with the flow?

Hello

I have a code that is supposed to be essentially a wrapper around several HashMaps arranged in a graph. Each map can only refer to one parent, and I need to return a reference to an object if it exists in the current map, or one of its parents.

I used a loop to do this, but I get an error saying that the value is actually borrowed multiple time, one in each iteration of my loop. Can someone explain me why this is the case ?

pub fn get_mut(&mut self, name:  &String) -> &mut Symbol {
    let mut current = Some(self.current);

    while let Some(id) = current {
        let scope = self.scopes.get_mut(id).unwrap();
        if let Some(symbol) = scope.symbols.get_mut(name) {
            return symbol;
        }

        current = scope.parent;
    }

    panic!("Value not found: {}", name);
}

EDIT: More clarification

The error is

         pub fn get_mut(&mut self, name: &String) -> &mut Symbol {
   |                    - let's call the lifetime of this reference `'1`
...
90 |             scope = self.scopes.get_mut(id).unwrap();
   |                     ^^^^^^^^^^^ `self.scopes` was mutably borrowed here in the previous iteration of the loop
91 |             if let Some(symbol) = scope.symbols.get_mut(name) {
92 |                 return symbol;
   |                        ------ returning this value requires that `self.scopes` is borrowed for `'1`

The struct that self refers to is

pub struct SymbolTable {
    scopes : Vec<Scope>,
    current : usize,
}

with

struct Scope {
    parent : Option<usize>, 
    symbols : HashMap<String, Symbol>, 
}

The actual details of Symbol are not relevant to the question, it’s a simple enum.

What are the advantages of representing strings with an immutable data strucure?

A few good points i've read:

• Easier to compare (compare by pointer)
• Less expensive to copy
• String pool cuts down the use of memory

Other than that, most other arguments are about immutable objects in general, ie. thread safety, optimizations, easier to reason, etc

That said, i'm considering to represent strings internally with a Mutable data structure, essentially, the string type is an alias to []byte (dynamic size byte array or byte slice), and as such is completely mutable. And here is why:

• Fits better with the type system (specially with generics^(1)), since all operations on slices can be done with strings
• Less confusion on why you can mutate an item in a slice but not on a string
• Less runtime complexity

Additionally, since function parameters are immutable by default in my language, we can pass slices by reference, not needing a copy. If you need to mutate an argument, however, i'm still deciding, either you need to explicitly pass a pointer to the value you want to mutate or you must specify that particular parameter as mutable.

1 - There are 5 (and only 5) typeclasses in my language: anything -> comparable -> orderable -> numerical -> integer. Each typeclass has associated operators. User defined types are automatically assigned to this typeclasses if they can be ordered, compared, etc. The language has an 'append' operator: a .. b appends b to the end of a, this operation is supported by both strings and slices. If strings are not slices, then i would need yet another typeclass to represent appendables. With strings being aliases, it's trivial to write generic algorythms that work in both slices and strings:

generic ReverseInPlace over T
    fn(list:&[]T) {
        var start = 0,
            end   = (@list).length;

        for start < end {
            val temp <- (@list)[start];
            (@list)[start] <- (@list)[end];
            (@list)[end] <- temp;

            start <- start + 1;
            end <- end - 1;
        }
    }

Edit: Thank you for all your input, after careful consideration, i decided to issue a compiler warning whenever string is indexed or mutated in place. That way the user will still be aware of string encodings but the type will fit well within the type system, without creating a special case. string is an

Can add cash to even things out if necessary. Would love an F Stop for the Context as I'm chasing that specific flavor of spring/trem combo.

All have their boxes, although the Context's is covered in tape.

A proposal related to stolen neuron control was defeated recently in an NNS vote. A large quantity of ICP locked in an 8 year neuron was stolen in an inside job. The original owner wanted the original seed phrase restored so he could regain control of the neuron. I voted against the proposal even though the evidence convinced me, because it would set a bad precedent. Only a systemic threat such as the Ethereum DAO hack warrants rolling back ownership, in my opinion. My question is: why does the NNS allow the seed phrase to be changed at all? This means that anyone who knows your II number and gets hold of your yubikey for even two minutes can lock you out of your account. I am wondering what the benefits of allowing seed phrase mutability are, which outweigh this drawback.

Hello, I'm having an issues implementing a data structure that requires a mutable borrow when being created, but then only holds immutable borrows in the leaves and Rust is thinking that the mutable borrow still exists. I've been using Rust for a bit now but I still can't fully understand how borrowing works.

The boiled-down version of the problem is the following:

// The struct should only have an immutable reference
struct Data<'a, T> {
    value: &'a T
} 

fn build<T>(val: &mut T) -> Data<T> {
    // some mutating operation on val here
    Data { value: val }
}

fn main() {
    let mut s = String::from("Some data");
    let data = build(&mut s);

    println!("{}", s); // cannot borrow `s` as immutable because it is also borrowed as mutable

    println!("{}", data.value);
}

The compiler responds with:

error[E0502]: cannot borrow `s` as immutable because it is also borrowed as mutable
  --> src/main.rs:14:20
   |
12 |     let data = build(&mut s);
   |                      ------ mutable borrow occurs here
13 | 
14 |     println!("{}", s);
   |                    ^ immutable borrow occurs here
15 | 
16 |     println!("{}", data.value);
   |                    ---------- mutable borrow later used here

error: aborting due to previous error

I'm wondering now, why can't Rust see that the data variable and the reference it has is immutable now? After build returns, all references to s should now be immutable, so another immutable borrow should be fine.

I've tried explicitly making sure I have an immutable borrow using:

fn build<T>(val: &mut T) -> Data<T> {
    // some mutating operation on val here
    let fixed: &T = val;
    Data { value: fixed }
}

or

fn build<T>(val: &mut T) -> Data<T> {
    // some mutating operation on val here
    Data { value: &*val }
}

But nothing seems to make the Rust compiler realize that s only has immutable borrows now.

Is there some way to let the Rust compiler explicitly know that data is completely immutable?

If I understand correctly, these basically perform the same core functions. Mixing, Inverting, Attenuating, and Offset. However, the 3MIA has those dual pots that the Shades doesn't.

Do they perform some function that the MI Shades can't? Or is it just a matter of patching differently?

I'm only a few months into my rack, this is still a bit of a head scratcher.

Hi.I'm pretty new to Rust, and I am working on my first proper project. I've used a TUI tutorial as my starting point as I want to have Terminal UI for the project (https://blog.logrocket.com/rust-and-tui-building-a-command-line-interface-in-rust/).

My problem comes from wanting to pass the return value of a function implemented on a struct and a variable from that same struct to another function. The function I'm trying to pass these values to is TUI's render_stateful_widget. I understand why this is happening, but it's not clear to me how it should be solved. Do I need to use Arc + Mutex to wrap the menu-field in App for example?
I'm getting this compile error from Cargo:

error[E0502]: cannot borrow `app.menu.state` as mutable because it is also borrowed as immutable
  --> src/app/ui.rs:50:55
   |
49 |     let body = app.menu.menu_as_list();
   |                -------- immutable borrow occurs here
50 |     rect.render_stateful_widget(body, body_chunks[0], &mut app.menu.state);
   |          ----------------------                       ^^^^^^^^^^^^^^^^^^^ mutable borrow occurs here
   |          |
   |          immutable borrow later used by call

The code causing the error is this:

let body = app.menu.menu_as_list();
rect.render_stateful_widget(body, body_chunks[0], &mut app.menu.state);

The App struct looks like this:

pub struct App {
    /// We could dispatch an IO event
    io_tx: tokio::sync::mpsc::Sender<IoEvent>,
    /// Contextual actions
    actions: Actions,
    /// State
    is_loading: bool,
    state: AppState,
    menu: Menu,
}

The Menu struct looks like this:

pub struct Menu {
    pub state: ListState,
    pub items: Vec<String>,
}

The menu_as_list function looks like this:

pub fn menu_as_list(&self) -> List {
        let menu_items: Vec<ListItem> = self.items.iter().map(|i|       ListItem::new(i.as_ref())).collect();
        List::new(menu_items)
            .block(Block::default().borders(Borders::ALL))
            .style(Style::default().fg(Color::White))
            .highlight_style(Style::default().add_modifier(Modifier::ITALIC))
            .highlight_symbol(">>")
    }

So Coils of the Hydra limits an AL force's infantry-choices to those that can infiltrate or take a transport. Does chosing infiltrate for Mutable Tactics mean any infantry unit with the Legiones Astartes rule now become a legal option, due to them having infiltrate?

Hey guys, I'm newer to the world of synthdiy. I have a couple successful eurorack kits under my belt and want to eventually get my skills build a Mutable Instruments Elements. However I have no experience with surface mount, and everything I've built so far has had fairly well documented build guides. I have no experience with mutable builds (although I found some through-hole Peaks and Braids pcbs that I'm tempted to put together.)

I guess my question is if I were to get the PCB printed, are there manufacturers that would pre-solder all the common SMT components at a good price? I'm confident I could figure out the rest, just a little spooked when it comes to surface mount stuff at my skill level.

My chart is filled with a lot of mutable signs. Specifically Virgo, Gemini and Pisces. And living with them has been absolute hell.

It's been hard trying to control my mind and body so I can settle down and finish up something. It's like I keep angering the folks around me, failing to complete the tasks they assign me due to said trait or goofing up on something because of my obliviousness. This could possibly be due to my Mercury being dominant in the chart, which is also housed to virgo in the 12th house, which I hear isn't a very good placement.

Also have a hard time controlling my mood swings. Everytime I felt sad and down, I would just stop working all together and just lay around for hours, even when I knew I had to get something done or didn't want to do that. As if I ever want to keep doing that. A lot of that could be traced back to my Pisces Moon, which is also housed to a lot of squares and oppositions.

And don't get me started on the self-hate, as if the things I said in this post didn't hint at that enough. This is definetly caused by my various Virgo signs (Mercury, Ascendant, and Jupiter to be exact), though some could argue it is also caused by my Chiron in Capricorn and 5th house as well. Hell if I know.

I also would be lying if I never said that I felt somewhat envious of people with Cardinal and Fixed signs, especially Cardinal. I dunno how they manage to get things done so efficiently meanwhile I fumble and jumble around in incompetency. But I won't harp on this longer, envying other people won't get me anywhere.

Sorry if this post sounds very self-absorbed or unprofessional. I'm just bot in a very good spot right now and need some serious help, mentally that is. You think you guys have any suggestions or ways on how to help me or "remedy" any of the stuff above? Feel free to type in your own personal experiences below as well.

Edit: Since you guys asked, here's a link to my chart. Though I left the images as "hidden" so I'm not sure if it'll show or not. If it doesn't, please let me know.

Aspects and Dominants: https://imgur.com/a/Kds1O6U

Positions: https://imgur.com/a/G654xTx

Shape: https://imgur.com/a/pDMQzmf

I've had a Korg Minilogue for a while and have done some research into other modular "rack" instruments such as Mutable Instruments. Is it possible to hook these modules to the Minilogue XD to achieve some sort of effect?

Consider the following program:

void Main()
{
    var cars = new List<string> { "Mondeo", "Astra" };
    var alice1 = new Person("Alice", cars.AsReadOnly());
    var alice2 = new Person("Alice", cars.AsReadOnly());

    Console.WriteLine(alice1.Equals(alice2));
}

public record Person(string Name, IReadOnlyList<string> Cars);

Because we are using records we would like that program to consider the records as being equal, and print `true`. However, it prints `false` because the two lists are not equal.

We have a few ways of working around this which I've detailed below - but is there a better approach than any of the ones I've mentioned? I feel like I'm missing an obvious, yet elegant, solution...?

1 Override equality

void Main()
{
    var cars = new List<string> { "Mondeo", "Astra" };
    var alice1 = new Person("Alice", cars.AsReadOnly());
    var alice2 = new Person("Alice", cars.AsReadOnly());
    
    Console.WriteLine(alice1.Equals(alice2));
}

public sealed record Person(string Name, IReadOnlyList<string> Cars)
{
    public bool Equals(Person? person)
    {
        if (person == null)
        {
            return false;
        }
        
        return person.Name == Name &&
               (person.Cars == Cars ||
               (person.Cars?.SequenceEqual(Cars) ?? false));
        
    }

    // Also need to override GetHashCode()
}

Main con here is the significant maintenance burden, and the ease of missing a property in the comparison.

We could mitigate this con by using Source Generators to automatically generate the `Equals` and `GetHashCode` implementations for us.

2 Create a special list class that handles the equality for us

void Main()
{
    var cars = new List<string> { "Mondeo", "Astra" };
    var alice1 = new Person("Alice", new RecordList<string>(cars.AsReadOnly()));
    var alice2 = new Person("Alice", new RecordList<string>(cars.AsReadOnly()));
    
    Console.WriteLine(alice1.Equals(alice2));
}

public sealed record Person(string Name, RecordList<string> Cars);

public class RecordList<T> : IReadOnlyList<T>
{
    private readonly IReadOnlyList<T> _list;
    public RecordList(IReadOnlyList<T> list)
    {
        _list = list;

I'm still a modular noob, and half of my rack is devoted to MI modules.

Yes, I know MI modules are popular for a reason: they do amazing things. I find that the more time I spend studying and getting to know each module, the more rewarding they become; they're full of beautiful little easter eggs and thoughtful things.

For example, I spent the weekend carefully learning how to construct envelopes with Stages, and discovered it had a color-blind mode. That is a game changer in usability for me. And then when I start digging deeper into the insanity of Beads, I discovered the hidden Plaits oscillator lurking inside... which is another wonderful gift. I'm just amazed by the company's ability to spark unexpected bits of joy.

So: thank you, Émilie!!

I tried to make the title succinct but i couldnt so sorry for the unstructured question!

Is there any significance for only the mutable signs to be co-ruled by the same planet and also square each other?

Pisces & sag - co-ruled by jupiter, square each other Virgo & gemini -co ruled by mercury, square each other

Is there a particular symbolism/mythology/significance?

Good time of day everyone.

I've been grappling with my gender for years now, I'm 24 and I'm still not 100% sure about it. But lately I've been considering that gender fluid might be more accurate.

(For context I'm AMAB, 300 lbs and can't be bothered to shave most days)

But when those thoughts came I was horrendously upset. All I could think was "how can I have multiple genders But only one body, no matter what my body is going to be wrong."

Like how can I feel like a woman if my face is boxy, wide and hairy, or if I fixed something than how could I feel masc again on the days that I am? I hardly take care of my appearance as it is, and now it feels like I'm trying to play make believe, as if I have the effort?

When I came to this realization I wished that I hadn't, and now I don't know what to do or how to cope, and it's not like my family will be of any help.

I know there are things that I can do but I don't know where to start.

To be fair I’m having to re-read the FM chapters a few times, but each time a clearer picture emerges. It’s not a giveaway , but then synthesis isn’t. The hard work pays off. Awesome stuff. Thank you Gordon Reid. You’re a legend!

I've just finished a very simple and easy to use library that allows you to get as man̸͖̓ÿ̸̹́ ̸̬̆m̸̝̆ụ̵͛t̵̩͠a̴̘͒b̵̢̒l̸͚̄ë̵̹́ ̷̼͑r̶̨̽ḙ̷̊f̵̼̎e̴̩̾r̵̡͘e̷͚͠ǹ̵̞ces as you need and solves all your so̷r̴r̷o̸w̶ ̷c̶h̴e̴c̶k̴e̴r̸ and thread/resource sharing p̴̙̲͐̂r̸̹̟͂̎ỏ̶̞̙̑b̵̟͐̄ḹ̵̤͠ę̴̭̓̂m̸̩͖̀̑s̷͙̆!

https://github.com/Eugeny/rust-sinner

Please try it and l̸e̶a̶v̴e̶ ̶y̸o̶u̷r̸ ̴f̴e̸e̶d̶b̵a̵c̸k̴ j̷̭͋u̸̪͑s̴̭͆t̶̞̽ ̵̘̏p̵͓͝ĺ̶͎e̵̫͗ạ̵̄s̷̠̿e̷͎͑ ̵͇͘d̴͕̅ǒ̵̼n̴̢̿'̸̂ͅt̶̥̄ ̸̞͗f̴̛̭̖͚̞͗́̈́͜e̶̝͑̅̈́͘͘ͅę̶̮̮̮̺̇̿̇̓ḑ̸̙̺͉͋ ̷̲͔̇̽̊͑͝ȉ̶͇̹̅̽t̸̡͗̇̍̐̒ ̸̠͓̖̥͊̿͐͜ḁ̷̽͆͘͘ ̷͔̱̹̂̆̾́̃s̴̺̦̲͇̃̏̚͘ṯ̸̫̆̈́̉͝r̸̢͖͇̒ä̶͇͎͙́͝y̷̝̋̈́̉̉ ̴̭̖̙̦̈͋̽͐̑p̵̻͍͗ͅo̷͉͈̰͖͘i̴̮̗͓̘̋̓͆ṋ̴̄͋̔t̷̯͙̬̦̰̿̑͗̌̈e̵͔̖̿r̴̥͙͙͗̃̀̋ p̴̡̛̱̤̭̮̺͎̝̟̩̲̾͋̉͆͛͗͑̉̊͝͝l̵̡͙͙̪̩̱̭̝̹̹͂̀̈͛͂̾̽̾͊ͅẽ̵̡̙̱͇̫̟͙͎̫̏̓ȃ̶͓̘̙̘͓̆s̵̮̪͂̔̑́̍̅ͅͅê̸̢̨͔͍̦̳̭̂̊́̈́̇͛͜͠ͅ ̷̤͖͇̄͛̒̾̋̇́͂̎o̴̧̮̠̠͍̺̥̺͆̓͗̒̓h̷̹̭̍ ̷̛̣̠͌̋͌̍̅͆́͊̄̿ģ̵͖͉͈͈͙͙͍̥̉͒̈̚ͅǫ̷͔̗͇̅̏̃͊̄̈̚d̵̤͓̺̳̯͕̖͚͍͕͎̈́̍̌̉̏̏ ̴̟̐̈̇̀̍͌͗͂̂͝Ì̸͇̯̼̞̳͙̘͍͇̮̅̀̅ ̶̠̞̮̟͍̙̗̰̈́̉̅͋͂͝͝c̶̠̩̋̌͜a̴͙͇̣̟̩̎͆͐̓͋̈͌̃̚n̴̥͍͔̏̈̓̌̅̈̾̐̊̎̒͂͠'̴̜̥̻͔̭̄̆̇̊̂͆͐̕͘͝͠t̸̮̝̲̻̙͒̓̓̆̌̅̈́͒̋̚͠ t̸̛̮͔̟̒̏̌̒̏̍͛̚a̶̢̫̞̳̝̠͒̎͂̍͋̆͑̓͘k̵̨̛̰̫̖̦̯̞̻̓̄̉̀̎̔̎́̀͊̾͝ȩ̸̢͍̦̲͇͇͕̟͙͚̘̼̬̙̑ ̷̢̢̱̱̗̱̖̙̱̹͎̬͂͋̑̃̑͜͝ͅi̴̛̟̲̙̘̹͔͍͕̠̪̱̖̒̈́̓̓͒̽̎̎̽̉̍̐̈̚ͅͅt̸̢͓̻̤͚̘̂͝ ̷̠̲̼̘̗́̍ạ̸̯̍̆̾ṋ̸̒̋͑̈́̓y̵̯͖̺̤̞͚͖̤͍͛̈̓ͅm̸̯̠̹̬͎̮̪̮̀̎͛̆̔̀̍̈́͌͌̓͘͝ȍ̸̢̢̬̻̫̗̟̞̫̟̙̼̠͕̰͙͑̆̏͋͗̓̚͜r̶̛̖̻̋̏͂͑̊̀̔̃͂̎̔͆̒̃̑e̴̛̻͌̊͋͝