diff --git a/doc/sphinx/book/administration.rst b/doc/sphinx/book/administration.rst
index afc9b747dccc898560ec89010bd2ba9bc34aac63..b48aed7b9174d1de0658b0778e1365747f4fa159 100644
--- a/doc/sphinx/book/administration.rst
+++ b/doc/sphinx/book/administration.rst
@@ -246,10 +246,10 @@ Explanatory notes about what tarantool displayed in the above example:
 With ``tarantoolctl`` one can say: "start an instance of the Tarantool server
 which runs a single user-written Lua program, allocating disk resources
 specifically for that program, via a standardized deployment method."
-If Tarantool was downloaded from source, then the script is in
-:file:`[tarantool]/extra/dist/tarantoolctl`. If Tarantool was installed with Debian or
-Red Hat installation packages, the script is renamed :program:`tarantoolctl`
-and is in :file:`/usr/bin/tarantoolctl`. The script handles such things as:
+If Tarantool was installed with Debian or
+Red Hat installation packages, the script is 
+in :file:`/usr/bin/tarantoolctl` or :file:`/usr/local/bin/tarantoolctl`.
+The script handles such things as:
 starting, stopping, rotating logs, logging in to the application's console,
 and checking status.
 
@@ -300,11 +300,11 @@ The settings in the above script are:
     add ":samp:`/{instance-name}.log`" to the name.
 
 ``username``
-    the user that runs the tarantool server. This is the operating-system
+    The user that runs the tarantool server. This is the operating-system
     user name rather than the Tarantool-client user name.
 
 ``instance_dir``
-    the directory where all applications for this host are stored. The user
+    The directory where all applications for this host are stored. The user
     who writes an application for :program:`tarantoolctl` must put the
     application's source code in this directory, or a symbolic link. For
     examples in this section the application name my_app will be used, and
@@ -320,11 +320,11 @@ operation is one of: start, stop, enter, logrotate, status, eval. Thus ...
 
 .. option:: start <application>
 
-    Starts application *<application>*
+    Start application *<application>*
 
 .. option:: stop <application>
 
-    Stops application
+    Stop application
 
 .. option:: enter <application>
 
@@ -336,7 +336,7 @@ operation is one of: start, stop, enter, logrotate, status, eval. Thus ...
 
 .. option:: status <application>
 
-    Check application's status status
+    Check application's status
 
 .. option:: eval <application> <scriptname>
 
@@ -388,6 +388,7 @@ can start a long-running application and monitor it.
 
 The assumptions are: the root password is known, the computer is only being used
 for tests, the Tarantool server is ready to run but is not currently running,
+tarantoolctl is installed along the user's path,
 and there currently is no directory named :file:`tarantool_test`.
 
 Create a directory named /tarantool_test:
@@ -396,37 +397,8 @@ Create a directory named /tarantool_test:
 
     $ sudo mkdir /tarantool_test
 
-Copy tarantoolctl to /tarantool_test. If you made a source
-download to ~/tarantool-1.6, then
-
-.. code-block:: console
-
-    $ sudo cp ~/tarantool-1.6/extra/dist/tarantoolctl /tarantool_test/tarantoolctl
-
-If the file was named tarantoolctl and placed on :file:`/usr/bin/tarantoolctl`, then
-
-.. code-block:: console
-
-    $ sudo cp /usr/bin/tarantoolctl /tarantool_test/tarantoolctl
-
-Check and possibly change the first line of :file:`code/tarantool_test/tarantoolctl`.
-Initially it says
-
-.. code-block:: bash
-
-    #!/usr/bin/env tarantool
-
-If that is not correct, edit tarantoolctl and change the line. For example,
-if the Tarantool server is actually on :file:`/home/user/tarantool-1.6/src/tarantool`,
-change the line to
-
-.. code-block:: bash
-
-    #!/usr/bin/env /home/user/tarantool-1.6/src/tarantool
-
-Save a copy of :file:`/etc/sysconfig/tarantool`, if it exists.
-
-Edit /etc/sysconfig/tarantool. It might be necessary to say sudo mkdir /etc/sysconfig first. Let the new file contents be:
+Edit /etc/sysconfig/tarantool. It might be necessary to
+say :codenormal:`sudo mkdir /etc/sysconfig` first. Let the new file contents be:
 
 .. code-block:: lua
 
@@ -463,7 +435,7 @@ Tell tarantoolctl to start the application ...
 .. code-block:: console
 
     $ cd /tarantool_test
