From 586dd5e1e24ef88db3c811945158949679332a1f Mon Sep 17 00:00:00 2001
From: Simeon Schaub <simeondavidschaub99@gmail.com>
Date: Tue, 14 Jul 2020 18:39:49 +0200
Subject: [PATCH] fix Markdown in README

---
 README.md | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/README.md b/README.md
index d875287b..e4344435 100644
--- a/README.md
+++ b/README.md
@@ -145,7 +145,7 @@ which is automatically converted to a Julia type, you will have override this
 via `@pywith EXPR::PyObject ...`.
 
 If you are already familiar with Python, it perhaps is easier to use
-``py`...``` and ````py```...``````` which are equivalent to Python's
+` py`...` ` and ` py```...``` ` which are equivalent to Python's
 [`eval`](https://docs.python.org/3/library/functions.html#eval) and
 [`exec`](https://docs.python.org/3/library/functions.html#exec),
 respectively:
@@ -162,7 +162,7 @@ py`sinpi`(1)
 
 When creating a Julia module, it is a useful pattern to define Python
 functions or classes in Julia's `__init__` and then use it in Julia
-function with ``py`...```.
+function with ` py`...` `.
 
 ````julia
 module MyModule
@@ -183,7 +183,7 @@ two(x) = py`one`(x) + py`one`(x)
 end
 ````
 
-Note that Python code in ``py`...``` of above example is evaluated in a
+Note that Python code in ` py`...` ` of above example is evaluated in a
 Python namespace dedicated to `MyModule`.  Thus, Python function `one`
 cannot be accessed outside `MyModule`.
 
@@ -355,38 +355,38 @@ and also by providing more type information to the Julia compiler.
   `@pycall function(args...)::returntype` into
   `pycall(function,returntype,args...)`.
 
-* ``py`...``` evaluates `"..."` as Python code, equivalent to
+* ` py`...` ` evaluates `"..."` as Python code, equivalent to
   Python's [`eval`](https://docs.python.org/3/library/functions.html#eval) function, and returns the result
-  converted to `PyAny`.  Alternatively, ``py`...`o`` returns the raw `PyObject`
+  converted to `PyAny`.  Alternatively, ` py`...`o ` returns the raw `PyObject`
   (which can then be manually converted if desired).   You can interpolate
   Julia variables and other expressions into the Python code with `$`,
   which interpolates the *value* (converted to `PyObject`) of the given
   expression---data is not passed as a string, so this is different from
-  ordinary Julia string interpolation.  e.g. ``py`sum($([1,2,3]))``` calls the
+  ordinary Julia string interpolation.  e.g. ` py`sum($([1,2,3]))` ` calls the
   Python `sum` function on the Julia array `[1,2,3]`, returning `6`.
   In contrast, if you use `$$` before the interpolated expression, then
   the value of the expression is inserted as a string into the Python code,
   allowing you to generate Python code itself via Julia expressions.
-  For example, if `x="1+1"` in Julia, then ``py`$x``` returns the string `"1+1"`,
-  but ``py`$$x``` returns `2`.
-  If you use ````py```...``````` to pass a *multi-line* string, the string can
+  For example, if `x="1+1"` in Julia, then ` py`$x` ` returns the string `"1+1"`,
+  but ` py`$$x` ` returns `2`.
+  If you use ` py```...``` ` to pass a *multi-line* string, the string can
   contain arbitrary Python code (not just a single expression) to be evaluated,
   but the return value is `nothing`; this is useful e.g. to define pure-Python
   functions, and is equivalent to Python's
   [`exec`](https://docs.python.org/3/library/functions.html#exec) function.
-  (If you define a Python global `g` in a multiline ````py```...```````
-  string, you can retrieve it in Julia by subsequently evaluating ``py`g```.)
+  (If you define a Python global `g` in a multiline ` py```...``` `
+  string, you can retrieve it in Julia by subsequently evaluating ` py`g` `.)
 
-  When ``py`...``` is used inside a Julia module, it uses a Python namespace
+  When ` py`...` ` is used inside a Julia module, it uses a Python namespace
   dedicated to this Julia module.  Thus, you can define Python function
-  using ````py```....``````` in your module without worrying about name clash
+  using ` py```....``` ` in your module without worrying about name clash
   with other Python code.  Note that Python functions _must_ be defined in
   `__init__`.  Side-effect in Python occurred at top-level Julia scope
   cannot be used at run-time for precompiled modules.
 
 * `pybuiltin(s)`: Look up `s` (a string or symbol) among the global Python
   builtins.  If `s` is a string it returns a `PyObject`, while if `s` is a
-  symbol it returns the builtin converted to `PyAny`.  (You can also use ``py`s```
+  symbol it returns the builtin converted to `PyAny`.  (You can also use ` py`s` `
   to look up builtins or other Python globas.)
 
 Occasionally, you may need to pass a keyword argument to Python that