return nil
}

// List represents a doubly linked list.
// The zero value for List is an empty list ready to use.
type List[T any] struct {
	root Element[T] // sentinel list element, only &root, root.prev, and root.next are used
	len  int        // current list length excluding (this) sentinel element
}

// Init initializes or clears list l.
func (l *List[T]) Init() *List[T] {
	l.root.next = &l.root
	l.root.prev = &l.root
	l.len = 0

Text.
 - List immediately after.
 - Another.

More text.

 - List after blank line.
 - Another.

Even more text.
 - List immediately after.

 - Blank line between items.

Yet more text.

 - Another list after blank line.

 - Blank line between items.

Still more text.
 - One list item.

   Multiple paragraphs.
-- dump --
Doc
	Paragraph
		Plain "Text."

        if (setter != null) {
            List<U> list = new ArrayList<>(getter.get());
            list.add(index, revMapper.apply(element));
            setter.accept(list);
        } else {
            getter.get().add(index, revMapper.apply(element));
        }
    }

    @Override
    public T remove(int index) {
        if (setter != null) {
            List<U> list = new ArrayList<>(getter.get());

        list.toArray(new String[0]) == ['foo', 'bar', 'baz'] as String[]
    }

    def "can check contents"() {
        when:
        mutate {
            add 'foo'
            add 'bar'
            add 'baz'
        }

        then:
        def list = registry.realize(collectionPath, collectionType)
        list.contains('foo')
        !list.contains('echo')
        list.containsAll(['foo', 'baz'])

import java.util.Collection;
import java.util.List;
import java.util.function.BiConsumer;

public interface JavaPropertyReflectionUtilTestMethods<T> {
    T simpleTypeVariable();

    List<T> encapsulatedTypeVariable();

    T[] arrayTypeWithTypeVariable();

    List<Collection<? extends List<? super T>>[]> complexTypeWithTypeVariable();

        LinkedList list = new LinkedList();

        list.add("one");
        list.add("two");
        assertTrue(list.remove("one"));

        assertEquals(1, list.size());
        assertEquals("two", list.get(0));

        assertTrue(list.remove("two"));
        assertEquals(0, list.size());
    }

    @Test public void testRemoveMissing() {
        LinkedList list = new LinkedList();

        list.add("one");

-- input --
Text.
  1. List
2. Not indented, not a list.
  3. Another list.

-- gofmt --
Text.
 1. List

2. Not indented, not a list.
 3. Another list.

-- text --
Text.
 1. List

2. Not indented, not a list.
 3. Another list.

-- markdown --
Text.

 1. List

2\. Not indented, not a list.

 3. Another list.

-- html --
<p>Text.
<ol>
<li>List
</ol>

			seg += "%fs:"
		}
		if haveGS {
			seg += "%gs:"
		}
		disp := ""
		if x.Disp != 0 {
			disp = fmt.Sprintf("%#x", x.Disp)
		}
		if x.Scale == 0 || x.Index == 0 && x.Scale == 1 && (x.Base == ESP || x.Base == RSP || x.Base == 0 && inst.Mode == 64) {
			if x.Base == 0 {
				return seg + disp
			}
			return fmt.Sprintf("%s%s(%s)", seg, disp, gccRegName[x.Base])
		}
		base := gccRegName[x.Base]
		if x.Base == 0 {

        when:
        list.remove(0)

        then:
        thrown(UnsupportedOperationException)
    }

    def "can filter list"() {
        given:
        def list = ImmutableFilteredList.allOf([1, 2, 3, 4, 5, 6])

        expect:
        list.matching(x -> x > 2) == [3, 4, 5, 6]
        list.matching(x -> x < 2) == [1]
        list.matching(x -> x > 2).matching(x -> x < 5) == [3, 4]

  public static <T extends @Nullable Object> List<List<T>> partition(List<T> list, int size) {
    checkNotNull(list);
    checkArgument(size > 0);
    return (list instanceof RandomAccess)
        ? new RandomAccessPartition<>(list, size)
        : new Partition<>(list, size);
  }

  private static class Partition<T extends @Nullable Object> extends AbstractList<List<T>> {
    final List<T> list;
    final int size;