-    $ sudo ./tarantoolctl start my_app
+    $ sudo tarantoolctl start my_app
 
 ... expect to see messages indicating that the instance has started. Then ...
 
@@ -471,11 +443,11 @@ Tell tarantoolctl to start the application ...
 
     $ ls -l /tarantool_test/my_app
 
-... expect to see the .snap file, .xlog file, and sophia directory. Then ...
+... expect to see the .snap file and the .xlog file. Then ...
 
 .. code-block:: console
 
-    $ less /tarantool_test/log/my_app.log
+    $ sudo less /tarantool_test/log/my_app.log
 
 ... expect to see the contents of my_app's log, including error messages, if any. Then ...
 
@@ -495,7 +467,7 @@ Stop. The only clean way to stop my_app is with tarantoolctl, thus:
 
 .. code-block:: console
 
-    $ sudo ./tarantoolctl stop my_app
+    $ sudo tarantoolctl stop my_app
 
 Clean up. Restore the original contents of :file:`/etc/sysconfig/tarantool`, and ...
 
diff --git a/doc/sphinx/book/app/c-lua_tutorial.rst b/doc/sphinx/book/app/c-lua_tutorial.rst
index d37c6059384ecfbbcf1ee7cd3294f5e97a8c583e..4ae508304dc6de2d15481d0471d3e1cde25a2f34 100644
--- a/doc/sphinx/book/app/c-lua_tutorial.rst
+++ b/doc/sphinx/book/app/c-lua_tutorial.rst
@@ -1,7 +1,14 @@
 -------------------------------------------------------------------------------
-                        Appendix C. Lua tutorial
+                        Appendix C. Lua tutorials
 -------------------------------------------------------------------------------
 
+There are three tutorials:
+:ref:`Insert one million tuples with a Lua stored procedure <tutorial-insert-one-million-tuples>`,
+:ref:`Sum a JSON field for all tuples <tutorial-sum-a-json-field>`,
+:ref:`Indexed pattern search <tutorial-indexed-pattern-search>`.
+
+.. _tutorial-insert-one-million-tuples:
+
 =====================================================================
        Insert one million tuples with a Lua stored procedure
 =====================================================================
@@ -469,6 +476,8 @@ What has also been shown is that inserting a million tuples took 37 seconds. The
 host computer was a Linux laptop. By changing :confval:`wal_mode <wal_mode>` to 'none' before
 running the test, one can reduce the elapsed time to 4 seconds.
 
+.. _tutorial-sum-a-json-field:
+
 =====================================================================
                   Sum a JSON field for all tuples
 =====================================================================
@@ -593,3 +602,244 @@ It works. We'll just leave, as exercises for future improvement, the possibility
 that the "hard coding" assumptions could be removed, that there might have to be
 an overflow check if some field values are huge, and that the function should
 contain a "yield" instruction if the count of tuples is huge.
