Enum fluent_syntax::ast::InlineExpression [−][src]
pub enum InlineExpression<S> {
StringLiteral {
value: S,
},
NumberLiteral {
value: S,
},
FunctionReference {
id: Identifier<S>,
arguments: CallArguments<S>,
},
MessageReference {
id: Identifier<S>,
attribute: Option<Identifier<S>>,
},
TermReference {
id: Identifier<S>,
attribute: Option<Identifier<S>>,
arguments: Option<CallArguments<S>>,
},
VariableReference {
id: Identifier<S>,
},
Placeable {
expression: Box<Expression<S>>,
},
}Expand description
A subset of expressions which can be used as Placeable,
selector, or in CallArguments.
Example
use fluent_syntax::parser;
use fluent_syntax::ast;
let ftl = r#"
key = { $emailCount }
"#;
let resource = parser::parse(ftl)
.expect("Failed to parse an FTL resource.");
assert_eq!(
resource,
ast::Resource {
body: vec![
ast::Entry::Message(
ast::Message {
id: ast::Identifier {
name: "key"
},
value: Some(ast::Pattern {
elements: vec![
ast::PatternElement::Placeable {
expression: ast::Expression::Inline(
ast::InlineExpression::VariableReference {
id: ast::Identifier {
name: "emailCount"
},
}
)
},
]
}),
attributes: vec![],
comment: None,
}
)
]
}
);Variants
StringLiteral
Single line string literal enclosed in ".
Example
use fluent_syntax::parser;
use fluent_syntax::ast;
let ftl = r#"
key = { "this is a literal" }
"#;
let resource = parser::parse(ftl)
.expect("Failed to parse an FTL resource.");
assert_eq!(
resource,
ast::Resource {
body: vec![
ast::Entry::Message(
ast::Message {
id: ast::Identifier {
name: "key"
},
value: Some(ast::Pattern {
elements: vec![
ast::PatternElement::Placeable {
expression: ast::Expression::Inline(
ast::InlineExpression::StringLiteral {
value: "this is a literal",
}
)
},
]
}),
attributes: vec![],
comment: None,
}
)
]
}
);NumberLiteral
A number literal.
Example
use fluent_syntax::parser;
use fluent_syntax::ast;
let ftl = r#"
key = { -0.5 }
"#;
let resource = parser::parse(ftl)
.expect("Failed to parse an FTL resource.");
assert_eq!(
resource,
ast::Resource {
body: vec![
ast::Entry::Message(
ast::Message {
id: ast::Identifier {
name: "key"
},
value: Some(ast::Pattern {
elements: vec![
ast::PatternElement::Placeable {
expression: ast::Expression::Inline(
ast::InlineExpression::NumberLiteral {
value: "-0.5",
}
)
},
]
}),
attributes: vec![],
comment: None,
}
)
]
}
);FunctionReference
A function reference.
Example
use fluent_syntax::parser;
use fluent_syntax::ast;
let ftl = r#"
key = { FUNC() }
"#;
let resource = parser::parse(ftl)
.expect("Failed to parse an FTL resource.");
assert_eq!(
resource,
ast::Resource {
body: vec![
ast::Entry::Message(
ast::Message {
id: ast::Identifier {
name: "key"
},
value: Some(ast::Pattern {
elements: vec![
ast::PatternElement::Placeable {
expression: ast::Expression::Inline(
ast::InlineExpression::FunctionReference {
id: ast::Identifier {
name: "FUNC"
},
arguments: ast::CallArguments::default(),
}
)
},
]
}),
attributes: vec![],
comment: None,
}
)
]
}
);MessageReference
A reference to another message.
Example
use fluent_syntax::parser;
use fluent_syntax::ast;
let ftl = r#"
key = { key2 }
"#;
let resource = parser::parse(ftl)
.expect("Failed to parse an FTL resource.");
assert_eq!(
resource,
ast::Resource {
body: vec![
ast::Entry::Message(
ast::Message {
id: ast::Identifier {
name: "key"
},
value: Some(ast::Pattern {
elements: vec![
ast::PatternElement::Placeable {
expression: ast::Expression::Inline(
ast::InlineExpression::MessageReference {
id: ast::Identifier {
name: "key2"
},
attribute: None,
}
)
},
]
}),
attributes: vec![],
comment: None,
}
)
]
}
);TermReference
A reference to a term.
Example
use fluent_syntax::parser;
use fluent_syntax::ast;
let ftl = r#"
key = { -brand-name }
"#;
let resource = parser::parse(ftl)
.expect("Failed to parse an FTL resource.");
assert_eq!(
resource,
ast::Resource {
body: vec![
ast::Entry::Message(
ast::Message {
id: ast::Identifier {
name: "key"
},
value: Some(ast::Pattern {
elements: vec![
ast::PatternElement::Placeable {
expression: ast::Expression::Inline(
ast::InlineExpression::TermReference {
id: ast::Identifier {
name: "brand-name"
},
attribute: None,
arguments: None,
}
)
},
]
}),
attributes: vec![],
comment: None,
}
)
]
}
);VariableReference
Fields
id: Identifier<S>A reference to a variable.
Example
use fluent_syntax::parser;
use fluent_syntax::ast;
let ftl = r#"
key = { $var1 }
"#;
let resource = parser::parse(ftl)
.expect("Failed to parse an FTL resource.");
assert_eq!(
resource,
ast::Resource {
body: vec![
ast::Entry::Message(
ast::Message {
id: ast::Identifier {
name: "key"
},
value: Some(ast::Pattern {
elements: vec![
ast::PatternElement::Placeable {
expression: ast::Expression::Inline(
ast::InlineExpression::VariableReference {
id: ast::Identifier {
name: "var1"
},
}
)
},
]
}),
attributes: vec![],
comment: None,
}
)
]
}
);Placeable
Fields
expression: Box<Expression<S>>A placeable which may contain another expression.
Example
use fluent_syntax::parser;
use fluent_syntax::ast;
let ftl = r#"
key = { { "placeable" } }
"#;
let resource = parser::parse(ftl)
.expect("Failed to parse an FTL resource.");
assert_eq!(
resource,
ast::Resource {
body: vec![
ast::Entry::Message(
ast::Message {
id: ast::Identifier {
name: "key"
},
value: Some(ast::Pattern {
elements: vec![
ast::PatternElement::Placeable {
expression: ast::Expression::Inline(
ast::InlineExpression::Placeable {
expression: Box::new(
ast::Expression::Inline(
ast::InlineExpression::StringLiteral {
value: "placeable"
}
)
)
}
)
},
]
}),
attributes: vec![],
comment: None,
}
)
]
}
);Trait Implementations
This method tests for self and other values to be equal, and is used
by ==. Read more
This method tests for !=.
Auto Trait Implementations
impl<S> RefUnwindSafe for InlineExpression<S> where
S: RefUnwindSafe,
impl<S> Send for InlineExpression<S> where
S: Send,
impl<S> Sync for InlineExpression<S> where
S: Sync,
impl<S> Unpin for InlineExpression<S> where
S: Unpin,
impl<S> UnwindSafe for InlineExpression<S> where
S: UnwindSafe,
Blanket Implementations
Mutably borrows from an owned value. Read more