Pushes a new pair onto the sequence ```rust # use full_moon::ast::punctuated::{Pair, Punctuated}; let mut punctuated = Punctuated::new(); punctuated.p

Checks if the token is the given symbol

Returns an iterator over references of the sequence values, ignoring punctuation ```rust # use full_moon::ast::punctuated::{Pair, Punctuated}; let mut

Maps a `Pair<T>` to a `Pair<U>` by applying a function to the value of the pair, while preserving punctuation if it is not the end. ```rust # use full

Unwraps the result, panicking if it is not [`LexerResult::Ok`].

Returns a vector of all tokens left in the source string.

The type of token as well as the data needed to represent it If you don't need any other information, use [`token_kind`](Token::token_kind) instead.

Returns true if Luau is enabled.

Consumes the current token and returns the next token.

The kind of token with no additional data. If you need any information such as idenitfier names, use [`token_type`](Token::token_type) instead.

Returns the start and end bounds in a tuple as references

Returns the current token.

Returns the length of the ShortString.

The entire code of the function ```rust # fn main() -> Result<(), Vec<full_moon::Error>> { assert_eq!(full_moon::parse("local x = 1; local y = 2")?.n

Returns whether there's any nodes in the punctuated sequence ```rust # use full_moon::ast::punctuated::{Pair, Punctuated}; let mut punctuated = Punctu

Returns the last pair in the sequence ```rust # use full_moon::ast::punctuated::{Pair, Punctuated}; let mut punctuated = Punctuated::new(); punctuated

Returns the number of pairs in the punctuated sequence ```rust # use full_moon::ast::punctuated::{Pair, Punctuated}; let mut punctuated = Punctuated::

Returns an iterator over pairs ```rust # use full_moon::ast::punctuated::{Pair, Punctuated}; let mut punctuated = Punctuated::new(); punctuated.push(P

This takes start_token and end_token as owned references because otherwise, we tend to stack an immutable over mutable borrow.

The `return` token

Takes the `Pair` and returns the node `T` and the punctuation, if it exists as a tuple ```rust # use full_moon::ast::punctuated::Pair; let pair = Pair

Returns a `&str` representation of the ShortString.

Returns true if LuaJIT is enabled.

Pops off the last pair if it isn't empty ```rust # use full_moon::ast::punctuated::{Pair, Punctuated}; let mut punctuated = Punctuated::new(); punctua

Blocks in general are not very fallible. This means, for instance, not finishing `function()` will result in a completely ignored function body. This

Returns true if CFX Lua is enabled.

Returns true if Lua 5.2 is enabled.

Takes the `Pair` and returns the node `T` ```rust # use full_moon::ast::punctuated::Pair; let pair = Pair::new(1, None); assert_eq!(pair.into_value(),

Pushes a new node `T` onto the sequence, with the given punctuation. Will apply the punctuation to the last item, which must exist.

Returns a reference to the node `T` ```rust # use full_moon::ast::punctuated::Pair; let pair = Pair::new(1, None); assert_eq!(pair.value(), &1); ```

Returns whether or not the ShortString is empty.

Returns the next token.

Processes and returns the next token in the source string, ignoring trivia.

Returns the range of the error

An iterator over the statements in the block, such as `local foo = 1`. Note that this does not contain the final statement which can be attained via

Will update the positions of all the tokens in the tree Necessary if you are both mutating the tree and need the positions of the tokens

Returns the first pair in the sequence ```rust # use full_moon::ast::punctuated::{Pair, Punctuated}; let mut punctuated = Punctuated::new(); assert_eq

Returns true if Lua 5.3 is enabled.

Returns whether a token can be practically ignored in most cases Comments and whitespace will return `true`, everything else will return `false`

Returns the leading trivia

Returns an iterator over pairs as references ```rust # use full_moon::ast::punctuated::{Pair, Punctuated}; let mut punctuated = Punctuated::new(); pun

Given code and a pinned Lua version, will produce an [`ast::AstResult`]. This AstResult always produces some [`Ast`](ast::Ast), regardless of errors.

Returns the trailing trivia

The type for the field, `number` in `foo: number`.

Returns a new NumericFor with the given block

How many bytes, ignoring lines, it would take to find this position

Returns the errors, if there was any.