add expression statement

src/ast.rs

···
     DeclareImmutable(DeclareImmutable),
     DeclareMutable(DeclareMutable),
     Assign(Assign),
+    Expr(ExpressionStatement),
     // Graph nodes
     CreateGraphNode(CreateGraphNode),
     AddGraphNodeAttribute(AddGraphNodeAttribute),
···
             Self::DeclareImmutable(stmt) => stmt.fmt(f),
             Self::DeclareMutable(stmt) => stmt.fmt(f),
             Self::Assign(stmt) => stmt.fmt(f),
+            Self::Expr(stmt) => stmt.fmt(f),
             Self::CreateGraphNode(stmt) => stmt.fmt(f),
             Self::AddGraphNodeAttribute(stmt) => stmt.fmt(f),
             Self::CreateEdge(stmt) => stmt.fmt(f),
···
             write!(f, " {}", attr)?;
         }
         write!(f, " at {}", self.location)
+    }
+}
+
+/// An `expression` statement whose output is ignored
+#[derive(Debug, Eq, PartialEq)]
+pub struct ExpressionStatement {
+    pub value: Expression,
+    pub location: Location,
+}
+
+impl From<ExpressionStatement> for Statement {
+    fn from(statement: ExpressionStatement) -> Statement {
+        Statement::Expr(statement)
+    }
+}
+
+impl std::fmt::Display for ExpressionStatement {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(
+            f,
+            "{} at {}",
+            self.value, self.location,
+        )
     }
 }
 

src/checker.rs

···
             Self::DeclareImmutable(stmt) => stmt.check(ctx),
             Self::DeclareMutable(stmt) => stmt.check(ctx),
             Self::Assign(stmt) => stmt.check(ctx),
+            Self::Expr(stmt) => stmt.check(ctx),
             Self::CreateGraphNode(stmt) => stmt.check(ctx),
             Self::AddGraphNodeAttribute(stmt) => stmt.check(ctx),
             Self::CreateEdge(stmt) => stmt.check(ctx),
···
         used_captures.extend(value.used_captures.iter().cloned());
         let var_result = self.variable.check_set(ctx, value.into())?;
         used_captures.extend(var_result.used_captures);
+        Ok(StatementResult { used_captures })
+    }
+}
+
+impl ast::ExpressionStatement {
+    fn check(&mut self, ctx: &mut CheckContext) -> Result<StatementResult, CheckError> {
+        let mut used_captures = HashSet::new();
+        let value = self.value.check(ctx)?;
+        used_captures.extend(value.used_captures.iter().cloned());
         Ok(StatementResult { used_captures })
     }
 }

src/execution/lazy.rs

···
             Self::DeclareImmutable(statement) => statement.execute_lazy(exec),
             Self::DeclareMutable(statement) => statement.execute_lazy(exec),
             Self::Assign(statement) => statement.execute_lazy(exec),
+            Self::Expr(statement) =>  statement.value.evaluate_lazy(exec).map(|_| ()),
             Self::CreateGraphNode(statement) => statement.execute_lazy(exec),
             Self::AddGraphNodeAttribute(statement) => statement.execute_lazy(exec),
             Self::CreateEdge(statement) => statement.execute_lazy(exec),

src/execution/strict.rs

···
 use crate::ast::AddEdgeAttribute;
 use crate::ast::AddGraphNodeAttribute;
 use crate::ast::Assign;
+use crate::ast::ExpressionStatement;
 use crate::ast::Attribute;
 use crate::ast::AttributeShorthand;
 use crate::ast::AttributeShorthands;
···
             Statement::DeclareImmutable(s) => s.location,
             Statement::DeclareMutable(s) => s.location,
             Statement::Assign(s) => s.location,
+            Statement::Expr(s) => s.location,
             Statement::CreateGraphNode(s) => s.location,
             Statement::AddGraphNodeAttribute(s) => s.location,
             Statement::CreateEdge(s) => s.location,
···
             Statement::DeclareImmutable(statement) => statement.execute(exec),
             Statement::DeclareMutable(statement) => statement.execute(exec),
             Statement::Assign(statement) => statement.execute(exec),
+            Statement::Expr(statement) => statement.execute(exec),
             Statement::CreateGraphNode(statement) => statement.execute(exec),
             Statement::AddGraphNodeAttribute(statement) => statement.execute(exec),
             Statement::CreateEdge(statement) => statement.execute(exec),
···
     fn execute(&self, exec: &mut ExecutionContext) -> Result<(), ExecutionError> {
         let value = self.value.evaluate(exec)?;
         self.variable.set(exec, value)
+    }
+}
+
+impl ExpressionStatement {
+    fn execute(&self, exec: &mut ExecutionContext) -> Result<(), ExecutionError> {
+        self.value.evaluate(exec).map(|_| ())
     }
 }
 

src/parser.rs

···
     }
 
     fn parse_statement(&mut self) -> Result<ast::Statement, ParseError> {
+        if matches!(self.peek(), Ok( '#' | '"' | '@' | '$' | '(' | '[' | '{')) {
+            if let Ok(value) = self.parse_expression() {
+                return Ok(ast::Statement::Expr(ast::ExpressionStatement {
+                    location: self.location,
+                    value,
+                }));
+            }
+        }
         let keyword_location = self.location;
         let keyword = self.parse_name("keyword")?;
         self.consume_whitespace();