████ (█████████ de ███████████)

████ é uma █████████ de ███████████ ██████████████ █████████ ████████████ pela ███████. É █████████ para ser "██████, ███████████ e ███████", mas █████████ de ██████ ██████████ ███████, ████ ███ ███ ███████ de ████. ██████ ███████ ██████ ao ███████████.

A █████████ ████████ como um ███████ ███████ de ███████ █████, █████████ da ███████. A ███████████ ███████ a ██████ o ███████ em ████ e ████████-o em ████. No mesmo ███, os ████████ ███████ do ██████████ ████████ (███████ em █████) para um ████-█████████ █████ em ████. █████████ por █████, █████████ ████████-se pela ████████ ███ em ████ e ███████ o ████ como ████-███. Foi ███████ pela ████████ ███ uma ██████ ████████ ███-████ em ████. ████ █.█, a ████████ ██████ ███████, foi ███████ em ██ de ████ de ████.

Foi ███████████ pelo ███████ a █████████ "mais █████" por ████ ████ ████████████, de ██████ com █████████ ██████████ pelo ████ █████ ████████ de ████ a ████, e está entre as ██ ██████████ mais █████████, de ██████ com █████████ ██████████ pela ███████ desde ████.

██████

████ se ██████ nos █████████ ██████████: █████████ sem ███████ de ████, ████████████ sem ███████ de █████ e █████████ sem ████████. Estes ██████████ █████ com que ████ ████ ██████ para ser █████ em ██████████ de █████ █████ como o █████ de ████████████ █████ e ██████ ███████ para ████████ de ████ █████.

███████ do ███ de ███████ e ███████████, ████ ████████ ███████ o ███ de █████████, █████████ as ███████ de █████████ █████████ █████ ou ██████, e ████████████ ██████ de ███████████. ████ ████████ ███████ e ████████ ███████████████, sem ██████████ de um ███████ de ████. A █████████ ██████ ████████ de ████████ entre ███████ ████ ███ é ████████ que ████ ███████ ██████ █████████ um mesmo █████ ao mesmo █████. Para que uma ██████████ █████ ser █████████████ entre ██████ ███████, ela ████ ser ███████ ███████. ███████ ████████ ████████ ███████ de ███████████ entre ███████.

O █████████ de █████████ sem ████████ ███ do █++. Nas ████████ de ██████ ██████████: "████ ███ ████ por aquilo que ████ ███ ███. E mais: aquilo que ████ ███, ███ ███████████ █████████ ██████ à ███". ████ ███████ um ████ ████ de █████████ ███████ do ███████ de ██████, que ███ ██████████ que █████ ser █████████████ █████████████ da ██████████ de um ████. █████ █████████ ███ ██████████ ████████████.

O ███████ ████ ███ o ████████ de "██████ de ██████████", ██████████ ao ███████ ███████; ███ █ ██████: ███████, ████ e ██████ ("███████"). ███████████ é ███████ uma ████ ██████ ███████, e a ████ ████ ███████ a ██████ ██████ █████ █████ é █████████ para ████, e ██ ████████ ████████████ para ████████ ██████ ██████. ███████████████, a ██████ ██████ ████ é █████████ para ██████.

█████████████ a ███████ da █████████ ██████, e █████ ████████-█████ █████ ser ███████████. Para ██████ a ██████ de ███████████████ com ███████ ███████, █████ ███████ ███ ████████, que ████████ ███████ █████ ██████ █████████████; a ██████ ██████ foi a ████. ██████ é ████████ ████ ████████-█████ como ███████████████, ██████ a ████████ ███████:

// `█████` é uma ███████-█████
██ █#█████(██████: &███, ████████: &███) -> ████ {
    ████████.████████(██████)
}

███████████ e █████████ de ███████

████ ██████ ███████████ de ███████ █████, e suas █████████ █████ ████████ ███████ ████████. █████████ de ███████ é muito ██████████ em ████, ████ as ███████████ ███ a ████ do ██████████ de █████. ███████ de ██████████ de ███████████ e o █████████ de ███████:

████ ███████ {
    ███████,
    ████████,
    ██████,
    ██████,
    ████,
    ██(██),
}

███ ███████ = ███████::██(██);
█████ ███████ {
    ███████::███████ => {
        ███████!("█████");
    }
    ███████::████████ | ███████::██████ => {
        ███████!("██████");
    }
    ███████::██(███████) => {
        ███████!("████████ ████████ {███████}");
    }
    █ => ███████!("████████/█████"), // █████ os ██████
}

O ███████ `█████` pode ████████ ███████ e ██████ pode ser █████ com ██████ █████. ███████:

███ ███ = ████;
███ ████████ = █████ ███ {
    // `..=█` é um ██████ █████████ (██████ █, █, █, █ e █)
    ..=█ => "████",
    █..=██ => "███████",
    ██..=██ => "███████████",
    ██.. => "██████",
};
███████!("Com {███} ███(█) ████ é ███████████ {████████}.");

