with PLF_CPP20_SUPPORT enabled these issues occur:

1. insert() returns void (should be iterator)
2. insert() gives me other vague errors about not being able to find matching parameters, probably due to the iterator parameters that I don't fill in my code as that's not normally required.

I have to comment out PLF_CPP20_SUPPORT to make it compile.

@mattreecebentley Per https://help.github.com/articles/adding-a-license-to-a-repository/ , ifF you rename or duplicate (or perhaps quicker, commit directly from https://choosealicense.com/licenses/zlib/ ) your current license file to LICENSE or LICENSE.md, GitHub interface will pick it up, & show your repo license type in the header & searches that restrict to open-source licenses.

	plf::list<int> wow;
	wow.push_back(1);
	wow.push_back(7);
	wow.push_back(3);
	wow.push_back(5);
	wow.push_back(4);
	const auto size1 = wow.size(); //5

	wow.shrink_to_fit();
	const auto size2 = wow.size(); //0

	wow.resize(4);
	const auto size3 = wow.size(); //4

	wow.shrink_to_fit();
	const auto size4 = wow.size(); //0

As you can see, shrink_to_fit() is not behaving properly.

iterator unordered_find_single(const element_type &element_to_match) PLF_LIST_NOEXCEPT

~~I would expect this function to be marked const, if it [the function] cannot be marked const because of some internal (state?), the function should be declared const and the internal (state) mutable.~~

This function must be marked const.

Iterators were dereferenced and then extraneosly referenced again on return from emplace_back and emplace_front. This commit ommits the needless reference which caused code to not compile.

Calling splice() to move the last element to the end drops it

#include <iostream>
#include "plf_list.h"

void print(const plf::list<int>& list1)
{
  for (auto& elem : list1)
  {
    std::cout << elem << ' ';
  }
  std::cout << std::endl;
}

int main()
{
  plf::list<int> list1 = { 1, 2, 3, 4, 5 };

  // Outputs "1 2 3 4 5 "
  print(list1);

  // This *should* be a no-op:
  list1.splice(list1.end(), std::prev(list1.end()));

  // Outputs "1 2 3 4"
  print(list1);

  return 0;
}

The standard specifies that the ranged version of erase should return the iterator following the last removed element. This should rectify that. I've also slightly modified the tests involving erase for this. Looks good on GCC, Clang and MSVC.

Hi I suspected the move semantics are not handled properly. We are using your project but it crashed when constructing a list with move constructor.

		list(list &&source) PLF_LIST_NOEXCEPT:
			element_allocator_type(source),
			groups(std::move(source.groups)),
			end_node(std::move(source.end_node)),
			last_endpoint(std::move(source.last_endpoint)),
			end_iterator(reinterpret_cast<node_pointer_type>(&end_node)),
			begin_iterator((source.begin_iterator.node_pointer == source.end_iterator.node_pointer) ? reinterpret_cast<node_pointer_type>(&end_node) : std::move(source.begin_iterator)),
			node_pointer_allocator_pair(source.node_pointer_allocator_pair.total_number_of_elements),
			node_allocator_pair(source.node_allocator_pair.number_of_erased_nodes)
		{
			end_node.previous->next = begin_iterator.node_pointer->previous = end_iterator.node_pointer;
			source.groups.blank();
			source.node_pointer_allocator_pair.total_number_of_elements = 0;
                        
                        source.reset();   // NEED to clean out source to avoid crash
		}

For parity with std::list, (at least in Visual Studio), the following should return a reference to the list_iterator, rather than a copy:

inline PLF_LIST_FORCE_INLINE list_iterator operator ++ () PLF_LIST_NOEXCEPT inline PLF_LIST_FORCE_INLINE list_iterator operator -- () PLF_LIST_NOEXCEPT inline list_iterator operator = (const list_iterator &rh) PLF_LIST_NOEXCEPT inline list_iterator operator = (const list_iterator &&rh) PLF_LIST_NOEXCEPT

inline PLF_LIST_FORCE_INLINE list_reverse_iterator operator ++ () PLF_LIST_NOEXCEPT inline PLF_LIST_FORCE_INLINE list_reverse_iterator operator -- () PLF_LIST_NOEXCEPT inline list_reverse_iterator operator = (const list_reverse_iterator &rh) PLF_LIST_NOEXCEPT inline list_reverse_iterator operator = (const list_reverse_iterator &&rh) PLF_LIST_NOEXCEPT

With std::list, I can use a functor with a non-const operator() when sorting. This can be helpful when the compare has to build some temporary data per item (like a display name), caching the value internally so that it doesn't have to build the display name every time that record is compared during the sort.

This can be fixed by adding a second, non-const operator() in sort_dereferencer with the same code as the const version. I am not sure this works on all compilers/platforms.

On Visual Studio 2017, I get the warning: warning C4458: declaration of 'end_node' hides class member

on this line: inline PLF_LIST_FORCE_INLINE void destroy_all_node_pointers(group_pointer_type const group_to_process, const node_pointer_type end_node) PLF_LIST_NOEXCEPT

If you rename end_node parameter, this warning goes away.