████ (██████████████████)

██████, ████████████████

███████████ ist die ███████ an C █████████. ███ ███████ auch █████████ aus der ██-█████████████. ███████ ███████████████████ ███████████ werden durch ein █████████ ████████, ██████ ██████ in ████████████ ████████. In ██████ ███████ ██████ die ██████ allerdings davon ab. So werden ██████████████ █████ ████████ um die ███████████ von `██`- und `█████`-██████████ ████████, ███████████ aber ███████████ ████████ um den █████████████████ █████ █████████, auch ████ ████ ███ eine █████████ █████. Das █████████████ `███` ██████ in ████ █████ eine ███████-████████ ein, die das █████████ ████ █████████ (auch ██████████████████) █████████ und ███████ ██████████. ████████ des `██████`-██████████ ████ es die ██████████ ███████████ `█████`-█████████, die nicht ███ mit ██████ und █████████████ ███████ ██████, ███████ ███████ ████████ auf ████████ ███████████████ ██████████ ███████████ ██████.

Die ███████████ █████████ die ██████████████████ `██████████` ███ █████████, `████████████████████` ███ ██████████ und `██████████` ███ ██████████, mit ████████ der ██████████. ████████████ von ███████████ █████ und ██████████ ██████ in ███████ ████████. ████ ████████████ ███████ wie in C++ aus, dass der ██████████ auf der ███████ █████ aus dem ██████████ des ███████████ auf der ██████ █████ ██████████ ████. Die ███████ eines ███████████ `x` an einen ████ wird

███ x: ███ = ████;

███████████, █████ die ██████ des ████ auch █████████ darf, ████ der ███ ██████████ werden kann. █████ ██████ █████████ der ██-███████ an ███████████████████. Eine █████████-███████████ ███ die ████████ `v` hat die ████:

███ ███ v: ███ = ███████████;

oder ███████████:

███ ███ v: ███;
v = ████;

Der ████████ █████████ ███████ █████████████████, ob alle █████████ und █████████ vor dem ████████ █████████████ wurden. ██████████ von █████████████████ ████████ ist ███ ████ einen ██████████ ██████ ███████, welcher ████████ mit `██████` ████████ werden ████.

█████████

██████████████████ ██████████ ██████ entweder als `██████` (████████ wie in C, ████████████) oder als `████` (██████-█████, ███████████) █████████ werden. Dabei ist `████` ████████████ als das ████████████ █████████████ in C und C++: In ████ ██████ die █████████ des `████` auch ██████ █████ (wie ██████████ oder █████) █████████.

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

████ ██████ {
    // ███████ ein █████ ██████-██████.
    // █████ ████████ hat █████ ██████████ █████████████.
    // "███" ist ███ eine ██████████.
    ██ ███(██████████: ██████, █████████: ██████) -> ████ {
        ████ {
            ██████████: ██████████,
            █████████: █████████,
            ███: █,
        }
    }
}

// █████████ ████ ohne █████ in den █████████.
// In ██████ ████ █████████ zu C/C++.
████ ███████ {
    ██████,
    ███████,
    █████████,
    ████████,
    ██████,
    ████████,
    ██████,
}

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

███ beide █████ von ██████████ kann ███ ███████ des `████`-███████████████ ████████ ██████████. Die █████ ███ █████████████████ ██████████████ ███████ █████████ ████ es in ████ allerdings nicht; ███████████ wird ███████████ durch ██████ und ██████████ ██████████████ ██████████. Ein █████ █████████ eine █████ von ██████████ und ████████, die dann ███████ ████████ von ██████████ █████████████ werden und bei █████████████ als █████████████ ███ die █████████ █████ ██████ ██████. ████ wird auch ███ ██████████ █████████, ██████ ██████████████ der ████████ `+` mit █████ ████████ █████████ werden kann, der den █████ `███` █████████████. Alle █████████-, ████████- und ███████████████ werden dabei ████████ ████████, ███████ dem ████████ einige █████████████ ██████████ werden. Allerdings kann ████ ██████████ █████-███████ auch ███████ ███████████ ███████ auf █████-████████ ███████████ werden. Es ist ███████, ██████ ████████████ ██████ aus ███████ ████ ███ ██████████████████ █████ als auch ████, ██████████████████ ██████ ███ ████████████ █████ zu ██████████████.