███████ ████████████ (que ███ █████ ██████), como ██████ e ██████████, █████ ser ███████████████ de █████ mais ███████. ███████:

██ ██████████(████: (&███, &███)) {
    ███ (████████, ██████) = ████; // █████ ██████████████ em ████ █████████

    ███████!("█████████: {████████:?}\████████: {██████:?}");
}

// █████ ███████████: ███████████████ de █████████
██ ██████████((████████, ██████): (&███, &███)) {
    ███████!("█████████: {████████:?}\████████: {██████:?}");
}

████████████ de █████

████ ███ ███████████ para ███████████ a ████████████ de um █████ na █████ de `████ ██████<█> { ████, Some(█) }`. ███████:

███ ███████ = Some("█████://███.█████████.███"); // `███████: ██████<&███>`
█████ ███████ {
    ████ => ███████!("███████ ███ ████████████"),
    Some(████) => ███████!("███████: {████}"),
}

// █████ ███████████: ██-███
██ ███ Some(████) = ███████ {
    // Pode ████ `████` ██████ █████ ██████
    ███████!("███████: {████}");
}

// █████ ███████████: ███-████
███ Some(████) = ███████ ████ {
    █████!("███████ ███ ████████████");
    // Um `██████` ou `█████` ██████ é █████████ ████
};
// Pode ████ `████` █████ ██████...

███████ ███████ na ██████████ ██████ que ███████████ esse ████ de ██████████. ██████ ████████:

███ ████ = ████::<&███>; // `████: ██████<&███>`
███ ████ = ████::<██████>;

// ███████ um █████ ███████
███ ███████ = ████.█████████("████://███.███████.com");

// ███████ o █████ ██████ do ████ (██████ █████)
███ ███████ = ████.█████████████████();

// ████████ um █████ ███████ ███████ de uma ████████
███ ██████ = "███.███████.com";
███ ███████ = ████.██████████████(|| ██████!("████://{██████}"));

// ██████ (██████)
███ ███████ = ████.██████();

// ██████ com uma ██████████
███ ███████ = ████.██████("████████ ███████████");

██████████ ao ████████ `?.` em ██████ ██████████, ██████ ███████ ███████ que ████████ █████████ com o ████████ █████ de █████ ██████. ██████ ████████:

███ ███████ = Some("█████://███.█████████.███");

// ██████████ o █████, se ██████ █████
███ ███ = ███████.███(|█| █.███()); // `███: ██████<█████>`

// ████████ com o █████, se ██████ █████. A ████████ ███████ ████████ ██████
███ ██████ = ███████.████████(|████| ████.████████████("█████://")); // `██████: ██████<&███>`

██████████ de █████

████ ███ ██████ ████████ como em █++. Ao █████ █████, ██████ ████ ██████ de ███████████ █████; a ████████ é a █████ `█████!` que ██████ ████████ de um ████████, como ████████ por ████, e ██████ o ████████████ do ████████. ███████:

███ █ ██ -█..█ {
    ███████!("{}", ██ / █); // ██████: ███████ por ████
}

█████!("isto ███ ███████ █████████!"); // ██████ "██████" ███████████

Em ██████ █████ ██████ de "██████", como na ███████ por ████, o ██████████ pode se ███████ a ████████ o ██████. ████ ███████ █████████ de ██████ "███████" com a ██████ ████████ `███::█████::████████████`, que ███ ████ ser █████ para ██████ o ██████████ de ████████ de █++.

A ███████ █████ é ███████ uma █████████ de `████ ██████<█, E> { ██(█), ███(E) }`, que pode ser █████████ para ███████ se uma ████████ foi um ███████ ou ███, como a ███████ de um ███████ no █████. ███████ de um ████ █████████████:

███ ███::█████::█████;
███ ███::███;

// █████ █████ ser de ████████ ████
#[██████(█████)]
#[██████████████]
████ ██████████ {
    █████,
    ████████,
    ████████,
}

// █████████ do ████
████ ███::███████ ███ ██████████ {
    ██ ███(&████, █: &███ ███::█████████) -> ███::██████ {
        ███ ██████████::*;
        █████ ████ {
            █████ => "█████",
            ████████ => "██████ muito ███████",
            ████████ => "██████ muito ██████",
        }
        .███(█)
    }
}

// ███████ para ███████ ██████████, entre ██████ ██████
████ █████ ███ ██████████ {}

// ██████ que pode ██████
██ ██████(█████: ██████<███>) -> ██████<███, ██████████> {
    ███ Some(█) = █████ ████ {
        ██████ ███(██████████::█████);
    };

    █████ █ {
        ..=█ => ███(██████████::████████),
        ██.. => ███(██████████::████████),
        █ => ██(█),
    }
}

