@ Наборы также как и карты могут быть двух видов: хэш и упорядоченными. Наборы - только коллекции значений без какого бы то ни было ключа (мы можем думать о значении как о своего рода ключе самого себя). Таким образом, упорядоченный набор подобен карте где в качестве ключа используется собственное значение элемента. Вместе с обычными операциями вставки элементов в набор, поиска и так далее, есть также много операций на наборах в целом, которые не встречаются в других контейнерах - это свойственные только для наборов операции - объединение и пересечение.

@ Вот спецификация пакета упорядоченных наборов, где представлены только те средства, которые распространены у обоих видов наборов.

  1	generic
  2		type Element_Type is private;
  3		with function "<" (Left, Right : Element_Type) return Boolean is <>;
  4		with function "=" (Left, Right : Element_Type) return Boolean is <>;
  5	package Ada.Containers.Ordered_Sets is
  6		pragma Preelaborate (Ordered_Sets);
  7		function Equivalent_Elements (Left, Right : Element_Type) return Boolean;
  8		type Set is tagged private;
  9		pragma Preelaborable_Initialization (Set);
 10		type Cursor is private;
 11		pragma Preelaborable_Initialization (Cursor);
 12		Empty_Set : constant Set;
 13		No_Element : constant Cursor;

@ Единственное отличие от пакета карт (кроме идентификаторов) состоит в том, что нет никакого ключевого типа, функции "<" и "=" относятся к типу элемента (тогда как в случае карт, операция "<" относится к типу ключа). Таким образом, отношение упорядочения "<" определённое на элементах определяет эквивалентность между элементами, тогда как "=" определяет равенство.

@ Два элемента могут быть эквивалентными, но не обязательно при этом равными. Например, в случае строк мы могли бы решить, что упорядочение (и, таким образом, эквивалентность) игнорировало бы буквенный регистр, но равенство должно было бы принять во внимание этот факт. (Они могли также быть равными, но не эквивалентными, но это возможно менее вероятно). И как в случае пакета карт, операция равенства на элементах только пользуется функцией "=" для того, чтобы сравнить два набора.

@ Снова у нас есть обычные правила как и для карт. Таким образом, если X < Y является истиной тогда Y < X должно быть ложью; X < Y и Y < Z должен подразумевать X < Z; и X = Y и Y = X должно быть эквивалентно.

@ Для удобства пользователя функция Equivalent_Elements объявлена явно. Она выглядит выполняет примерно следующее:

  1	function Equivalent_Elements (Left, Right : Element_Type) return Boolean is
  2	begin
  3		return not (Left < Right) and not (Right < Left);
  4	end Equivalent_Elements;

@ Функция Equivalent_Elements соответствует формальному настроечному параметру с таким же именем в пакете хэш - наборов, который будет обсуждаться ниже. Это должно облегчить преобразование между двумя формами пакетов.

  1	function "=" (Left, Right : Set) return Boolean;
  2	function Equivalent_Sets (Left, Right : Set) return Boolean;
  3	function To_Set (New_Item : Element_Type) return Set;
  4	function Length (Container : Set) return Count_Type;
  5	function Is_Empty (Container : Set) return Boolean;
  6	procedure Clear (Container : in out Set);

@ Отметим добавление функций Equivalent_Sets и To_Set. Два набора эквивалентны если у них один и тот же ряд элементов и пары элементов эквивалентны. Это контрастирует с функцией "=" где пары элементов должны быть равными, а не эквивалентными. Помните, что элементы могут быть эквивалентны, но при этом не обязательно должны быть равными (как в примере упомянутой выше строки). Функция To_Set берет единственный элемент и создает набор. Она особенно удобна когда используется вместе с операциями, такими как Union, описывемыми ниже. Другие подпрограммы как в других контейнерах.

  1	function Element (Position : Cursor) return Element_Type;
  2	procedure Replace_Element
  3	(	Container : in out Set;
  4		Position  : in Cursor;
  5		New_Item  : in Element_Type);
  6	procedure Query_Element
  7	(	Position : in Cursor;
  8		Process  : not null access procedure (Element : in Element_Type));

