Trait rune::Parse

pub trait Parse where
    Self: Sized, {
    fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>;
}

The parse trait, implemented by items that can be parsed.

Required methods

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

Parse the current item from the parser.

Loading content...

Implementations on Foreign Types

impl<A, B> Parse for (A, B) where
    A: Parse + Peek,
    B: Parse, 

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl<T> Parse for Option<T> where
    T: Parse + Peek, 

Parse implementation for something that can be optionally parsed.

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl<T> Parse for Box<T> where
    T: Parse, 

Parse implementation for something that is boxed.

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl<T> Parse for Vec<T> where
    T: Parse + Peek, 

Parser implementation for a vector.

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

Loading content...

Implementors

impl Parse for Condition

Parse a condition.

Examples

use rune::{testing, ast};

testing::roundtrip::<ast::Condition>("true");
testing::roundtrip::<ast::Condition>("let [a, ..] = v");

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Expr

Parsing a block expression.

Examples

use rune::{testing, ast};

testing::roundtrip::<ast::Expr>("()");
testing::roundtrip::<ast::Expr>("foo[\"foo\"]");
testing::roundtrip::<ast::Expr>("foo.bar()");
testing::roundtrip::<ast::Expr>("var()");
testing::roundtrip::<ast::Expr>("var");
testing::roundtrip::<ast::Expr>("42");
testing::roundtrip::<ast::Expr>("1 + 2 / 3 - 4 * 1");
testing::roundtrip::<ast::Expr>("foo[\"bar\"]");
testing::roundtrip::<ast::Expr>("let var = 42");
testing::roundtrip::<ast::Expr>("let var = \"foo bar\"");
testing::roundtrip::<ast::Expr>("var[\"foo\"] = \"bar\"");
testing::roundtrip::<ast::Expr>("let var = objects[\"foo\"] + 1");
testing::roundtrip::<ast::Expr>("var = 42");