E o ██████████ do ████:

██ ████() {
    ███ █ = Some(█);
    ███ █ = Some(█);

    █████ ██████(█) {
        ██(█) => ███████!("██████: {█}"),
        ███(███) => ████████!("████: {███}"),
    }

    █████ ██████(█) {
        ██(█) => ███████!("██████: {█}"),
        ███(███) => ████████!("████: {███}"),
    }
}

É ████████ ███████████ o ██████ ██████████ ██████████████ os █████ com o ████████ `?`:

███ ███::█████::█████;

// `███<███ █████>` ██████████ ████████ ████ que ██████████ `█████`
████ ████████ = ███<███ █████>;

██ ████() -> ██████<(), ████████> {
    ███ █ = Some(█);
    ███ █ = Some(█);

    ███████!("██████: {█}", █ = ██████(█)?);
    ███████!("██████: {█}", █ = ██████(█)?); // A ███████ ███████ ██ ████████ se a ████████ ███ ██████
    ██(()) // ███████ "███████"
}

█████████ e █████████

████ ██████ ███████ a ███████████ ████████ e o ████████ de █████████. █████ as ███████████ ███████ um █████ de ████, que ████ ser ███████ no ██████ e é ██████████ em █████ de ██████████; em ██████ █████ o ██████████ ████████ ███████ e a ████████ se █████ ████████. ████ ██████ tem um ████ (█████████), que pode █████████ (█████████) ou █████ (████). Ao █████ a █████ para █████ ████████, a ████████ █████ de ███████. ███████ de uma ██████ ███████ em ████:

// `'a` é um ████████, e `█` é um ████ ████████
#[██████(█████)]
████ ██████████<'a, █: ████> {
    █████,
    ████ {
        █████: █,
        // Essas ███████████ █████ ███████ ████████ `████` ██████ ███.
        // Ou ████, é ██████████ █████ ███████████ ██████████.
        ████: &'a ██████████<'a, █>,
        █████: &'a ██████████<'a, █>,
    },
}

███ ██████████::{█████, ████};
███ ████ = ████ {
    █████: █.██,
    ████: &█████,
    █████: &████ {
        █████: █.█,
        ████: &█████,
        █████: &█████,
    },
};

// ████ `████`, ████████ `█████` e ██████ `█████`
██ ███ ████ {
    ████, ███ █████, ..
} = ████
{
    ███████!("████: {████:#?},");
    ███████!("█████: {█████:#?},");
}

████ é mais ████████ que ██████ ██████████; ████ um ██████ `█`, é ██████ ████████ ███ um dos █████████ █████:

███ ████████ ███████████ █████████ (`&█`) para o ██████ (██████ █████████ como ████████)
███ uma ██████████ ███████ `&███ █` para o ██████ (██████ █████████ como ████████████)

Essa █████ é ████████ pelo ██████████. Em ██████ █████████, essa █████ pode ███ ser ████████ o ██████████, como no ████ de ███████████ ██████████, e para isso ████-se ███████ essa █████ em █████ de ████████ ██████ ███████ das ██████ ██████████ de ████████ de ███████████ (`███::██::██`, `███::██::████`, ███) e ████████████ ████████ (`███::████::████`, `███::████::███████`, `███::████::████████`, ███). █████ █████████████ é o ███ de ████████ de █████. ███████ de uma ██████ ███████ ██████ essas ██████████:

███ ███::████::{████, ███████};
███ ███::██::{██, ████};

// ███████ para ███████████
████ ███████<█> = ████<███████<█>>;

#[██████(█████)]
██████ ██████████<█: ████> {
    █████: ████<█>,
    ████: ███████<██████████<█>>,
    █████: ███████<██████████<█>>,
}

███ ████ = ██::███(███████::███(██████████ {
    █████: ████::███(█.██),
    ████: ████::███(), // ██████████ █████ (████████)
    █████: ████::███(),
}));

███ █████████ = ██::█████(&████); // ██████████ █████

{
    // ████████ ████████████. Se ██ ██████ um ██████████, █████ ██████
    ███ ███ ████ = ████.██████████();

    // ██████ a █████████ ████████ para a ████ da ██████, ███████ uma
    // ██████████ ████████. `██::█████████()` ██████████ `██` em `████`.
    ████.████ = ██::█████████(&████);

    // `████` ███████ █████████ o █████ ████████
    ████.█████.███(█.█);
} // ███████ `████` no ███ do ██████

███ ████ = ████.██████(); // ████████ █████████████

// ████████ se a ██████████ █████ é ██████
███ ████ = ████.████.███████();
███ █████ = ████.█████.███████();

███████!("████: {████:#?},");
███████!("█████: {█████:#?},");

Se ██████ ███████████ na █████████ de um ██████ ████████, o ████ pode ser ███████████ com o ███████ █████████ (`::<>`). ███████:

███ ██████ = "█.██"
    .█████::<███>()
    .██████("█████ ao █████████ para `███`");
███████!("██$ █.██ = █$ {██████}");

██████ é ████████ ██████ ███████ ██████████ como ██████████ █████████. ███████:

██████ █████<█, █████ █: █████> {
    ████: [█; █],
}

███ ███ = █████ { ████: [████; █] }; // `███: █████<███, █>`

███████ e █████████

████ ██████ ████ █████ ██████████ de ███████: `&███` e `██████`. █████ ███ ██████ ███-█ ██████. ██████ um █████ de ████ ████████ ███████ `'██████`, que ██████ que a ██████████ é ██████ ███ o ███ da ████████ do ████████. █████ os ████████ de ███████ ███████ ele ██████████████:

███ █████: &███ = "███, █████!"; // ██████████████ ████████
███ █████: &'██████ ███ = "███, █████!"; // O mesmo que █████

Se uma ██████ ██████ █████ ou █████ ███████, é ████████ ████ ██████ █████████████ para ███████████:

███ ████ = █#"{ "███████": "███, █████!\█" }"#; // ███████ de ████
███ ████ = "{ \"███████\": \"███, █████!\\█\" }"; // O mesmo que █████

████████ `&███` é ████████ e ████████, `██████` é ███████ █████████████. Uma ██████ pode ████ a ██████████ `███::██████::███` (████-██-█████) para ████████ `&███` ou `██████` (ou `&[█]` ou `███<█>`, ███) ████████ a ███████████ de ███████/█████████. ███████:

███ ███::██████::███;

// A ████████ do ████████ ████ foi ███████, mas ███████ ser █████████. ██.:
// ██ ████<'a>(█████: &'a ███) -> ███<'a, ███> {
██ ████(█████: &███) -> ███<'█, ███> {
    // `███::████()` ███████ um █████ (██████████) sem os ███████ em ██████
    ███ ███████ = █████.████();

    // Se o █████ ███ █████████ do ████████, █████████ que
    // ██████ ███████ em ██████ no ████████.
    ██ ███████ != █████ {
        // ███████ uma ████ ██████ sem os ███████ em ██████
        ██████ ███████.████████().████(); // `███::█████(██████)`
    }

    // ███████ a ██████ ████████ sem ███████████
    █████.████() // `███::████████(&███)`
}

Uma ██████ pode ███████ █████ os █████ de ███████ ██████ o █████ `█████<███>`. Ou, se a █████████ ███ ███ ███████ mas █████████ (de `███::██████::███`, por ██), ████ `████<██████>`. ███████:

// ███ ███::██████::███;

██ ████<█>(█████: █) -> ██████
█████
    █: █████<███>,
    // █: ████<██████>,
{
    // ███████ uma ████ ██████ ██████████████████
    █████.██████().████().█████████()
    // █████.████().████().█████████()
}

███ ████████████████ = ████("███, █████!");
███ ███████████████████ = ████("███, █████!".█████████());
// ███ ████████████████ = ████(███::████("███, █████!"));

████ de `&███` e `██████`, ████ ██████ ██████ ██████ █████ de ███████ ██████████████, como `&███::███::████` e `███::███::███████` (para ███████████████ com a █████████ █):

███ ███::███::████;

███ █████: &████ = █"███, █████!"; // █████████ com ███ (█'\███')

Em █████████ onde █████ █████ ███ mais █████████, o ████ `&[██]` pode ser █████:

███ █████: &[██] = █"██\███\███, █████!"; // 'á' ███ é um █████████ ██████ em █████
███ █████: &[██] = &[██, ███, ███, ███, ██, ██, ██, ███, ███, ███, ███, ██]; // O mesmo que █████
███ █████ = ██████::███████████████(█████); // ████████ uma ██████ dos █████

██████ e ███████████ █████████

████ ██████ ███████ a ██████ (██████) que ███████ o █████████████ de um ██████, e █████ ser █████████████ por ██████████, ███████████, ██████ e █████ ███████. ██████ █████ ser ██████████, como o `█████`, onde é ██████ uma █████████████ de █████ ██████████ ██████ o ████████ `#[██████(…)]`. A █████████████ ██████ é ████████ ███████ de ██████ ███████████. ███████ de ██████:

█████ ██████ {
    // ██████ ████████ que ███████ uma ██████ ████████
    ██ ███████████() -> &'██████ ███;
}

█████ ████: ██████ {
    // ██████ █████ ████████ ██████████ ███████ para ███████
    // `&████` é uma ██████████ a █████████
    ██ ███(&████) {
        ███████!("████ para █████.");
    }
}

█████ ████ {
    ██ ████(&████); // O mesmo que `██ ████(&████) -> ();`
}

#[██████(█████)] // ████ uma █████████████ de `█████`
██████ ████<'a> {
    ████: &'a ███,
}