+
+.. _tutorial-indexed-pattern-search:
+
+=====================================================================
+       Indexed Pattern Search
+=====================================================================
+
+Here is a generic function which takes a field identifier
+and a search pattern, and returns all tuples that match. |br|
+* The field must be the first field of a TREE index.
+If the engine is sophia, the field must be the only field of the index. |br|
+* The function will use `Lua pattern matching <http://www.lua.org/manual/5.2/manual.html#6.4.1>`_,
+which allows "magic characters" in regular expressions. |br|
+* The initial characters in the pattern, as far as the
+first magic character, will be used as an index search key.
+For each tuple that is found via the index, there will be
+a match of the whole pattern. |br|
+* To be :ref:`cooperative <cooperative_multitasking>`, the function should yield after every
+10 tuples, unless there is a reason to delay yielding. |br|
+With this function, we can take advantage of Tarantool's indexes
+for speed, and take advantage of Lua's pattern matching for flexibility.
+It does everything that an SQL "LIKE" search can do, and far more.
+
+Read the following Lua code to see how it works.
+The comments that begin with "SEE NOTE ..." refer to long
+explanations that follow the code.
+
+.. code-block:: tarantoolsession
+
+   function indexed_pattern_search(space_name, field_no, pattern)
+     -- SEE NOTE #1 "FIND AN APPROPRIATE INDEX"
+     if (box.space[space_name] == nil) then
+       print("Error: Failed to find the specified space")
+       return nil
+     end
+     local index_no = -1
+     for i=0,box.schema.INDEX_MAX,1 do
+       if (box.space[space_name].index[i] == nil) then break end
+       if (box.space[space_name].index[i].type == "TREE"
+           and box.space[space_name].index[i].parts[1].fieldno == field_no
+           and box.space[space_name].index[i].parts[1].type == "STR"
+           and (box.space[space_name].index[i].parts[2] == nil
+                or box.space[space_name].engine == "memtx")) then
+         index_no = i
+         break
+       end
+     end
+     if (index_no == -1) then
+       print("Error: Failed to find an appropriate index")
+       return nil
+     end
+     -- SEE NOTE #2 "DERIVE INDEX SEARCH KEY FROM PATTERN"
+     local index_search_key = ""
+     local index_search_key_length = 0
+     local last_character = ""
+     local c = ""
+     for i=1,string.len(pattern),1 do
+       c = string.sub(pattern, i, i)
+       if (last_character ~= "%") then
+         if (c == '^' or c == "$" or c == "(" or c == ")" or c == "."
+                      or c == "[" or c == "]" or c == "*" or c == "+"
+                      or c == "-" or c == "?") then
+           break
+         end
+         if (c == "%") then
+           c2 = string.sub(pattern, i + 1, i + 1)
+           if (string.match(c2, "%p") == nil) then break end
+           index_search_key = index_search_key .. c2
+         else
+           index_search_key = index_search_key .. c
+         end
+       end
+       last_character = c
+     end
+     index_search_key_length = string.len(index_search_key)
+     if (index_search_key_length < 3) then
+       print("Error: index search key " .. index_search_key .. " is too short")
+       return nil
+     end
+     -- SEE NOTE #3 "OUTER LOOP: INITIATE"
+     local result_set = {}
+     local number_of_tuples_in_result_set = 0
+     local previous_tuple_field = ""
+     while true do
+       local number_of_tuples_since_last_yield = 0
+       local is_time_for_a_yield = false
+       -- SEE NOTE #4 "INNER LOOP: ITERATOR"
+       for _,tuple in box.space[space_name].index[index_no]:
+       pairs(index_search_key,{iterator = box.index.GE}) do
+         -- SEE NOTE #5 "INNER LOOP: BREAK IF INDEX KEY IS TOO GREAT"
+         if (string.sub(tuple[field_no], 1, index_search_key_length)
+         > index_search_key) then
+           break
+         end
+         -- SEE NOTE #6 "INNER LOOP: BREAK AFTER EVERY 10 TUPLES -- MAYBE"
+         number_of_tuples_since_last_yield = number_of_tuples_since_last_yield + 1
+         if (number_of_tuples_since_last_yield >= 10
+             and tuple[field_no] ~= previous_tuple_field) then
+           index_search_key = tuple[field_no]
+           is_time_for_a_yield = true
+           break
+           end
+         previous_tuple_field = tuple[field_no]
+         -- SEE NOTE #7 "INNER LOOP: ADD TO RESULT SET IF PATTERN MATCHES"
+         if (string.match(tuple[field_no], pattern) ~= nil) then
+           number_of_tuples_in_result_set = number_of_tuples_in_result_set + 1
+           result_set[number_of_tuples_in_result_set] = tuple
+         end
+       end
+       -- SEE NOTE #8 "OUTER LOOP: BREAK, OR YIELD AND CONTINUE"
+       if (is_time_for_a_yield ~= true) then
+         break
+       end
+       require('fiber').yield()
+     end
+     return result_set
+   end
+
+NOTE #1 "FIND AN APPROPRIATE INDEX" |br|
+The caller has passed space_name (a string) and field_no (a number).
+The requirements are: |br|
+(a) index type must be "TREE" because for other index types
+(HASH, BITSET, RTREE) a search with iterator=GE
+will not return strings in order by string value; |br|
+(b) field_no must be the first index part; |br|
+(c) the field must contain strings, because for the other data type
+("NUM") pattern searches are not possible; |br|
+(d) if the index has more than one part then the space's engine
+must be "memtx", because for the other engine ("sophia")
+a search on only one part will cause an error
+"Index ... does not support partial keys". |br|
+If these requirements are not met by any index, then
+print an error message and return nil.
+
+NOTE #2 "DERIVE INDEX SEARCH KEY FROM PATTERN" |br|
+The caller has passed pattern (a string).
+The index search key will be
+the characters in the pattern as far as the first magic character.
+Lua's magic characters are % ^ $ ( ) . [ ] * + - ?.
+For example, if the pattern is "ABC.E", the period is a magic
+character and therefore the index search key will be "ABC".
+But there is a complication ... If we see "%" followed by a punctuation
+character, that punctuation character is "escaped" so
+remove the "%" when making the index search key. For example, if the
+pattern is "AB%$E", the dollar sign is escaped and therefore
+the index search key will be "AB$E".
+Finally there is a check that the index search key length
+must be at least three -- this is an arbitrary number, and in
+fact zero would be okay, but short index search keys will cause
+long search times.
+
+NOTE #3 -- "OUTER LOOP: INITIATE" |br|
+The function's job is to return a result set,
+just as box.space.select would. We will fill
+it within an outer loop that contains an inner
+loop. The outer loop's job is to execute the inner
+loop, and possibly yield, until the search ends.
+The inner loop's job is to find tuples via the index, and put
+them in the result set if they match the pattern.
+
+NOTE #4 "INNER LOOP: ITERATOR" |br|
+The for loop here is using pairs(), see the
+:ref:`explanation of what index iterators are <index-pairs>`. 
+Within the inner loop,
+there will be a local variable named "tuple" which contains
+the latest tuple found via the index search key.
+
+NOTE #5 "INNER LOOP: BREAK IF INDEX KEY IS TOO GREAT" |br|
+The iterator is GE (Greater or Equal), and we must be
+more specific: if the search index key has N characters,
+then the leftmost N characters of the result's index field
+must not be greater than the search index key. For example,
+if the search index key is 'ABC', then 'ABCDE' is
+a potential match, but 'ABD' is a signal that
+no more matches are possible.
+
+NOTE #6 "INNER LOOP: BREAK AFTER EVERY 10 TUPLES -- MAYBE" |br|
+This chunk of code is for cooperative multitasking.
+The number 10 is arbitrary, and usually a larger number would be okay.
+The simple rule would be "after checking 10 tuples, yield,
+and then resume the search (that is, do the inner loop again)
+starting after the last value that was found". However, if
+the index is non-unique or if there is more than one field
+in the index, then we might have duplicates -- for example
+{"ABC",1}, {"ABC", 2}, {"ABC", 3}" -- and it would be difficult
+to decide which "ABC" tuple to resume with. Therefore, if
+the result's index field is the same as the previous
+result's index field, there is no break.
+
+NOTE #7 "INNER LOOP: ADD TO RESULT SET IF PATTERN MATCHES" |br|
+Compare the result's index field to the entire pattern.
+For example, suppose that the caller passed pattern "ABC.E"
+and there is an indexed field containing "ABCDE".
+Therefore the initial index search key is "ABC".
+Therefore a tuple containing an indexed field with "ABCDE"
+will be found by the iterator, because "ABCDE" > "ABC".
+In that case string.match will return a value which is not nil.
+Therefore this tuple can be added to the result set.
+
+NOTE #8 "OUTER LOOP: BREAK, OR YIELD AND CONTINUE" |br|
+There are three conditions which will cause a break from
+the inner loop: (1) the for loop ends naturally because
+there are no more index keys which are greater than or
+equal to the index search key, (2) the index key is too
+great as described in NOTE #5, (3) it is time for a yield
+as described in NOTE #6. If condition (1) or condition (2)
+is true, then there is nothing more to do, the outer loop
+ends too. If and only if condition (3) is true, the
+outer loop must yield and then continue. If it does
+continue, then the inner loop -- the iterator search --
+will happen again with a new value for the index search key.
+
+EXAMPLE:
+
+Start tarantool, cut and paste the code for function indexed_pattern_search,
+and try the following: |br|
+:codebold:`box.space.t:drop()` |br|
+:codebold:`box.schema.space.create('t')` |br|
+:codebold:`box.space.t:create_index('primary',{})` |br|
+:codebold:`box.space.t:create_index('secondary',{unique=false,parts={2,'STR',3,'STR'}})` |br|
+:codebold:`box.space.t:insert{1,'A','a'}` |br|
+:codebold:`box.space.t:insert{2,'AB',''}` |br|
+:codebold:`box.space.t:insert{3,'ABC','a'}` |br|
+:codebold:`box.space.t:insert{4,'ABCD',''}` |br|
+:codebold:`box.space.t:insert{5,'ABCDE','a'}` |br|
+:codebold:`box.space.t:insert{6,'ABCDE',''}` |br|
+:codebold:`box.space.t:insert{7,'ABCDEF','a'}` |br|
+:codebold:`box.space.t:insert{8,'ABCDF',''}` |br|
+:codebold:`indexed_pattern_search("t", 2, "ABC.E.")` |br|
+The result will be: |br|
+:codenormal:`tarantool>` :codebold:`indexed_pattern_search("t", 2, "ABC.E.")` |br|
+:codenormal:`---` |br|
+:codenormal:`- - [7, 'ABCDEF', 'a']` |br|
+:codenormal:`...` |br|
+
+
+
+
+
+
+
diff --git a/doc/sphinx/book/box/box_index.rst b/doc/sphinx/book/box/box_index.rst
index e154e0ff0e556453205caeb1478a3655d4a6012c..d010e05f88a908577269768b28b4ca7759eeb473 100644
--- a/doc/sphinx/book/box/box_index.rst
+++ b/doc/sphinx/book/box/box_index.rst
@@ -56,6 +56,8 @@ API is a direct binding to corresponding methods of index objects of type
               type: TREE
             ...
 