@ Опять же они такие как и ожидается за исключением того что нет никакой процедуры Update_Element. Это потому что элементы упорядочены в терминах их собственного значения (в соответствии с установленным порядком или через хеш-функцию) и если мы только изменяем элемент на месте тогда это может стать неуместным (эта проблема не возникает с другими контейнерами). Это также означает, что Replace_Element должен гарантировать что значение New_Item не эквивалентно элементу в различной позиции; в этом случае возбуждается исключение Program_Error. Мы вернёмся к проблеме без вести пропавшей Update_Element позже.

  1	procedure Move (Target, Source : in out Set);

@ Производит такое же действие как и в других контейнерах.

  1	procedure Insert
  2	(	Container : in out Set;
  3		New_Item  : in Element_Type;
  4		Position  : out Cursor;
  5		Inserted  : out Boolean);
  6	procedure Insert
  7	(	Container : in out Set;
  8		New_Item  : in Element_Type);

@ Эти процедуры вставляют новый элемент в набор, если эквивалентный элемент ещё не существует. Если он действительно существует тогда первая возвращается с параметром Inserted установленным в False и параметром Position указывающим на элемент, тогда как вторая процедура поднимает исключение Constraint_Error (значение элемента при этом не изменяется). Если эквивалентный элемент не находится в наборе, тогда он добавляется и Position устанавливается соответственно.

  1	procedure Include (Container : in out Set; New_Item : in Element_Type);

@ Это несколько походит на последнюю процедуру Insert за исключением того, что если эквивалентный элемент уже находится в наборе тогда, он заменяется (вместо того, чтобы поднять исключение Constraint_Error).

  1	procedure Replace (Container : in out Set; New_Item : in Element_Type);

@ В этом случае Constraint_Error возбуждается, если эквивалентный элемент не существует.

  1	procedure Exclude (Container : in out Set; Item : in Element_Type);

@ Если элемент, эквивалентный Item уже находится в наборе, то он удаляется.

  1	procedure Delete (Container : in out Set; Item : in Element_Type);
  2	procedure Delete (Container : in out Set; Position : in out Cursor);

@ Они удаляют элемент. В первом случае, если нет такого элемента, возбуждается исключение Constraint_Error. Во втором случае, если курсор - No_Element, также имеет место Constraint_Error - есть также проверка для гарантии того что курсор определяет элемент в правильном наборе (напомним, что курсоры определяют и объект и контейнер); если эта проверка терпит неудачу, возбуждается исключение Program_Error.

@ И теперь некоторый новый материал, обычные операции набора.

  1	procedure Union (Target : in out Set; Source : in Set);
  2	function Union (Left, Right : Set) return Set;
  3	function "or" (Left, Right : Set) return Set renames Union;
  4	procedure Intersection (Target : in out Set; Source : in Set);
  5	function Intersection (Left, Right : Set) return Set;
  6	function "and" (Left, Right : Set) return Set renames Intersection;
  7	procedure Difference (Target : in out Set; Source : in Set);
  8	function Difference (Left, Right : Set) return Set;
  9	function "–" (Left, Right : Set) return Set renames Difference;
 10	procedure Symmetric_Difference (Target : in out Set; Source : in Set);
 11	function Symmetric_Difference (Left, Right : Set) return Set;
 12	function "xor" (Left, Right : Set) return Set renames Symmetric_Difference;

@ Они все делают точно, что можно было бы ожидать используяь отношение эквивалентности элементов.

  1	function Overlap (Left, Right : Set) return Boolean;
  2	function Is_Subset (Subset : Set; Of_Set : Set) return Boolean;

@ Они также самоочевидны.

  1	function First (Container : Set) return Cursor;
  2	function Last (Container : Set) return Cursor;
  3	function Next (Position : Cursor) return Cursor;
  4	procedure Next (Position : in out Cursor);
  5	function Find (Container : Set; Item : Element_Type) return Cursor;
  6	function Contains (Container : Set; Item : Element_Type) return Boolean;

@ Они должны быть самоочевидными и очень похожи на соответствующие операции карт. Снова в отличие от операций векторов и списков Find логически ищет целый набор, а не только начинающийся в некоторой точке (нет также никакого Reverse_Find). Кроме того, Find использует отношение эквивалентности основанное на параметре "<".

  1	function Has_Element (Position : Cursor) return Boolean;
  2	procedure Iterate
  3	(	Container : in Set;
  4		Process   : not null access procedure (Position : in Cursor));

@ Они такие же что и для других контейнеров.