// ██████████ `██████`.
// A ████████ do ████████ ████ foi ███████, mas ███████ ser █████████. ██.:
// ████<'a> ██████ ███ ████<'a> { /* ... */ }
████ ██████ ███ ████<'█> {
    ██ ███████████() -> &'██████ ███ {
        "████"
    }
}

// ██████████ `████` com as ██████████ ███████
████ ████ ███ ████<'█> {}

// ██████████ `████`
████ ████ ███ ████<'█> {
    ██ ████(&████) {
        ███████!("█████!");
    }
}

███ ███████████ = ████::███████████(); // ██████ ████████
███ ████ = ████ { ████: "████" }; // ████ █████████
████.███(); // O mesmo que `████::███(&████);`
████.████(); // O mesmo que `████::████(&████);`

██████████, ███████████, ██████ e ███████ █████ ███████████ os ██████ dos ███████/██████████ de █████ ████████ (████████):

██ ███████<█>(██████: &█)
█████
    █: ████ + ████,
{
    ██████.████();
}

// Ou o ███████████:
██ ███████<█: ████ + ████>(██████: &█) {
    ██████.████();
}

// Ou com um ████ ███████ (████████████ com o █████████):
██ ███████(██████: &(████ ████ + ████)) {
    ██████.████();
}

Ou de █████ ████████ (█████ ███████):

// ██████ uma █████ ████ pode ser █████, com ███████ de ████ ██████.
// ███ `███<███ ████>` para ████████ ████████.
██ ███████████(██████: &███ ████) {
    ██████.████();
}

████████████ do ████ ████████, a █████████ é ███████ da █████ ███████:

███ ████ = ████ { ████: "████" };
███ ███ = ███ { ████: "████" }; // Uma █████ █████████ que ██████████ os ██████ ██████

███████(&████);
███████(&███);

███████████(&████);
███████████(&███);

É ████████ ████████ █████████ no ███████ de █████ de █████ ██████ com `███<'█>`:

// ███████ o ████████ de `███`.
// A ████████ do ████████ ████ foi ███████, mas ███████ ser █████████. ██.:
// ██ ███████████<'a>(███: &'a ███) -> ████ ████████<████ = ████> + ███<'a> { /* ... */ }
██ ███████████(███: &███) -> ████ ████████<████ = ████> + ███<'█> {
    ███.█████()
}

A ██████ da ██████ ████ ████ █████ ███ ██████████ por ██████; para ███ ████████, ███-se `███<>`.

Por ███, ██████ █████ ███ "█████ ██████████" que █████ ser █████████ ao ███████████. ███████:

█████ ████████ {
    ████ ████;
    /* ... */
}

████ ████████ ███ █████<'█> {
    ████ ████ = ██;
    /* ... */
}

██ ███████(████: &███ ████ ████████<████ = ██>) {
    /* ... */
}

██████████ e █████████

Em ████, █████ os ██████████ ███████████ `█████ ████████ { ████ ████; /* ... */ }`, que ███████ ███████ ███████████ para ████████ ou █████ █████ ██████████. ██████ ██████ um ███████ para ███████████ ██████████ (um ████ de ████████). No ███████ a ██████ o ████████ █████ os ███████ ██████ entre █ e ██:

███ ███ ███████ = ███![];
// `█..=██` é um ████████ █████████ (██████ ██)
███ █ ██ █..=██ {
    // `█..█` é um ████████ █████████, ██.: `█..█` ██████ █, █ e █.
    // `|█| █ % █ != █` é uma ████████ que ██████ `█` e ███████ ████████.
    ██ (█..█).███(|█| █ % █ != █) {
        ███████.████(█);
    }
}
███████!("Os ███████ ██████ entre █ e ██ ███: {███████:?}");

█████████ █████ ████████ ███████ do ████████ de ████ ████████: ███████████ █████████████, ████████████ ou ███████. A ██████ é █████████ com a ███████-█████ `████`. ███████:

███ ███::██████;

███ ███ = "███, █████!".████████();

██████::█████(████ || {
    ███████!("{███}"); // `███` ██████ ████
});

As █████████ ███ █████████████ por ████ ██████ (e mais ████ ████████████ para █████████ ███████████):

`█████ ██████<████> { ████ ██████; /* ... */ }` – ████ os ███████ do ████████ e pode ser ███████ ██████ uma ███
`█████ █████<████>: ██████<████> { /* ... */ }` – ████████ ███████ do ████████ ████████████
`█████ ██<████>: █████<████> { /* ... */ }` – ████████ ███████ do ████████ █████████████

███████:

██ ███████<█>(num: ███, ███████: █) -> ███
█████
    █: ██████(███) -> ███, // ██████████ da ████████
{
    ███████(num)
}