+.. _index-pairs:
+
     .. method:: pairs(bitset-value | search-value, iterator-type)
 
         This method provides iteration support within an index.
@@ -79,6 +81,8 @@ API is a direct binding to corresponding methods of index objects of type
         to the yielded procedure, the data set could have changed significantly.
         Iteration, resumed after a yield point, does not preserve the read view,
         but continues with the new content of the database.
+        The tutorial :ref:`Indexed pattern search <tutorial-indexed-pattern-search>`
+        shows one way that iterators and yields can be used together.
 
         Parameters:
 
@@ -290,7 +294,7 @@ API is a direct binding to corresponding methods of index objects of type
             |                    |           | Tuples are returned in order: nearest neighbor first.   |
             +--------------------+-----------+---------------------------------------------------------+
 
-        **Example:**
+        **First Example of index pairs():**
 
         Default 'TREE' Index and ``pairs()`` function:
 
@@ -340,6 +344,36 @@ API is a direct binding to corresponding methods of index objects of type
             ---
             ...
 
+        **Second Example of index pairs():**
+
+        This Lua code finds all the tuples whose primary key values begin with 'XY'.
+        The assumptions include that there is a one-part primary-key
+        TREE index on the first field, which must be a string. The iterator loop ensures
+        that the search will return tuples where the first value
+        is greater than or equal to 'XY'. The conditional statement
+        within the loop ensures that the looping will stop when the
+        first two letters are not 'XY'. |br|
+        :codenormal:`for _,tuple in box.space.t.index.primary:pairs("XY",{iterator = "GE"}) do` |br|
+        |nbsp| |nbsp| :codenormal:`if (string.sub(tuple[1], 1, 2) ~= "XY") then break end` |br|
+        |nbsp| |nbsp| :codenormal:`print(tuple)` |br|
+        |nbsp| |nbsp| :codenormal:`end` |br|
+
+        **Third Example of index pairs():**
+
+        This Lua code finds all the tuples whose primary key values are
+        greater than or equal to 1000, and less than or equal to 1999
+        (this type of request is sometimes called a "range search" or a "between search").
+        The assumptions include that there is a one-part primary-key
+        TREE index on the first field, which must be a number. The iterator loop ensures
+        that the search will return tuples where the first value
+        is greater than or equal to 1000. The conditional statement
+        within the loop ensures that the looping will stop when the
+        first value is greater than 1999. |br|
+        :codenormal:`for _,tuple in box.space.t2.index.primary:pairs(1000,{iterator = "GE"}) do` |br|
+        |nbsp| |nbsp| :codenormal:`if (tuple[1] > 1999) then break end` |br|
+        |nbsp| |nbsp| :codenormal:`print(tuple)` |br|
+        |nbsp| |nbsp| :codenormal:`end` |br|
+
     .. _index_object_select:
 
     .. method:: select(key, options)
