on 30-Dec-2023 (Sat)

You can use maps.Values from the golang.org/x/exp package.

Values returns the values of the map m. The values will be in an indeterminate order.

you’ll write a function that declares type parameters in addition to its ordinary function parameters. These type parameters make the function generic, enabling it to work with arguments of different types. You’ll call the function with type arguments and ordinary function arguments.

Each type parameter has a type constraint that acts as a kind of meta-type for the type parameter. Each type constraint specifies the permissible type arguments that calling code can use for the respective type parameter.

While a type parameter’s constraint typically represents a set of types, at compile time the type parameter stands for a single type – the type provided as a type argument by the calling code. If the type argument’s type isn’t allowed by the type parameter’s constraint, the code won’t compile.

Keep in mind that a type parameter must support all the operations the generic code is performing on it. For example, if your function’s code were to try to perform string operations (such as indexing) on a type parameter whose constraint included numeric types, the code wouldn’t compile.

You can omit type arguments in calling code when the Go compiler can infer the types you want to use. The compiler infers type arguments from the types of function arguments.

Note that this isn’t always possible. For example, if you needed to call a generic function that had no arguments, you would need to include the type arguments in the function call.

You declare a type constraint as an interface. The constraint allows any type implementing the interface. For example, if you declare a type constraint interface with three methods, then use it with a type parameter in a generic function, type arguments used to call the function must have all of those methods.

Constraint interfaces can also refer to specific types

declare a type constraint.

type Number interface { int64 | float64
}

The mamba-org organization hosts multiple Mamba flavors:

• mamba : a Python-based CLI conceived as a drop-in replacement for conda , offering higher speed and more reliable environment solutions

• micromamba : a pure C++-based CLI, self-contained in a single-file executable

• libmamba : a C++ library exposing low-level and high-level APIs on top of which both mamba and micromamba are built

We recommend that you start with the Miniforge distribution >= Miniforge3-22.3.1-0 . If you need an older version of Mamba, please use the Mambaforge distribution. Miniforge comes with the popular conda-forge channel preconfigured, but you can modify the configuration to use any channel you like.

After successful installation, you can use the mamba commands as described in mamba user guide .

Note

1. After installation, please make sure that you do not have the Anaconda default channels configured.

2. Do not install anything into the base environment as this might break your installation. See here for details.

For now, only micromamba provides shell completion on bash and zsh .

To activate it, it’s as simple as running:

 micromamba shell completion

In Unix-like platforms, installing a piece of software consists of placing files in subdirectories of an “installation prefix”:

• no file is placed outside of the installation prefix

• dependencies must be installed in the same prefix (or standard system prefixes with lower precedence)

Note

Examples on Unix: the root of the filesystem, the /usr/ and /usr/local/ directories.

An environment is just another name for a target prefix.

Mamba’s environments are similar to virtual environments as seen in Python’s virtualenv and similar software, but more powerful since Mamba also manages native dependencies and generalizes the virtual environment concept to many programming languages.

When downloading for the first time the index of packages for resolution of the environment, or the packages themselves, a cache is generated to speed up future operations:

• the index has a configurable time-to-live (TTL) during which it will be considered as valid

• the packages are preferentially hard-linked to the cache location

This cache is shared by all environments or target prefixes based on the same root prefix. Basically, that cache directory is a subdirectory located at $root_prefix/pkgs/ .

The root prefix also provide a convenient structure to store environments $root_prefix/envs/ , even if you are free to create an environment elsewhere.

The base environment is the environment located at the root prefix.

Note

You can’t create the base environment because it’s already part of the root prefix structure. Directly install in base instead.

Activation#

The activation of an environment makes all its contents available to your shell. It mainly adds target prefix subdirectories to your $PATH environment variable.

Note

activation implementation is platform dependent.

Deactivation#

The deactivation is the opposite operation of activation , removing from your shell what makes the environment content accessible.

You can create an environment with the name nameofmyenv by calling:

 mamba create - n nameofmyenv < list of packages > 

After this process has finished, you can _activate_ the virtual environment by calling mamba activate <nameofmyenv> . For example, to install JupyterLab from the conda-forge channel and then run it, you could use the following commands:

 mamba create - n myjlabenv jupyterlab - c conda - forge mamba activate myjlabenv # activate our environment jupyter lab # this will start up jupyter lab and open a browser 

Once an environment is activated, mamba install can be used to install further packages into the environment.

 mamba activate myjlabenv mamba install bqplot # now you can use bqplot in myjlabenv mamba install "matplotlib>=3.5.0" cartopy # now you installed matplotlib with 

Psycopg 2 is mostly implemented in C as a libpq wrapper, resulting in being both efficient and secure. It features client-side and server-side cursors, asynchronous communication and notifications , COPY support. Many Python types are supported out-of-the-box and adapted to matching PostgreSQL data types ; adaptation can be extended and customized thanks to a flexible objects adaptation system .

Psycopg 2 is both Unicode and Python 3 friendly.

For a quick way to dive into Anki, please have a look at these intro videos. Some were made with a previous Anki version, but the concepts are the same.

• Shared Decks and Review Basics

• Syncing

• Switching Card Order

• Styling Cards

• Typing in the Answer