Let's see how to handle Python `Dictionaries`. For now, you need to define a module that has a couple of functions. For now, we will call it `Dict`. You can use a signature or `mli` file if you want, but to keep it simple, we will leave it out for now.

Stick the following code in a file called `dict.ml`

Technically, that would be all you need, but it's not very easy to work with...you would have to create all your own `pyobjects` by hand. Yuck!

The next thing you need is to decide what kind of interface you want your `Dict.t` to have. By that I just mean that it would be nice to have a convenient way to get standard "dictionary-like" types into `Dict.t`. In this tutorial, we will look at three: an association list, and [Base's](https://ocaml.janestreet.com/ocaml-core/latest/doc/base/Base/index.html) `Map` and `Hashtbl`.

Of course, you may want to use something different, and that will work just fine after you see how to do it.

But first we should look at the Python code we are planning to bind.

def add(d, k, v):

d[k] = v

def get(d, k):

return d[k]

Just two functions to define a weird little map module: `add` and `get`, both of which take a `dictionary` as their first argument. The Python dictionary can have pretty much any types for keys and values, but we are going to use it as a `string => string` map. You should choose whatever types make sense for your particular use case.

Here are the value specs to bind these functions.

Now, let's generate our library code.

See that weird `NA` in the command? That's because you currently have to pass in a Python class name, even if you are binding module functions.

The generated OCaml module will be `Silly_map`. The other flags specify that we want to bind module associated code and not code associated with a class (`-a module`), and that we don't want to check the results of any converting code (`-r no_check`).

*Note: For more info on `pyml_bindgen` CLI args, see [here](http://localhost:8000/getting-started/#running-pyml_bindgen).

Here's what the generated code looks like:

Okay, now that we know a little more about the Python code and our desired interface for the `Silly_map` module, let's return to the `Dict` module and fill it out. Here's the whole thing. Jump down for some explanations.

`of_alist` and `to_alist` let us connect the `Dict` module with association lists.

The `Py.Dict.of_bindings_map` function takes two functions used to convert OCaml values to Python values, and the association list. In this case, we're passing in strings, so we use `Py.String.of_string` to convert an OCaml `string` to a `Pytypes.pyobject`. The `to_bindings_map` works in an analogous way.

*Note: For more info on writing pyml bindings, check out the [py.mli](https://github.com/thierry-martinez/pyml/blob/master/py.mli) signature file.*

Next, the `of/to_map` and `of/to_hashtbl` functions are pretty simple. Both `Map` and `Hashtbl` modules have a `of/to_alist` functions. So, we just call the function to convert to/from an association list, then call the matching `Dict.of/to_alist` function.

Finally, I threw in a printing function that uses [sexp_of](https://github.com/janestreet/ppx_sexp_conv) to convert the `alist` to a sexp, then print it.

Now we're ready to set up a Dune project and write a driver to run the generated code. Save these two files in the same directory in as the other files.

Run it like so:

If all goes well, you should see some zany output like this:

In this tutorial, we went over a couple of ways to handle Python Dictionaries. A lot of times, you will need to pass a dictionary to a Python function or return one from a Python function. Hopefully, you have a good idea of how to do this now!