@ Пакеты наборов включают внутренний настраиваемый пакет по имени Generic_Keys. Этот пакет позволяет некоторым операциям набора быть выполненными в терминах ключей, где ключ - функция элемента. Обратите внимание, что в случае карты, элемент определен в терминах ключа, тогда как здесь ситуация полностью изменена. Эквивалентные отношения определены для этих ключей также; они определены настраиваемым параметром "<" для упорядоченных наборов и Equivalent_Keys для хэш - наборов.

@ В случае упорядоченного набора формальные параметры следующие:

  1	generic
  2		type Key_Type (<>) is private;
  3		with function Key (Element : Element_Type) return Key_Type;
  4		with function "<" (Left, Right : Key_Type) return Boolean is <>;
  5	package Generic_Keys is

@ Следующее является общим для пакета Generic_Keys как для хэш так и для упорядоченных наборов.

  1	function Key (Position : Cursor) return Key_Type;
  2	function Element (Container : Set; Key : Key_Type) return Element_Type;
  3	procedure Replace
  4	(	Container : in out Set;
  5		Key       : in Key_Type;
  6		New_Item  : in Element_Type);
  7	procedure Exclude (Container : in out Set; Key : in Key_Type);
  8	procedure Delete (Container : in out Set; Key : in Key_Type);
  9	function Find (Container : Set; Key : Key_Type) return Cursor;
 10	function Contains (Container : Set; Key : Key_Type) return Boolean;
 11	procedure Update_Element_Preserving_Key
 12	(	Container : in out Set;
 13		Position  : in Cursor;
 14		Process   : not null access procedure (Element : in out Element_Type));

@ и в конце мы имеем:

  1	end Generic_Keys;
  2	private
  3		... -- not specified by the language
  4	end Ada.Containers.Ordered_Sets;

@ Ожидается, что большинство пользователей наборов будет использовать их прямым способом и что операции, определенные для наборов такие как Union и Intersection будут доминирующими.

@ Однако, наборы могут использоваться как вид карт экономического класса при использовании внутреннего пакета Generic_Keys.

@ Хотя это конечно не для новичка, мы покажем пример того как это можно использовать наборы вместо карт. Мы объявляем:

  1	type Part_Type is
  2		record
  3			Part_Number : Integer;
  4			Year        : Integer;
  5			Shelf       : Character range 'A' .. 'T';
  6			Stock       : Integer;
  7		end record;

@ Здесь мы поместили всю информацию в один тип.

@ Мы тогда объявляем "<" как обычно:

  1	function "<" (Left, Right : Part_Type) return Boolean is
  2	begin
  3		return Left.Part_Number < Right.Part_Number;
  4	end "<";

@ и затем иллюстрируем пакет таким образом:

  1	package Store_Sets is new Ordered_Sets (Element_Type => Part_Type);
  2	The_Store : Store_Sets.Set;

@ Мы использовали механизм заданный по умолчанию для настраиваемого параметра "<" на сей раз посредством иллюстрации.

@ В этом случае мы добавляем элементы к памяти следующим образом:

  1	The_Store.Insert ((34618, 1998, 'F', 25));
  2	The_Store.Insert ((27134, 2004, 'C', 45));
  3	...

@ Процедура для проверки стойки может теперь быть такой:

  1	procedure Request
  2	(	Part  : in Integer;
  3		Ok    : out Boolean;
  4		Year  : out Integer;
  5		Shelf : out Character)
  6	is
  7		C : Cursor;
  8		E : Part_Type;
  9	begin
 10		C := The_Store.Find ((Part, others => <>));
 11		if C = No_Element then
 12			Ok := False; return; -- no such item
 13		end if;
 14		E := Element (C);
 15		Year := E.Year;
 16		Shelf := E.Shelf;
 17		if E.Stock = 0 then
 18			Ok := False; return; -- out of stock
 19		end if;
 20		Replace_Element (C, (E.Part_Number, Year; Shelf, E.Stock–1));
 21		Ok := True;
 22	end Request;

@ Хотя это и работает, но не совсем удовлетворительно. С одной стороны, мы должны были вставить фиктивные компоненты в вызове Find (используя <>), кроме того, мы должны были заменить весь элемент, хотя мы только хотели обновить Stock компонент. Кроме того, мы не можем использовать Update_Element, потому что он не определен для наборов вообще. Напомним, что это могло бы нарушить порядок элементов; но в данном случае это не было бы проблемой, потому что мы не хотим менять числовой код запчасти.