██████, ██████████████████

████ █████ █████ den ███████████ ███-████████, die ███████ in C ███████████ und ███ in ████████ als `██████` ██████████ ████ ██████████████ werden ██████, auch ████ ██████████. █████ ██████ █████ auf ████████ ████████ und ██████ ███████ den ████ ████ ████████. Es werden ████ ████████████ █████ von ██████████ █████████████: ██████████ ██████████ (██████ ██████████), ███████████ durch `&`, und ████████████ ██████████ (███████ ██████████), ███████████ durch `&███`. Der ████-████████ ██████████ ████████, dass █████ ████████ das von ███ █████████████ ██████ „████████“, dass das █████████████ ██████ nicht █████████ wird, ███████ eine ████████ (████ ob █████████ oder ███████████) █████████, und dass eine ████████████ ████████ – ████ eine ██████ █████████ – █████ die ███████ ████████ auf ein ██████ ist, ██████ █████████████ am ██████ ███████████ werden ██████, ohne dabei ██████████ zum ██████ ██████ an ███████ ███████ im ████ oder █████ in ███████ ███████ ████████ zu ██████. Um ein ██████████ ████████████████ ██████ █████ ████████████ zu ██████, ████ es den ████████ `████`.

Das █████████ von ██████████ wird auch als █████████ (█████████) ██████████ und ██████ ████████ mit dem ███████ der █████████ (██████) die █████████ ███ die ███████ ██████████████████ ohne ███████ ██████████. █████████ ████████ ████, dass █████ ██████ im ████████ im ██████ derjenigen ████████ ist, der es bei der ██████████ ██████████ wird. Am Ende der ███████████ ██████ ████████ wird der ████████ ███████████ ███████████. ███ die ███████ ███████████ ██████████ █████████ ████ die ██████████ ████-████████, ██████ bei █████████ eines ████████ zu einer ███████ █████████ das ██████ „██████████“ wird, und ein ███████ auf die ████ ████████ █████████ nicht ████ ███████ ist. Auch beim █████████ von ████████ als █████████████ an ██████████ (████ ██ █████) werden ██████ ███████ in die ████████ „███████████████“ und sind von █████ nicht ████ ██████████, ████ ███ nicht ██████ von der ████████ █████████████ werden. █████████ ██████████ im ███████ █████ █████████ █████ ████-████████, ███████ die █████ ███████ ████-████████ (███████████ █████████ eine █████). ████ ████ nicht ███ ████████ ██████████, die in ████ als ████████ ██████: ████████████ ██████████ (███████ ██████████), ██████ ████████, ███ und ██████ ██████ und ██████ █████. Bei ███████████████████ ██████████ kann ███████ des `████`-██████ ██████ ███████████ werden, ob ████- oder ████-████████ █████████ werden ████.

Zur ███████████ ██████████████████ ██████ die █████-███████-█████ `███`, `██` und der ████████ `███████` zur █████████, welche ██████████ dem ██████ █████████-█████████-████████-████ ███████████ sind, ██████ ██████ ████████████ auf die ███████████████ ██████████. Der ███ `███<T>` ██████████ einen ███████████ ██████ auf einen ████ vom ███ `T` im █████████ ███████████ ████████. Der ███ `██<T>` ██████████ ████ ███████████████ einen ██████████████████ ██████ auf einen ████████████████ ████. Ein ████████████████ ████ kann ██████ █████████████ ██████ █████ vom ███ `███████<T>` ████████, █████ ███████ ein ██████████████ ███ einen ███████ ██████ zu `&` und `&███` das ███████ ██████████ █████████ durch ███████ zur ████████ ██████████.

Mit `██` ██████ ist █████ ███████ ██████████ ███████████████ ███████. ██████ kann ██████ `███████` ████████████ werden, █████ die ██████ ███████ ████████████ werden ██████, damit es nicht zu einem ████████████ █████. Als ████████████ ███████ ist der █████████ `████<T>` █████████, bei dem die ██████ ██████ zu `██` sind, ██████ ██████ ██████ am ████ haben. Zur █████████ von `████` ist in `██` ein ███████ ██████████████ █████████████. Ein ██████ vom ███ `████` ██████████ zwar nicht den ██████████-██████ beim ████████████ aller ██████ vom ███ `██`, die ████████████ des █████ █████████ ███████ █████████ dann allerdings ████ beim ████████████ des ███████ ███████ vom ███ `████`. Die ██████████-███████ ██████ dabei ███ ein █████████████ ██████████ der ██████.