@@ -793,6 +827,44 @@ Lua functions `os.date()`_ and `string.sub()`_.
     - error: 'This tuple already has 3 fields'
     ...
 
+=================================================================
+              Example showing a user-defined iterator
+=================================================================
+
+Here is an example that shows how to build one's own iterator.
+The paged_iter function is an "iterator function", which will only be
+understood by programmers who have read the Lua
+manual section
+`Iterators and Closures <https://www.lua.org/pil/7.1.html>`_.
+It does paginated retrievals, that is, it returns 10
+tuples at a time from a table named "t", whose
+primary key was defined with :codenormal:`create_index('primary',{parts={1,'STR'}})`. |br|
+|nbsp| |nbsp| :codenormal:`function paged_iter(search_key, tuples_per_page)` |br|
+|nbsp| |nbsp| |nbsp| |nbsp| :codenormal:`local iterator_string = "GE"` |br|
+|nbsp| |nbsp| |nbsp| |nbsp| :codenormal:`return function ()` |br|
+|nbsp| |nbsp| |nbsp| |nbsp| :codenormal:`local page = box.space.t.index[0]:select(search_key,` |br|
+|nbsp| |nbsp| |nbsp| |nbsp| |nbsp| |nbsp| |nbsp| |nbsp| :codenormal:`{iterator = iterator_string, limit=tuples_per_page})` |br|
+|nbsp| |nbsp| |nbsp| |nbsp| :codenormal:`if #page == 0 then return nil end` |br|
+|nbsp| |nbsp| |nbsp| |nbsp| :codenormal:`search_key = page[#page][1]` |br|
+|nbsp| |nbsp| |nbsp| |nbsp| :codenormal:`iterator_string = "GT"` |br|
+|nbsp| |nbsp| |nbsp| |nbsp| :codenormal:`return page` |br|
+|nbsp| |nbsp| |nbsp| |nbsp| :codenormal:`end` |br|
+|nbsp| |nbsp| :codenormal:`end`
+
+Programmers who use paged_iter do not need to know
+why it works, they only need to know that, if they
+call it within a loop, they will get 10 tuples
+at a time until there are no more tuples. In this
+example the tuples are merely printed, a page at a time.
+But it should be simple to change the functionality,
+for example by yielding after each retrieval, or
+by breaking when the tuples fail to match some
+additional criteria. |br|
+|nbsp| |nbsp| :codenormal:`for page in paged_iter("X", 10) do` |br|
+|nbsp| |nbsp| |nbsp| |nbsp| :codenormal:`print("New Page. Number Of Tuples = " .. #page)` |br|
+|nbsp| |nbsp| |nbsp| |nbsp| :codenormal:`for i=1,#page,1 do print(page[i]) end` |br|
+|nbsp| |nbsp| :codenormal:`end`
+
 .. _RTREE:
 
 =============================================================================
