Copy does an explicit shallow copy of a Node's data into a NodeAssembler.

DeepEqual reports whether x and y are "deeply equal" as IPLD nodes.

NewPath returns a Path composed of the given segments.

NewPathNocopy is identical to NewPath but trusts that the segments slice you provide will not be mutated.

ParsePath converts a string to an IPLD Path, doing a basic parsing of the string using "/" as a delimiter to produce a segmented Path.

ParsePathSegment parses a string into a PathSegment, handling any escaping if present.

PathSegmentOfString boxes an int into a PathSegment.

PathSegmentOfString boxes a string into a PathSegment.

Absent is the _other_ kind of node (besides Null) we can have a true singleton implementation of.

Null is the one kind of node we can have a true singleton implementation of.

ErrInvalidSegmentForList is returned when using Node.LookupBySegment and the given PathSegment can't be applied to a list because it's unparsable as a number.

ErrIteratorOverread is returned when calling 'Next' on a MapIterator or ListIterator when it is already done.

ErrNotExists may be returned from the lookup functions of the Node interface to indicate a missing value.

ErrRepeatedMapKey is an error indicating that a key was inserted into a map that already contains that key.

ErrWrongKind may be returned from functions on the Node interface when a method is invoked which doesn't make sense for the Kind that node concretely contains.

Path describes a series of steps across a tree or DAG of Node, where each segment in the path is a map key or list index (literaly, Path is a slice of PathSegment values).

PathSegment can describe either a key in a map, or an index in a list.

LargeBytesNode is an optional interface extending a Bytes node that allows its contents to be accessed through an io.ReadSeeker instead of a []byte slice.

Link is a special kind of value in IPLD which can be "loaded" to access more nodes.

LinkPrototype encapsulates any implementation details and parameters necessary for creating a Link, expect for the hash result itself.

ListIterator is an interface for traversing list nodes.

MapAssembler assembles a map node! (You guessed it.) Methods on MapAssembler must be called in a valid order: assemble a key, then assemble a value, then loop as long as desired; when finished, call 'Finish'.

MapIterator is an interface for traversing map nodes.

Node represents a value in IPLD.

NodeAssembler is the interface that describes all the ways we can set values in a node that's under construction.

NodePrototype describes a node implementation (all Node have a NodePrototype), and a NodePrototype can always be used to get a NodeBuilder.

NodePrototypeSupportingAmend is a feature-detection interface that can be used on a NodePrototype to see if it's possible to build new nodes of this style while sharing some internal data in a copy-on-write way.

Kind represents the primitive kind in the IPLD data model.

KindSet is a type with a few enumerated consts that are commonly used (mostly, in error messages).