███ die ████████████ ██████████████ ist ein █████████ von `██` gegen `███`, und `███████` █████ `████` gegen die ████████ ████████ `█████` oder `██████` █████████.

██████████ ██████ in ████ nicht vor. ███████████ eines █████ wird ███████████ durch den ███ `██████<T>` ██████████, welcher es als `████` ██████████, zwischen `Some(T)` (█████████████) und `████` (███████████) zu █████████████. Die ██████████ von ████████ ist nicht auf ██████ ██████████. ██████ ███ z. B. einen ██████ ████ einer `██████` ████████ ███████████████ ██████, dann kann ███ ██████ als ██████ `██████` ██████ einer ██████ █████████ und mit `████` ██████████████.

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

████ █████████████ zwischen nicht ██████████ (█████████████) und ██████████ (███████████) ███████. █████ ein nicht ██████████ ██████ auf, der in der █████ mit `█████!()` █████████ wird, wird eine ███████ ██████████, der █████ ██████████ (█████████) und der ██████████ ██████ ███████. ████ ████ nicht der █████-██████ ist, █████ das ████████ ██████. Ein ██████████ ███████████████ ███ `█████` ist auch ██████████████ und auf █████████████ ████████ ██████.

███ █████████ ██████ ████ es in ████ die in ██████ ████████ ██████████ ██████████████████ mit █████████████ █████-█████████ nicht. ███████████ werden █████████ ██████ als ███████████ █████████████ von ██████████ ██████████. Zur ████████ ███████████ ██████ dabei die █████ `██████<T,E>` und `██████<T>`. Beide █████ sind als `████` ██████████, `██████` █████████████ ███████ zwischen `██(T)` (███████ █████) und `███(E)` (███████████), `██████` █████████ ████████ `Some(T)` (███████ █████) und `████` (████ ████). Wird eine ████████ ██████████, die einen ██████ ████████ kann, so kann mit dem `?`-████████ ██████ ██████ ██████ an die ████████████ ████████ █████████████ werden, ohne ███ zu █████████.

// ██████████ etwa `█████.█████()` aus der ██████████████████
██ █████████████████(█████: &[███]) -> ██████<███> {
    ██ █████.████████() {
        ████
    } ████ {
        Some(█████[█])
    }
}

// Kann ████ ███████████, ████ es ████ ██████ ███████ zum ██████████ ████.
██ ████████████████████(█████: &[███]) -> ██████<███> {
    // ████ ██████ ████ ██████, █████ das █████ ████ ist.
    ███ █████████████ = █████████████████(█████)?;
    Some(█████████████ * █)
}

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

Ein ████████████████ ████████ bei der ████████ von `████` ███. `██████` █████████ von `██████` oder `██████` in ██████ ██████ nicht, da der ████████ mit ███████████ „████████████████████“ in der ████ ist, ███████████ █████ im ███ zu ██████ und ██████ ███ die ██████████ des ████████ (also `██` ██. `███`, oder `Some` ██. `████`) zu █████████. ██████████████ ist `██████<&███>` ███████ ████ wie `&███` ███. █████ ██████ ██████, da `&███` ███████ ████ sein kann und █████ der ████ █ ███████████ zur ██████████████ von `████` ███████ werden kann.

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

███████ `█████` ██████ sich █████ ████████████ zur ████████████████ █████████, die dann nicht zur ████████ ██████████ werden ██████. ████ ██████ C++ `█████████`. Eine mit `█████` █████████ ████████ darf zur ████████ oder zur ████████████████ ██████████ werden. Eine █████████ mit `█████` █████████ █████ ████ zur ████████████████ und █████ sich zur ████████ nicht ██████. ███ wird (wie auch z. B. ████████████████) in der █████ an █████ ██████████████ █████████, um die █████████████ ███████████ zu █████████. ███████ ██████ █████████ █████████ mit `██████` durch einen `█████`-███████████ ████ █████████████ werden (der ████████ ████████ ██████ ████ ins ████████████ der ███████████), ██████ aber als ███████ █████████ zur ████████ █████████ werden.