diff --git a/doc/sphinx/book/box/index.rst b/doc/sphinx/book/box/index.rst
index c0f98f3772c8f9472d06668aa0e0f19b04b64802..fc7f697a49c39056b91dbe6a37c155150ea24154 100644
--- a/doc/sphinx/book/box/index.rst
+++ b/doc/sphinx/book/box/index.rst
@@ -206,7 +206,7 @@ The basic operations are: the five data-change operations
 (insert, update, upsert, delete, replace), and the data-retrieval
 operation (select). There are also minor operations like
 “ping” which can only be used with the binary protocol.
-Also, there are :func:`index iterator <index_object.pairs>` operations, which can only
+Also, there are :ref:`index iterator <index-pairs>` operations, which can only
 be used with Lua code. (Index iterators are for traversing
 indexes one key at a time, taking advantage of features
 that are specific to an index type, for example evaluating
diff --git a/doc/sphinx/reference/console.rst b/doc/sphinx/reference/console.rst
index 2b6169dc1e9071b441536bd783967ae61ed80d19..2325b4469c6ba8663f8ab7530fbb53d897e3f37a 100644
--- a/doc/sphinx/reference/console.rst
+++ b/doc/sphinx/reference/console.rst
@@ -115,23 +115,7 @@ host/port.
 
 .. function:: ac([true|false])
 
-   Set the auto-completion flag.
-   If auto-completion is `true`, and
-   the user is :ref:`using tarantool as a client <using-tarantool-as-a-client>`,
-   then hitting the TAB
-   key will have a special effect. Suppose that, so far,
-   the user has typed 'ap'. |br|
-   * If there is a single variable or function name
-   which begins with 'ap', such as 'apple', then auto-completion occurs,
-   the full name 'apple' appears on the screen. |br|
-   * If there are two variables or function names
-   which begin with 'ap', such as 'apple' and 'application',
-   then auto-completion occurs for the letters that are
-   in common, and the terminal beeps. |br|
-   * If there are no variables or function names
-   which begin with 'ap', then the terminal beeps.
-
+   Set the auto-completion flag. If auto-completion is `true`,
+   and the user is using tarantool as a client, then hitting
+   the TAB key may cause tarantool to complete a word automatically.
    The default auto-completion value is `true`.
-   When auto-completion is true, users can still put tabs
-   inside strings with the Lua escape sequence: \\t.
-