#[allow(missing_docs)]

    List(Gc<'gc, ListCons<'gc>>),

    List(Gc<'gc, ListCell<'gc>>),

/// Representation of a Scheme list cell

pub enum ListCons<'gc> {

pub enum ListCell<'gc> {

    /// A list with a single element

    Cons(Gc<'gc, ListCons<'gc>>, Gc<'gc, ListCons<'gc>>),

    /// A pair of list cells (car, cdr)
    Cons(Gc<'gc, ListCell<'gc>>, Gc<'gc, ListCell<'gc>>),

    srl_registers: [Option<Gc<'gc, ListCons<'gc>>>; 255],

    srl_registers: [Option<Gc<'gc, ListCell<'gc>>>; 255],

/// A lightweight representation of a symbol from a given symbol table

#![warn(missing_docs)]

//! Lexer, taking an input string, and splitting it into tokens

    error::ContextError,

/// A lexing error

    /// An error occured paring an integer

    /// Lexer encountered an unknown character

    /// A winnow parse error occured
    #[error("{1} around offset {0}")]
    ParseError(usize, ContextError),

        .map_err(|e| {
            // TODO A proper lex error
            dbg!(std::any::type_name_of_val(&e));
            LexError::Unknown
        })

        .map_err(|e| LexError::ParseError(e.offset(), e.into_inner()))

    integer_number_parser.parse(target).map_err(|e| {
        // TODO A proper lex error
        dbg!(std::any::type_name_of_val(&e));
        LexError::Unknown
    })

    integer_number_parser
        .parse(target)
        .map_err(|e| LexError::ParseError(e.offset(), e.into_inner()))

/// Errors possible when parsing a decimal number

    /// Parsing a floating-point number failed

    /// Parsing an integer failed

    decimal_number_parser.parse(target).map_err(|e| {
        // TODO A proper lex error
        dbg!(std::any::type_name_of_val(&e));
        LexError::Unknown
    })

    decimal_number_parser
        .parse(target)
        .map_err(|e| LexError::ParseError(e.offset(), e.into_inner()))

/// The smallest unit of lexical meaning

    /// Left parenthesis

    /// Right parenthesis

    /// Start vector token

    /// Start bytevector token

    /// Contiguous Whitespace

    /// Boolean literal

    /// Character literal

    /// Identifier (or "symbol literal")

    /// String literal

    /// Integer literal in `(base, exponent)` form
    ///
    /// The number represented is `base * 10 ** exponent`

    /// Decimal literal in `(base, exponent)` form
    ///
    /// The number represented is `base * 10 ** exponent`

    /// Introduce a label for the following datum

    /// A placeholder for a datum referenced by a given label

    /// Positive infinity

    /// Negative infinity

    /// Not a number (positive)

    /// Not a number (negative)

    /// Positive Imaginary Root `(sqrt(-1))`

    /// Negative Imaginary Root `(-sqrt(-1))`

    /// A dot

    /// Symbol used to represent `quote` special form

    /// Symbol used to represent `quasiquote` special form

    /// Symbol used to represent `unquote` special form

    /// Symbol used to represent `unquote-splicing` special form

    /// Used to start a comment that ends with `\n`

    /// Contiguous line ends

    /// Used to start a comment that ends at the end of the following datum

    /// Used to start a nestable block comment

    /// Used to end a nestable block comment

/// Produce a lexer that lexes [`Token`]s from an input string

/// Arguments for an [`OpCode`]

    A(u32), // first 8 bits are ignored

    /// Shape A - only the last 24 bits of the value are used
    A(u32),
    /// Shape B

    /// Shape C

    /// Mask used to extract arguments from a given bytecode

    /// Treat arguments as a Shape A

    /// Treat arguments as a Shape B

    /// Treat arguments as a Shape C

/// Representation of valid bytecode

    /// The [`OpCode`] of a given bytecode

    /// Arguments specified of a given bytecode

    /// Parse a valid bytecode from a given raw bytecode