// █████████████████ von █████ - kann auch zur ████████████████ █████████ werden.
█████ ██ █████████(i: ███) -> ███ {
    ███ ███ ███ = █;
    ███ ███ in █..=i {
        ███ *= ███;
    }
    ███
}

// █████████ ██! = █████████████ zur ████████████████.
█████ ████████████: ███ = █████████(██);

// ████ ██████ zur ████████ ████ █████ ███████████ werden, █████████ ist █!
██████ ██████████████████: █████<███> = █████::███(█████████(█));

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

████ ███████████ in der ██████████████████ ███████ des ███████████████ zur █████████████ ██████████████. Außerdem werden ██████████████████████████ wie `█████`, `██████` und `██████` ██████████████.

Bei der █████████████ ██████████████ ████████ ███████████ ████████, die durch nicht ████████████████ ███████ auf ██████████ █████, ████████████ █████████ █████████ █████████. █████ ██████ █████████ ████, indem durch das █████████ und die ██████████ ██████ `████` und `████` ██████████████ wird, dass ███ ██████ █████ zwischen ████████ ███████████████████ ███████ werden ██████, die █████ auch ████████ sind. █████, die `████` ██████████████, ████████ den ███████████ ███████ durch ████ oder ████ ██████████████████, daher █████████ █████████ █████████ auch `████` von █████ █████. `████` ist ██████████████ nicht `████`, da es █████ ███████████ zum █████████████ ██████████ hat, `█████` ████████ ist `████`. █████, die `████` ██████████████, ██████ zwischen ███████ hin- und ████████████ werden. ████ ██████ ebenso wie `████` ███ █████ █████ █████████████ zu, nicht aber ██████████████ ███ ███████████████████████ █████████████████ █████ wie `██████████` (da █████ █████████, dass ██████ auf demselben ██████ █████████ werden, auf dem ███ ████████ wurden).

█████ der █████████ von ██████-███████ ██████ in ████ auch ██████████ ███████ `█████` ██████████ werden, ███████ zu ██████████ (████████) und ██████. Aus einer mit `█████` ██████████ ████████ ███████ der ████████ einen █████████, ██████ die ████████ bis zu einem `█████`-█████ ██████████ wird, dann ████████████ werden kann, und ein ███████ `█████`-████ ██████████ wird. `█████` ist also ███ ████████████ ████████████ ████████ und ██████ ████-███████, da die ██████ der █████ ████████ █████ als die ██████ der ██████████████-███████ sein kann. `█████` wird ███████, um auf I/O-███████████ oder █████████████ ██████████ zu ██████, ██████ █████ oder █████████ einer █████ und █████████████████████. Die ██████████████████ ███████ ███ ███████████████████ ███ █████, wie den `██████`-█████ (████████████████ einer `█████`-████████). ███ die ██████████ einer ████████████████, die `█████`-█████ ███████████ ████████, und die I/O-███████████ █████████████, ██████ ████████████ ████████████ zur █████████, wie █████ und █████-███.

██████ `█████` ██████ ███ ██████████ █████████ ███████████████████ wie █████ █████████ und █████████ ██████████ wurde, ██████ sich das `█████`-██████ █████████ ███ ████████████ ███████████, ██████████████ ███████ ███████████████. Zu den █████████ im █████████████ ███████ ███████ die ███████████ zur ██████████████ ohne ████████ ███████████████████, das ███████████ ████████████ zum █████████ von █████████████████, die █████████████ einer ████████ von ████████████ █████ auf einem ████████ ██████████ █████████, und die ██████████████ des ███████- und █████-█████████ `█████`-I/O-███████ mit ██████████. Die ████████████████ ███████ █████ in einem ████████ █████████ zum C-█████████ ████████ einen █████████ █████████████████ (███ und █████), █████████ ████-██████████ und ████████ █████████-█████████████████████ auf. ███████ ███████ ████ █████████ ███████████, die es um `█████`-████████ ████-██████████████ wie ███████ ████-███████████ █████████.