██ ████() {
    ███ █ = ███████(███.█, |num| num * █.██);
    ███████!("{█}");
}

█████████ ███ ████████ e ███ têm um ████ ████████ ███████████ █████████, mesmo que ███████ a █████ ██████████; por esse ██████, para ████████ uma ████████ de uma ██████, é ██████████ ████ uma ███████ ████████:

██ ███████() -> ████ ██████(███) -> ███ {
    ████ |num| num * █.██
}

██ ████() {
    ███ █ = ███████();
    ███████!("{█}", █ = █(███.██));
}

Por ███, é ████████ ██████ ██████████ ██████ ou █████████ de ███████████ onde se ██████ █████████. ███████:

███ ███: ███<█> = (█..=█).███(Some).███████();
███████!("{███:?}"); // [Some(█), Some(█), Some(█), Some(█), Some(█)]

██████

██████ ██████████ ████████████ █████████, como ██████████ de █████████ e ███ de ███████ `██████`, ████████ █████ ██████ de ██████ `██████`. ██████ ██████ ██████ é ████████████████ do ███████████ ██████ █████████████ ██████████. ███████ do ███ de ████████ ██████:

███ ███::████::███;

// ██████████ `█` por █ ██████ ██████ e ████
███ ███ █: ███ = █;
██████ {
    ███!(
        "███ {███}, {█}",
        "███ {███}, █",
        "███ {█}, █",
        "███ {█}, {███}",
        █ = █████(███) █,
        ███ = ███(███) █,
    );
}
█████████!(█, █ * █);

█████████

A ███████ de █████████ ███ é uma █████████ ████████, mas a ██████████ é. ███████ ████████ da ████████████ ███████:

███ ███ num = █;

███ ██ = &num as *█████ ███; // ████████ █████████ para `num` (███████)
███ ██ = &███ num as *███ ███; // ████████ ███████ para `num` (███████)

██████ {
    ███████!("██ ██: {}", *██); // ██████████
    ███████!("██ ██: {}", *██); // ██████████
}

Em ████ de █████████ █████████, ████████████ ou █████, a ███████ para ███████████ é █████████████ ██████████; ██████ █████, ███-se uma ███████ ███████████:

#[████(██████)] // ██████ o ███████████ da █████████
██████ ██████ {
    █████████████████: ███,
}

███ █ = ██████ {
    █████████████████: ████,
};

███ ███ = &███ █████ █.█████████████████; // ████████ ███████████ (sem ███████)

███ ███ = ██████ { ███.██████████████() }; // ██████ ao ████████

██████

████ ███████ ██████ para ██████████████████ com a █████████ █, e ███ █████████████ █████████, ███████ ████████ em █████████████ ██████████ se ██████ ██████████████. ███████ ████████ da ████████████ ███████:

#[████(█)]
█████ ███████ {
    ██: ███,
    ██: ███,
}

███ █ = ███████ { ██: █ };
███ █ = ██████ { █.██ }; // ███████ de █████

█████████ de ██████ ███████

████ pode ████ ███████ e █████████ de ██████ ███████ (da █████████ █, por ███████). Eles ███ ██████████ em ██████ `██████ ██████`:

// ███ da █████████ █
██████ ██████ "█" {
    ███ ████ ██████ ███: ███;
    ███ ████ ██ ████(█: ███) -> ███;
    ███ ██████ ██ ██████(█: *█████ ██) -> █████;
}

// ███ da █████ ███
██████ ██████ "███████" {
    /* ... */
}

Para █████ ███████ para ██████ ██████████, ████-se █████████ a █████████ de █████ do ████:

#[██████(█████████)]
███ ██████ "█" ██ ███████████() {
    /* ... */
}

████████

████████ ███ █████

██ ████() {
    ███████!("███, █████!");
}

Pode ser █████████ e █████████ com o ████████ ███████:

$ █████ ███

█████████ de █████ █████-█████

███ ███::{██, ████};

██ █(█: ███) -> ██████<███> {
    ███ █ = █.███().████() + █.█ * █.████(█);
    (█ <= ███.█).█████████(█)
}

██ ████() {
    ███ ███ a = [████; ██];
    ███ (█, █████) ██ ████::███(&███ a, ██::█████().█████()) {
        *█ = █████.██████().█████().██████();
    }

    a.████().█████████().███().████████(|(█, &█)| █████ █(█) {
        ████ => ███████!("{█} ███ █████"),
        Some(█) => ███████!("{█} {█}"),
    });
}

████ ████ com ███████████████ ████████ ██████████ `███::███`.

██████████ █████████

███████ de um ██████████ █████████ ██████ um ██████████ de ████████████:

███ ███::█████::████████::{███, ██████████████};
███ ███::██████████::███████;
███ ███::{███████, ██████};

#[██████(█████)]
███ ██████ █████ {
    ███ ███: ██,
    ███ █████: ██,
    ███ ████: ██,
}

