package list

Import Path
	container/list (on go.dev)

Dependency Relation
	imports 0 packages, and imported by 3 packages

Involved Source Files

	  d list.go
		Package list implements a doubly linked list.
		
		To iterate over a list (where l is a *List):
		
			for e := l.Front(); e != nil; e = e.Next() {
				// do something with e.Value
			}
Code Examples

	
		package main
		
		import (
			"container/list"
			"fmt"
		)
		
		func main() {
			// Create a new list and put some numbers in it.
			l := list.New()
			e4 := l.PushBack(4)
			e1 := l.PushFront(1)
			l.InsertBefore(3, e4)
			l.InsertAfter(2, e1)
		
			// Iterate through list and print its contents.
			for e := l.Front(); e != nil; e = e.Next() {
				fmt.Println(e.Value)
			}
		
		}


Package-Level Type Names (total 2, both are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Element (struct)
		Element is an element of a linked list.

		Fields (total 4, in which 1 is exported)
			Value any
				The value stored with this element.

			/* 3 unexporteds ... *//* 3 unexporteds: */
			list *List
				The list to which this element belongs.

			next *Element
				Next and previous pointers in the doubly-linked list of elements.
				To simplify the implementation, internally a list l is implemented
				as a ring, such that &l.root is both the next element of the last
				list element (l.Back()) and the previous element of the first list
				element (l.Front()).

			prev *Element
				Next and previous pointers in the doubly-linked list of elements.
				To simplify the implementation, internally a list l is implemented
				as a ring, such that &l.root is both the next element of the last
				list element (l.Back()) and the previous element of the first list
				element (l.Front()).

		Methods (total 2, both are exported)
			(*Element) Next() *Element
				Next returns the next list element or nil.

			(*Element) Prev() *Element
				Prev returns the previous list element or nil.

		As Outputs Of (at least 10, in which 8 are exported)
			func (*Element).Next() *Element
			func (*Element).Prev() *Element
			func (*List).Back() *Element
			func (*List).Front() *Element
			func (*List).InsertAfter(v any, mark *Element) *Element
			func (*List).InsertBefore(v any, mark *Element) *Element
			func (*List).PushBack(v any) *Element
			func (*List).PushFront(v any) *Element
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func (*List).insert(e, at *Element) *Element
			func (*List).insertValue(v any, at *Element) *Element
		As Inputs Of (at least 11, in which 7 are exported)
			func (*List).InsertAfter(v any, mark *Element) *Element
			func (*List).InsertBefore(v any, mark *Element) *Element
			func (*List).MoveAfter(e, mark *Element)
			func (*List).MoveBefore(e, mark *Element)
			func (*List).MoveToBack(e *Element)
			func (*List).MoveToFront(e *Element)
			func (*List).Remove(e *Element) any
			/* 4+ unexporteds ... *//* 4+ unexporteds: */
			func (*List).insert(e, at *Element) *Element
			func (*List).insertValue(v any, at *Element) *Element
			func (*List).move(e, at *Element)
			func (*List).remove(e *Element)

	 type List (struct)
		List represents a doubly linked list.
		The zero value for List is an empty list ready to use.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			len int
				// current list length excluding (this) sentinel element

			root Element
				// sentinel list element, only &root, root.prev, and root.next are used

		Methods (total 20, in which 15 are exported)
			(*List) Back() *Element
				Back returns the last element of list l or nil if the list is empty.

			(*List) Front() *Element
				Front returns the first element of list l or nil if the list is empty.

			(*List) Init() *List
				Init initializes or clears list l.

			(*List) InsertAfter(v any, mark *Element) *Element
				InsertAfter inserts a new element e with value v immediately after mark and returns e.
				If mark is not an element of l, the list is not modified.
				The mark must not be nil.

			(*List) InsertBefore(v any, mark *Element) *Element
				InsertBefore inserts a new element e with value v immediately before mark and returns e.
				If mark is not an element of l, the list is not modified.
				The mark must not be nil.

			(*List) Len() int
				Len returns the number of elements of list l.
				The complexity is O(1).

			(*List) MoveAfter(e, mark *Element)
				MoveAfter moves element e to its new position after mark.
				If e or mark is not an element of l, or e == mark, the list is not modified.
				The element and mark must not be nil.

			(*List) MoveBefore(e, mark *Element)
				MoveBefore moves element e to its new position before mark.
				If e or mark is not an element of l, or e == mark, the list is not modified.
				The element and mark must not be nil.

			(*List) MoveToBack(e *Element)
				MoveToBack moves element e to the back of list l.
				If e is not an element of l, the list is not modified.
				The element must not be nil.

			(*List) MoveToFront(e *Element)
				MoveToFront moves element e to the front of list l.
				If e is not an element of l, the list is not modified.
				The element must not be nil.

			(*List) PushBack(v any) *Element
				PushBack inserts a new element e with value v at the back of list l and returns e.

			(*List) PushBackList(other *List)
				PushBackList inserts a copy of another list at the back of list l.
				The lists l and other may be the same. They must not be nil.

			(*List) PushFront(v any) *Element
				PushFront inserts a new element e with value v at the front of list l and returns e.

			(*List) PushFrontList(other *List)
				PushFrontList inserts a copy of another list at the front of list l.
				The lists l and other may be the same. They must not be nil.

			(*List) Remove(e *Element) any
				Remove removes e from l if e is an element of list l.
				It returns the element value e.Value.
				The element must not be nil.

			/* 5 unexporteds ... *//* 5 unexporteds: */
			(*List) insert(e, at *Element) *Element
				insert inserts e after at, increments l.len, and returns e.

			(*List) insertValue(v any, at *Element) *Element
				insertValue is a convenience wrapper for insert(&Element{Value: v}, at).

			(*List) lazyInit()
				lazyInit lazily initializes a zero List value.

			(*List) move(e, at *Element)
				move moves e to next to at.

			(*List) remove(e *Element)
				remove removes e from its list, decrements l.len

		As Outputs Of (at least 2, both are exported)
			func New() *List
			func (*List).Init() *List
		As Inputs Of (at least 2, both are exported)
			func (*List).PushBackList(other *List)
			func (*List).PushFrontList(other *List)


Package-Level Functions (only one, which is exported)

	 func New() *List
		New returns an initialized list.

The pages are generated with Golds v0.6.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.