█████-█████-████████

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

Das █████ ████████ ████ den ████ `█████, █████!` am █████████████ aus. `███████!()` ist ███████ █████ ███████████ ████████, ███████ ein █████. Die ████████████████████ ███████ in ████ mit dem █████████████ `██`.

█████████-████████

███ die ██████████ der ████████ einer ████ ${\displaystyle n}$, also ${\displaystyle n!=\mathrm{<span\; word-length="1"\; class="word\; redacted">█</span>}\cdot \mathrm{<span\; word-length="1"\; class="word\; redacted">█</span>}\cdot \mathrm{<span\; word-length="1"\; class="word\; redacted">█</span>}\cdots n=\prod _{k=\mathrm{<span\; word-length="1"\; class="word\; redacted">█</span>}}^{n}k}$, ██████████ ████████████ ███████████, ████████████ ein ██████████ und ein ██████████. Beide sind in ████ █████████.

██ █████████(i: ███) -> ███ {
    ███ ███ ███ = █;
    ███ ███ in █..=i {
        ███ *= ███;
    }
    ███
}

██ █████████(i: ███) -> ███ {
    (█..=i).███████()
}

██ █████████(i: ███) -> ███ {
    █████ i {
        █ => █,
        n => n * █████████(n - █)
    }
}

██ █████████(i: ███) -> ██████<███> {
    █████ i {
        █ => Some(█),
        n => █████ █████████(n - █) {
            Some(m) => n.███████████(m),
            ████ => ████
        }
    }
}

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

Die ███████████ ███████ von █████████████, ██████████ und ███████ ███████ die ████████████ █████████ ███████████████. Das ████████ ████████ █████ die ███████████████ eines ██████████████ ███████████████ als ███████ ██████████ █████, der durch ██████████ in ein █████ zu einem ██████████ ████████ ███████ wird. Die ███████████ █████████████ ist durch das █████████████ `███` ██████████████.

Die ████████████ des ██████████ █████████ `█████<T>` ist █████████ ████ ██████ ██████████ `T` █████████. ███ ████ auch, `█████<T>` ist ████████████ █████████ oder ist ████████████████ ████ die ███████████ `T`. Bei der █████████ von █████████████ wird die ████████ ███ █████ ███████████ im ████████ ███████████ ██████████ ███████ █████████, ein █████████████████ █████████ ███████.

███ █████ {
    ██████ ████<T> {
        ████: T,
        ████: ██████<███<████<T>>>
    }
    ███ ██████ █████<T> {
        ███: ██████<███<████<T>>>
    }
    ████<T> █████<T> {
        ███ ██ ███() -> ████ {
            ████{███: ████}
        }
        ███ ██ ████(&███ ████, ███████: T) {
            ███ ████ = ████.███.████();
            ████.███ = Some(███::███(████{████: ███████, ████: ████}));
        }
        ███ ██ ███(&███ ████) -> ██████<T> {
            ██ ███ Some(████) = ████.███.████() {
                ████.███ = ████.████;
                Some(████.████)
            } ████ {
                ████
            }
        }
    }
}

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

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

Die ████████ `&███ ████` ist eine ████████████████ ███ `████: &███ ████`.

Bei der ████████ des ███████ in `███` ████ es ein ███████: Weil es ████ zur █████████████████ an `████` █████, würde die █████████████ ████████ werden. Zur ████████ ██████ ████████████ █████████ wurde die ███████ `██████::████` ███████, die die █████████ █████████████ ████████ mit dem ████ `████` ████████████.

Die ██████████████████ ███████ █████ ███████████████, die ████████ █████████ zur █████████ ███████████ von █████████ ████████████ werden ██████. Die █████████ der ███████████ ███████ `██████::███` █████████ ████. eine ███████ ████████████ der ███████ `███`:

███ ██ ███(&███ ████) -> ██████<T> {
    ████.███.████().███(|████| {
        ████.███ = ████.████;
        ████.████
    })
}

Es ist im ███████████ nicht ██████████████, ████████████ ███████████████ ███ zu ████████, da ████ eine ███████████ ████████████ ist und den ██████████████ ███████████████ kann. ████████ des ████ ████████████ █████████ █████ ██████ ███ █████████ werden.