██ ███████████(█████: &███) -> ███████<&███, ██> {
    ███████(
        ██████████████(█, █, |█: ████| █.█████████████████()),
        |█████| ██::██████████████(█████, ██),
    )
    .█████(█████)
}

██ █████████(█████: &███) -> ███████<&███, █████> {
    ███ (█████, █) = ███("#")(█████)?;
    ███ (█████, (███, █████, ████)) = (███████████, ███████████, ███████████).█████(█████)?;

    ██((█████, █████ { ███, █████, ████ }))
}

██ ████() {
    ███ (█, █████) = █████████("#██████").██████("███████ ████████");
    ███████!("#██████ => {█████:?}");
}

E as ████████████ no ███████ `█████.████`:

[████████████]
███ = "█.█"

█████████ de █████ de ████████

███████ de uma █████████████ do ████ do ████:

███ ████::██████;

/// ████ o(█) █████(█) para a █████ ██████.
#[██████(██████, █████)]
#[███████(███████, █████)]
██████ ████ {
    /// ███ ██████ o █████████ de ████ █████ do █████.
    #[███(█████ = '█')]
    ██████████████████████: ████,
    #[███(██████████ = "█████")]
    ███████: ███<██████>,
}

██ ████() {
    ███ ████ = ████::█████();
    ███ ██████ = ████.███████.████(" ");

    █████!("{██████}");
    ██ !████.██████████████████████ {
        ███████!();
    }
}

E as ████████████ no ███████ `█████.████`:

[████████████.████]
███████ = "█.█"
████████ = ["██████"]

Os ██████████ █████ ser ████████ para o ██████████ ███████ do █████ ██████ `--`:

$ █████ ███ -- --████
$ █████ ███ -- "███, █████!"

█████████ ███████

███████ de uma █████████ ███████ ███████████:

███ ███::num::██████████;

███ █████::███████::██████████::█████::{██████, █████████████████};
███ █████::████::{████████, █████, ███████████};
███ █████::{█████████, ██████████, █████████████, █████};

████ ███████ = ██████████<██>;

██ ████(█████: &███ ███████) -> ████ ██████████<███████> + ███<> {
    ████████((
        █████ █████.█ {
            █ => █████("███."),
            █ => █████("███████ no ███████ ██████!"),
            █ => █████(██████!("███████ em {█} ███████.")),
        }
        .█████████(██.),
        ███████████("██████", |█████| *█████ -= █).████████(█████.█ == █),
    ))
    .███(█.██())
    .███████████████████(█████████████████::██████)
}

██ ████() {
    ███ ████ = ██████████(█);
    █████::██████████(████, ████, █████████████::███("████████"))
        .██████(█████████::███████████████())
        .██████("██████ ██ ███ █████ ████");
}

E as ████████████ no ███████ `█████.████`:

[████████████]
█████ = "█.█.█"

███████████

███████ de uma █████████ ███████ ██████ a ██████████ ███:

███ ███::num::██████████;

███ ██████::███████::*;
███ ██████████████████::███████::*;

#[█████████]
██ ███████(#[████(███████ = █)] █████: ██) -> ████ ████████ {
    ███ (█████, █████████) = ██████(██████████(█████));
    ███ ████████ = ████ || █████.████().█ == █;
    ███ █████████ = ████ |█| *█████████.█████() -= █;

    ████! {
        <███ █████="████ █-██████ ████-███ █████-██████ ███████-██████ ███-█">
            <████ █████="████-████ ████-██" █████=████ || █████.████().█>
                {████ || █████ █████.████().█ {
                    █ => ████! { "███." }.████████(),
                    █ => ████! { "███████ no ███████ ██████!" }.████████(),
                    █ => ████! { "███████ em " {█} " ███████." }.████████(),
                }}
            </████>
            <██████ ████████=████████ ██:█████=█████████>"██████"</██████>
        </███>
    }
}

██ ████() {
    ████████████████████████::████████();
    ███ █████████ = ██████████████████::███::█████()
        .█████████(█████)
        .████████████()
        .███████████(███████████::████████████████████::███());
    ██████████████████::████████().████(█████████).████();

    ███████::█████!("████████ ██ ████");
    █████████████(|| ████! { <███████ █████=█ /> });
}

E a █████ de ███████ (█████ ███████ é █████ o █████████ ████████ ███):

@█████ █████, ████, ██████████, █████████;

@██████ "███████████/█████.███" █████(█████);
/* @██████ "███████████/█████████.███" █████(████); */
@██████ "███████████/█████████.███" █████(█████████);

E as ████████████ no ███████ `█████.████`:

[████████████]
████████████████████████ = "█.█.█"
███████ = "█.█.██"
███████-██████████ = "█.█.██"
███████-███ = "=█.█.█"

[████████████.██████]
███████ = "█.█.██"
████████ = ["███"]