let expr = testing::roundtrip::<ast::Expr>(r#"
    if 1 { } else { if 2 { } else { } }
"#);
assert!(matches!(expr, ast::Expr::If(..)));

// Chained function calls.
testing::roundtrip::<ast::Expr>("foo.bar.baz()");
testing::roundtrip::<ast::Expr>("foo[0][1][2]");
testing::roundtrip::<ast::Expr>("foo.bar()[0].baz()[1]");

testing::roundtrip::<ast::Expr>("42 is int::int");
testing::roundtrip::<ast::Expr>("{ let x = 1; x }");

let expr = testing::roundtrip::<ast::Expr>("#[cfg(debug_assertions)] { assert_eq(x, 32); }");
assert!(matches!(expr, ast::Expr::Block(b) if b.attributes.len() == 1 && b.block.statements.len() == 1));

testing::roundtrip::<ast::Expr>("#{\"foo\": b\"bar\"}");
testing::roundtrip::<ast::Expr>("Disco {\"never_died\": true }");
testing::roundtrip::<ast::Expr>("(false, 1, 'n')");
testing::roundtrip::<ast::Expr>("[false, 1, 'b']");

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprBreakValue

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprRangeLimits

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprSelectBranch

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for FnArg

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Item

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ItemModBody

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ItemOrExpr

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ItemStructBody

Parse implementation for a struct body.

Examples

use rune::{testing, ast};

testing::roundtrip::<ast::ItemStructBody>("");

testing::roundtrip::<ast::ItemStructBody>("{ a, b, c }");
testing::roundtrip::<ast::ItemStructBody>("{ #[x] a, #[y] b, #[z] #[w] #[f32] c }");
testing::roundtrip::<ast::ItemStructBody>("{ a, #[attribute] b, c }");

testing::roundtrip::<ast::ItemStructBody>("( a, b, c )");
testing::roundtrip::<ast::ItemStructBody>("( #[x] a, b, c )");
testing::roundtrip::<ast::ItemStructBody>("( #[x] pub a, b, c )");
testing::roundtrip::<ast::ItemStructBody>("( a, b, c )");
testing::roundtrip::<ast::ItemStructBody>("()");

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ItemUseSegment

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ItemVariantBody

Parse implementation for a struct body.

Examples

use rune::{testing, ast};

testing::roundtrip::<ast::ItemVariantBody>("( a, b, c )");
testing::roundtrip::<ast::ItemVariantBody>("{ a, b, c }");
testing::roundtrip::<ast::ItemVariantBody>("( #[serde(default)] a, b, c )");
testing::roundtrip::<ast::ItemVariantBody>("{ a, #[debug(skip)] b, c }");

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Lit

Parsing a Lit

Examples

use rune::{testing, ast};

testing::roundtrip::<ast::Lit>("true");
testing::roundtrip::<ast::Lit>("false");
testing::roundtrip::<ast::Lit>("'🔥'");
testing::roundtrip::<ast::Lit>("b'4'");
testing::roundtrip::<ast::Lit>("b\"bytes\"");
testing::roundtrip::<ast::Lit>("1.2");
testing::roundtrip::<ast::Lit>("42");
testing::roundtrip::<ast::Lit>("\"mary had a little lamb\"");

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ObjectIdent

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ObjectKey

Parse an object literal.

Examples

use rune::{testing, ast};

testing::roundtrip::<ast::ObjectKey>("foo");
testing::roundtrip::<ast::ObjectKey>("\"foo \\n bar\"");

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Pat

Parsing a block expression.

Examples

use rune::{testing, ast};

testing::roundtrip::<ast::Pat>("()");
testing::roundtrip::<ast::Pat>("42");
testing::roundtrip::<ast::Pat>("-42");
testing::roundtrip::<ast::Pat>("3.1415");
testing::roundtrip::<ast::Pat>("-3.1415");
testing::roundtrip::<ast::Pat>("b'a'");
testing::roundtrip::<ast::Pat>("'a'");
testing::roundtrip::<ast::Pat>("b\"hello world\"");
testing::roundtrip::<ast::Pat>("\"hello world\"");
testing::roundtrip::<ast::Pat>("var");
testing::roundtrip::<ast::Pat>("_");
testing::roundtrip::<ast::Pat>("Foo(n)");

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for PathSegment

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Stmt

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Visibility

Parsing Visibility specifiers

Examples

use rune::{testing, ast};

assert!(matches!{
    testing::roundtrip::<ast::Visibility>("pub"),
    ast::Visibility::Public(_)
});

assert!(matches!{
    testing::roundtrip::<ast::Visibility>("pub (in a::b::c)"),
    ast::Visibility::In(_)
});

assert!(matches!{
    testing::roundtrip::<ast::Visibility>("pub(in crate::x::y::z)"),
    ast::Visibility::In(_)
});

assert!(matches!{
    testing::roundtrip::<ast::Visibility>("pub(super)"),
    ast::Visibility::Super(_)
});

assert!(matches!{
    testing::roundtrip::<ast::Visibility>("pub(crate)"),
    ast::Visibility::Crate(_)
});

assert!(matches!{
    testing::roundtrip::<ast::Visibility>("pub(self)"),
    ast::Visibility::SelfValue(_)
});

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Abstract

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for AlignOf

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Amp

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for AmpAmp

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for AmpEq

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Arrow

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for As

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Async

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for At

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Await

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Bang

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for BangEq

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Become

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Break

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Caret

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for CaretEq

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Colon

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ColonColon

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Comma

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Const

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Continue

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Crate

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Dash

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for DashEq

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Default

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Div

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Do

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Dollar

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Dot

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for DotDot

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for DotDotEq

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Else

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Enum

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Eq

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for EqEq

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Extern

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for False

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Final

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Fn

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for For

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Gt

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for GtEq

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for GtGt

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for GtGtEq

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for If

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Impl

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for In

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Is

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Let

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Loop

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Lt

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for LtEq

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for LtLt

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for LtLtEq

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Macro

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Match

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Mod

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Move

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Not

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for OffsetOf

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Override

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Perc

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for PercEq

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Pipe

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for PipeEq

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for PipePipe

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Plus

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for PlusEq

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Pound

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Priv

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Proc

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Pub

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Pure

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for QuestionMark

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Ref

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Return

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Rocket

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Select

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for SelfType

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for SelfValue

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for SemiColon

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for SizeOf

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for SlashEq

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Star

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for StarEq

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Static

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Struct

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Super

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Tilde

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for True

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for TypeOf

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Underscore

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Unsafe

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Use

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Virtual

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for While

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Yield

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Attribute

Parsing an Attribute

Examples

use rune::{testing, ast};

testing::roundtrip::<ast::Attribute>("#[foo = \"foo\"]");
testing::roundtrip::<ast::Attribute>("#[foo()]");
testing::roundtrip::<ast::Attribute>("#![foo]");
testing::roundtrip::<ast::Attribute>("#![cfg(all(feature = \"potato\"))]");
testing::roundtrip::<ast::Attribute>("#[x+1]");

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Block

Parse implementation for a block.

Examples

use rune::{testing, ast};

let block = testing::roundtrip::<ast::Block>("{}");
assert_eq!(block.statements.len(), 0);
assert!(block.produces_nothing());

let block = testing::roundtrip::<ast::Block>("{ foo }");
assert_eq!(block.statements.len(), 1);
assert!(!block.produces_nothing());

let block = testing::roundtrip::<ast::Block>("{ foo; }");
assert_eq!(block.statements.len(), 1);
assert!(block.produces_nothing());

let block = testing::roundtrip::<ast::Block>(r#"
    {
        let foo = 42;
        let bar = "string";
        baz
    }
"#);

assert_eq!(block.statements.len(), 3);

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for CloseBrace

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for CloseBracket

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for CloseParen

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprAssign

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprAwait

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprBinary

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprBlock

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprBreak

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprCall

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprClosure

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprContinue

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprElse

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprElseIf

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprFieldAccess

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprFor

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprGroup

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprIf

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprIndex

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprLet

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprLit

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprLoop

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprMatch

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprMatchBranch

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprObject

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprRange

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprReturn

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprSelect

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprTry

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprTuple

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprUnary

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprVec

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprWhile

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprWithoutBinary

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ExprYield

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Field

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for FieldAssign

Parse an object literal.

Examples

use rune::{testing, ast};

testing::roundtrip::<ast::FieldAssign>("\"foo\": 42");
testing::roundtrip::<ast::FieldAssign>("\"foo\": 42");
testing::roundtrip::<ast::FieldAssign>("\"foo\": 42");

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for File

Parse a file.

Examples

use rune::{testing, ast};

testing::roundtrip::<ast::File>(r#"
use foo;

fn foo() {
    42
}

use bar;

fn bar(a, b) {
    a
}
"#);

Realistic Example

use rune::{testing, ast};

testing::roundtrip::<ast::File>(r#"
use http;

fn main() {
    let client = http::client();
    let response = client.get("https://google.com");
    let text = response.text();
}
"#);

File Attributes Example

use rune::{testing, ast};

testing::roundtrip::<ast::File>(r#"
// NB: Attributes are currently rejected by the compiler
#![feature(attributes)]

fn main() {
    for x in [1,2,3,4,5,6] {
        println(`{x}`)
    }
}
"#);

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Ident

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ItemConst

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ItemEnum

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ItemFn

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ItemImpl

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ItemMod

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ItemStruct

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ItemUse

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ItemUsePath

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for ItemVariant

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Label

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for LitBool

Parsing a unit literal

Examples

use rune::{testing, ast};

testing::roundtrip::<ast::LitBool>("true");
testing::roundtrip::<ast::LitBool>("false");

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for LitByte

Parse a byte literal.

Examples

use rune::{testing, ast};

testing::roundtrip::<ast::LitByte>("b'a'");
testing::roundtrip::<ast::LitByte>("b'\\0'");
testing::roundtrip::<ast::LitByte>("b'\\n'");
testing::roundtrip::<ast::LitByte>("b'\\r'");
testing::roundtrip::<ast::LitByte>("b'\\\\''");

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for LitByteStr

Parse a string literal.

Examples

use rune::{testing, ast};

testing::roundtrip::<ast::LitByteStr>("b\"hello world\"");
testing::roundtrip::<ast::LitByteStr>("b\"hello\\nworld\"");

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for LitChar

Parse a character literal.

Examples

use rune::{testing, ast};

testing::roundtrip::<ast::LitChar>("'a'");
testing::roundtrip::<ast::LitChar>("'\\0'");
testing::roundtrip::<ast::LitChar>("'\\n'");
testing::roundtrip::<ast::LitChar>("'\\r'");
testing::roundtrip::<ast::LitChar>("'\\''");

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for LitNumber

Parse a number literal.

Examples

use rune::{testing, ast};

testing::roundtrip::<ast::LitNumber>("42");
testing::roundtrip::<ast::LitNumber>("42.42");
testing::roundtrip::<ast::LitNumber>("0.42");
testing::roundtrip::<ast::LitNumber>("0.42e10");

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for LitStr

Parse a string literal.

Examples

use rune::{testing, ast};

testing::roundtrip::<ast::LitStr>("\"hello world\"");
testing::roundtrip::<ast::LitStr>("\"hello\\nworld\"");

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Local

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for MacroCall

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for OpenBrace

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for OpenBracket

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for OpenParen

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for PatBinding

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for Path

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl Parse for FormatArgs

fn parse(p: &mut Parser<'_>) -> Result<Self, ParseError>

Parse format arguments inside of a macro.

impl<T, S> Parse for AngleBracketed<T, S> where
    T: Parse,
    S: Peek + Parse, 

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl<T, S> Parse for Braced<T, S> where
    T: Parse,
    S: Peek + Parse, 

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl<T, S> Parse for Bracketed<T, S> where
    T: Parse,
    S: Peek + Parse, 

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

impl<T, S> Parse for Parenthesized<T, S> where
    T: Parse,
    S: Peek + Parse, 

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

Loading content...