@ Лучший подход должен использовать числовой код запчасти как ключ. Мы определяем:

  1	type Part_Key is new Integer;
  2	function Part_No (P : Part_Type) return Part_Key is
  3	begin
  4		return Part_Key (P.Part_Number);
  5	end Part_No;

@ и тогда:

  1	package Party is new Generic_Keys (Key_Type => Part_Key, Key => Part_No);
  2	use Party;

@ Отметим, что мы не должны определять функцию "<" для типа Part_Key вообще, потому что она уже существует, так как Part_Key - целочисленный тип. И реализация использует соответствующую функцию по умолчанию.

@ И теперь мы можем перезаписать процедуру Request следующим образом:

  1	procedure Request
  2	(	Part  : in Part_Key;
  3		Ok    : out Boolean;
  4		Year  : out Integer;
  5		Shelf : out Character)
  6	is
  7		C : Cursor;
  8		E : Part_Type;
  9	begin
 10		C := Find (The_Store, Part);
 11		if C = No_Element then
 12			Ok := False; return; -- no such item
 13		end if;
 14		E := Element (C);
 15		Year := E.Year; Shelf := E.Shelf;
 16		if E.Stock = 0 then
 17			Ok := False; return; -- out of stock
 18		end if;
 19		-- we are now going to update the stock level
 20		declare
 21			procedure Do_It (E: in out Part_Type) is
 22			begin
 23				E.Stock := E.Stock – 1;
 24			end Do_It;
 25		begin
 26			Update_Element_Preserving_Key (The_Store, C, Do_It'Access);
 27		end;
 28		Ok := True;
 29	end Request;

@ Это кажется тяжелой работой, но имеет ряд преимуществ. Во-первых, вызов Find является более естественным и вовлекает только числовой код запчасти (ключ) - отметим, что это вызов функции Find в реализации Generic_Keys использует только числовой код запчасти. Во-вторых, это обновление вовлекает только изменяемый компонент. Мы упоминали ранее, что нет никакого Update_Element для наборов из-за опасности создания значения, которое было бы в неправильном месте. В случае длинно названного Update_Element_Preserving_Key также выполняется проверка для гарантии того что элемент находится действительно все еще в правильном месте (проверяется что ключ - всё ещё тот же самый); если это не так, то элемент удаляется и возбуждается исключение Program_Error.

@ Если пользователь пожелает воспользоваться пакетом Generic_Keys абсолютно жизненно важно, чтобы относительная операция и функция (Part_No), используемая для иллюстрации Generic_Keys, были совместимы с упорядочением, используемым для иллюстрации родительского пакета Containers.Ordered_Sets непосредственно. Если дело обстоит не так, тогда небо могло бы обрушиться.

@ Случайно, процедура для того, чтобы проверить стойку, которая ранее использовала пакет карт теперь становится:

  1	procedure Check_Stock (Low : in Integer) is
  2		procedure Check_It (C : in Cursor) is
  3		begin
  4			if Element (C).Stock < Low then
  5				-- print a message perhaps
  6				Put ("Low stock of part ");
  7				Put_Line (Element (C).Part_Number); -- changed
  8			end if;
  9		end Check_It;
 10	begin
 11		The_Store.Iterate (Check_It'Access);
 12	end Check_Stock;

@ Здесь единственное изменение состоит в том, что вызов Key в:

  1	Put_Line (Key (C).Part_Number);

@ заменен на Element. Небольшое отличие состоит в том, что мы можем избежать вызова Element дважды, объявляя константу E в Check_It таким образом:

  1	E : constant Part_Type := Element (C);

@ и затем написав E.Stock < Low и вызывая Put_Line с E.Part_Number.

@ Более важный момент состоит в том, что если мы проиллюстрировали внутренний пакет Generic_Keys как было проиллюстрировано выше, тогда мы можем оставить Check_It неизменной, чтобы вызвать Key. Но важно понять, что тогда мы вызываем функцию Key внутренней к реализации Generic_Keys (flippantly вызываемый абонент) а не от реализации родительского пакета упорядоченных наборов (Store_Sets), потому что у этого нет такой функции. Это показывает тесную близость между пакетами наборов и пакетами карт.

@ И наконец, есть пакет хэш наборов, у которого есть сильные общие черты c пакетом упорядоченных наборов и пакетом хэш - карт. Мы можем ввести его как хэш карту, давая различия с пакетом наборов, дополнительными средствами в каждом и воздействии на примере обработки числового кода запчасти.

@ Спецификация пакета хэш - наборов начинается:

  1	generic
  2		type Element_Type is private;
  3		with function Hash (Element : Element_Type) return Hash_Type;
  4		with function Equivalent_Elements (Left, Right : Element_Type) return Boolean;
  5		with function "=" (Left, Right : Element_Type) return Boolean is <>;
  6	package Ada.Containers.Hashed_Sets is
  7		pragma Preelaborate (Hashed_Sets);

@ Отличие от пакета упорядоченных наборов состоит в том, что появляется дополнительный настроечный параметр Hash, а параметр упорядочения "<" заменяется функцией Equivalent_Elements.

@ Так, если мы имеем:

  1	function Equivalent_Parts (Left, Right : Part_Type) return Boolean is
  2	begin
  3		return Left.Part_Number = Right.Part_Number;
  4	end Equivalent_Parts;
  5	function Part_Hash (P : Part_Type) return Hash_Type is
  6		M31 : constant := 2**31–1; -- a nice Mersenne prime
  7	begin
  8		return Hash_Type (P.Part_Number) * M31;
  9	end Part_Hash;

@ (которые очень похожи на пример хэш - карты, за исключением имени типа параметра), тогда мы можем иллюстрировать пакет хэш - наборов следующим образом:

  1	package Store_Sets is
  2		new Hashed_Sets
  3		(	Element_Type        => Part_Type,
  4			Hash                => Part_Hash,
  5			Equivalent_Elements => Equivalent_Parts);
  6	The_Store : Store_Sets.Set;

@ и затем остальная часть нашего примера будет как и прежде. Таким образом, это легко преобразовать из упорядоченного набора в хэш - набор и наоборот, конечно, это возможно только если мы используем средства обычные для их обоих.

@ Нужно также упомянуть, что у внутреннего пакета Generic_Keys для хэш - наборов есть следующие формальные параметры:

  1	generic
  2		type Key_Type (<>) is private;
  3		with function Key (Element : Element_Type) return Key_Type
  4		with function Hash (Key : Key_Type) return Hash_Type;
  5		with function Equivalent_Keys (Left, Right : Key_Type) return Boolean;
  6	package Generic_Keys is

@ Отличие от упорядоченных наборов состоит в добавлении функции Hash и замене оператора сравнения "<" на функцию Equivalent_Keys. (Кстати, пакет Generic_Keys для упорядоченных наборов также экспортирует функцию Equivalent_Keys для однородности с пакетом хэш - наборов). Хотя сам наш пример неизменен, мы действительно должны изменить реализацию Generic_Keys таким образом:

  1	type Part_Key is new Integer;
  2	function Part_No (P : Part_Type) return Part_Key is
  3	begin
  4		return Part_Key (P.Part_Number);
  5	end Part_No;
  6	function Part_Hash (P : Part_Key) return Hash_Type is
  7		M31 : constant := 2**31–1; -- a nice Mersenne prime
  8	begin
  9		return Hash_Type (P) * M31;
 10	end Part_Hash;
 11	function Equivalent_Parts (Left : Right : Part_Key) return Boolean is
 12	begin
 13		return Left = Right;
 14	end Equivalent_Parts;

@ и тогда:

  1	package Party is
  2		new Generic_Key
  3		(	Key_Type => Part_Key,
  4			Key      => Part_No;
  5			Hash     => Part_Hash
  6			Equivalent_Keys => Equivalent_Parts);
  7	use Party;

@ Хеш-функция подобна используемой с хэш - картами. Тип Part_Key и функция Part_No такая же что и у упорядоченных наборов. Мы действительно не должны объявлять функцию Equivalent_Parts, так как мы можем использовать "=" как фактический параметр для Equivalent_Keys.

@ Мы закончим обсуждение наборов кратко рассматривая дополнительные средства в двух пакетах наборов (и их внутренние настраиваемые пакеты ключей) так же как мы это делали для двух пакетов карт (обсуждение почти идентично).

@ У пакета упорядоченных наборов есть следующие дополнительные подпрограммы:

  1	procedure Delete_First (Container : in out Set);
  2	procedure Delete_Last (Container : in out Set);
  3	function First_Element (Container : Set) return Element_Type;
  4	function Last_Element (Container : Set) return Element_Type;
  5	function Previous (Position : Cursor) return Cursor;
  6	procedure Previous (Position : in out Cursor);
  7	function Floor (Container : Set; Item : Element_Type) return Cursor;
  8	function Ceiling (Container : Set; Item : Element_Type) return Cursor;
  9	function "<" (Left, Right : Cursor) return Boolean;
 10	function ">" (Left, Right : Cursor) return Boolean;
 11	function "<" (Left : Cursor; Right : Element_Type) return Boolean;
 12	function ">" (Left : Cursor; Right : Element_Type) return Boolean;
 13	function "<" (Left : Element_Type; Right : Cursor) return Boolean;
 14	function ">" (Left : Element_Type; Right : Cursor) return Boolean;
 15	procedure Reverse_Iterate (Container : in Set;
 16	Process : not null access procedure (Position : in Cursor));

@ Они снова в значительной степени самоочевидны. Функции Floor и Ceiling такие же что и для упорядоченных карт - Floor ищет последний элемент, который не больше чем Item, а Ceiling ищет первый элемент, который не меньше чем Item - все они возвращают No_Element, если такого элемента нет.

@ Функции "<" и ">" очень важны для упорядоченных наборов. Первая эквивалентна:

  1	function "<" (Left, Right : Cursor) return Boolean is
  2	begin
  3		return Element (Left) < Element (Right);
  4	end "<";

@ Есть общая философия, что контейнерные пакеты должны работать эффективно, даже если сами элементы являются очень большими - возможно даже другими контейнерами. Мы должны поэтому избегать копирования элементов. (Передача их как параметры не является никакой проблемой, так как они передаются по ссылке, если они окажутся большими структурами). Таким образом, в этом случае, встроенное сравнение ценно, потому что оно позволяет избегать копирования, которое произошло бы, если бы мы написали функцию самостоятельно с явными внутренними запросами функции Element.

@ С другой стороны, есть общее ожидание, что ключи будут маленькими и, таким образом, нет никакой соответствующей проблемы с копированием ключей. Таким образом, такие встроенные функции менее важны для карт чем для наборов, но их предоставляют для карт для однородности.

@ Следующее дополнение в пакете Generic_Keys для упорядоченных наборов:

  1	function Equivalent_Keys (Left, Right : Key_Type) return Boolean;

@ Это соответствует формальному настроечному параметру с токим же именем в пакете Generic_Keys для хэш - наборов упомянутых ранее.

  1	function Floor (Container : Set; Key : Key_Type) return Cursor;
  2	function Ceiling (Container : Set; Key : Key_Type) return Cursor;

@ Они эквивалентны аналогичным функциям родительского пакета за исключением того, что они используют формальный параметр "<" для Generic_Keys для поиска.

@ У хэш - наборов как и хэш - карт имеется средство для определения ёмкости как и у векторного пакета.

@ Таким образом мы имеем:

  1	procedure Reserve_Capacity (Container : in out Set; Capacity : in Count_Type);
  2	function Capacity (Container : Set) return Count_Type;

@ Поведение такое же как для векторов и хэш - карт. Мы не обязаны устанавливать ёмкость самостоятельно, так как она будет автоматически расширена по мере необходимости, но мы можем значительно улучшить производительность если мы установим ёмкость заранее. Обратите внимание, что Length (S) не может превысить Capacity (S).

@ Другие дополнительные подпрограммы для хэш - наборов:

  1	function Equivalent_Elements (Left, Right : Cursor) return Boolean;
  2	function Equivalent_Elements (Left : Cursor; Right : Element_Type) return Boolean;
  3	function Equivalent_Elements (Left : Element_Type; Right : Cursor) return Boolean;

@ Снова, они очень важны для наборов. Первая выполняет примерно следующее:

  1	function Equivalent_Elements (Left, Right : Cursor) return Boolean is
  2	begin
  3		return Equivalent_Elements (Element (Left), Element (Right));
  4	end Equivalent_Elements;

@ и еще раз мы видим, что встроенные функции могут избежать копирования типа Element, которое произошло бы, если бы мы написали функции самостоятельно.