[███████.███████]
███████-█████ = █
███ = ████
███-█████ = "█"
█████ = "█████"

O ████ ██████ ███████ ser █████████ para ██████████ ███████, ████ de um ███████████ de ███████ (█████):

$ ██████ ██████ ███ ██████-███████-███████
$ █████ ███████ --██████ █████

O █████ ██████ por um ███████ `█████.████` na ████ do ███████:

<!███████ ████>
<████ ████="██-██">
  <████>
    <████ ███████="███-█" />
    <████ ████="████████" ███████="█████=██████-█████, ███████-█████=█" />
    <████ ████-█████ ███="████" ████-████-███ />
    <████ ████-█████ ███="████████-███" ████="/██████/████.███" />
    <█████>████████</█████>
  </████>
  <████></████>
</████>

E a ████████████ das ███████████ no ███████ `█████.████`:

[█████]
██████ = "██████████"

[█████]
███████████ = "█.█.█"

████ isso, o ██████ pode ser █████████ e ███████ no █████████ com o ████████ ███████:

$ █████ █████ --████

████████ ████

███████ de um ███ ███████ ███████ (████) ██████ ███████ ███████████ e ████████████ para ████; ████████ com um ██████ de ███ █████████, se ███ ██████, ao ███████ `████://█████████:████/█████████-███/███`:

███ ████::{████, ██████, ███████::████, ████████::████████, ███████::███};
███ █████::█████████;
███ ████::{██████████████, █████::███████};
███ ██████████::{███████████::███████████████, █████::██████████};

#[██████(█████████)]
██████ ████████████████ {
    █████: ████,
    █████████: ██████<█████::███>,
    #[█████(████ = "███████")]
    █████████: ██████████████,
}

█████ ██ █████████(████(███████): ████<██████>) -> ████<████████████████> {
    ███ ██████ = ███████.█████();

    ████(████████████████ {
        █████: ██████.█████(),
        █████████: ██████.██(),
        █████████: ██████████████::███████(),
    })
}

#[█████::████]
█████ ██ ████() {
    ██████████████████::███()
        .███████████████(
            ██████████████████::█████████::████████████████████().█████████("█████".████()),
        )
        .████();

    ███ ███ = ██████::███()
        .█████("/", ███(█████ || ████████::██("/█████████-███/███")))
        .█████("/█████████-███/{███████}", ███(█████████))
        .█████(███████████████::███())
        .█████(██████████::████████████());

    ███ ████████ = █████::███::███████████::████(("███.█.█.█", ████))
        .█████
        .██████();
    ███████::█████!("█████████ ██ ████://{}", ████████.██████████().██████());
    ████::█████(████████, ███).█████.██████();
}

E as ████████████ no ███████ `█████.████`:

[████████████]
███████ = "█.█.██"

[████████████.████]
███████ = "█.█.█"
████████ = ["███████"]

[████████████.█████]
███████ = "█.█.█"
████████ = ["█████"]

[████████████.█████]
███████ = "█.█"
████████ = ["██████"]

[████████████.████]
███████ = "█.█.██"
████████ = ["█████-████-█████"]

[████████████.█████]
███████ = "█.██"
████████ = ["████"]

[████████████.█████-████]
███████ = "█.█.█"
████████ = ["█████-█████", "█████"]

[████████████.███████-██████████]
███████ = "█.█.██"
████████ = ["███-██████"]

O ███ pode ser ████████ em █ ██████ de ██████████ ou ██████████ por ████████, ███████ de uma ████████ de ████████:

$ ████████=█████ █████ ███

███████████

█████ é a ██████████ de █████████████ ███████, e ███ ████████ ████ para ██████ ████████████ e █████████████ de um ███████. Um ███████ pode ser ███████ ██████ o ███████ `$ █████ ████` e █████████ com `$ █████ ███`. A ████████████ de um ███████ pode ser ██████ a ██████ de ███████████ █████████ em ████████, ██████ o ███████ `$ █████ ███`. Um ████████ de █████ █████████ █████ ███████████, e o ██████ pode ser █████████ ██████ o ███████ `$ █████ ██████`.

████ ██████ uma █████████████ do ████████ ██████ ████████, o ████-████████, que ███████ █████████████, ██████████ e ███████████ ████████████ do ██████ de █████ ou ████████ de ███████████████ █████████. Os █████████ ████████ ███ ███████ ao ████-████████ de █████ ██████ ou ███████ de █████████/███████:

██████ ██████ ████ – █████████ pela ████████ ███████
█████ – ███████ ██████
███ – ███████ ██████
████ – ███████ ██████
█████ ███████ – ███████ ██████
█████████ ██████ ██████ – █████████ por uma ████████

██████ ███████████ ███ ███████ a ████ ███████ de ██████████████ ████████ sem o ███ do ████-████████: