Enum Statement

Source

pub enum Statement {
    Argument(Argument),
    Assignment(Assignment),
    Class(Class),
    Comment(Comment),
    Function(Function),
    FunctionCall(FunctionCall),
    KeywordArgument(KeywordArgument),
}

Variants§

§

KeywordArgument(KeywordArgument)

Implementations§

Source §

impl Statement

Source

pub fn variable<T: Display>(name: T) -> Statement

Examples found in repository ?

examples/hello_world.rs (line 15)

5fn main() {
6    let mut program = Block::new();
7
8    let mut function = Function::new("hello",
9                                     vec![Argument::new("name",
10                                                        Some("\"World\""),
11                                                        Some("str"),
12                                                        Some("The name to say Hello to"))],
13                                     &program);
14    let arguments = vec![Statement::unnamed_variable("Hello"),
15                         Statement::variable("name")];
16    let function_call = Statement::function_call("print", arguments);
17    function.add_statement(function_call);
18    function.add_docstring("hello is a function that prints \"Hello\" with the given \
19                            name argument.");
20
21    program.add_function(function);
22    let function_call = Statement::function_call(
23      "hello",
24      vec![
25        Statement::unnamed_variable("Chris")
26      ]);
27    program.add_statement(function_call);
28    let expected = r#"def hello(name="World"):
29    """
30    hello is a function that prints "Hello" with the given name argument.
31
32    :param name: str The name to say Hello to
33    """
34    print("Hello", name)
35
36hello("Chris")
37"#;
38    let actual = format!("{}",program);
39    assert_eq!(expected, actual);
40
41    println!("{}", actual);
42
43}

More examples

Hide additional examples

examples/classes.rs (line 19)

5fn main() {
6    let mut program = Block::new();
7    let mut class = Class::new("Greeter", &program);
8    class.add_docstring("Greeter is a class to say Hello!");
9    let arguments = vec![
10      Argument::new("self", None, None, None),
11      Argument::new("name", Some("\"World\""), Some("str"), Some("The name to greet")),
12    ];
13    let mut init = Function::new("__init__", arguments, &class.block);
14
15    init.add_docstring("Set up name variable for the Greeter");
16    init.add_statement(
17      Statement::Assignment(
18        Assignment::new(
19          Argument::variable("self.name"), Statement::variable("name"))));
20    class.add_statement(Statement::Function(init));
21    let arguments = vec![
22      Argument::new("self", None, None, None),
23    ];
24    let mut hello = Function::new("hello", arguments, &class.block);
25    hello.add_docstring("Say hello to self.name");
26    let print = Statement::function_call(
27      "print",
28      vec![
29        Statement::unnamed_variable("Hello"),
30        Statement::variable("self.name"),
31        Statement::unnamed_variable("!"),
32      ]);
33    hello.add_statement(print);
34    class.add_statement(Statement::Function(hello));
35    program.add_statement(Statement::Class(class));
36    program.add_statement(
37        Statement::Assignment(Assignment::new(
38            Argument::variable("g"),
39            Statement::function_call(
40                "Greeter",
41                vec![
42                    Statement::KeywordArgument(KeywordArgument::new("name", "\"Chris\""))
43                ]
44            )
45    )));
46    let function_call = Statement::function_call(
47      "g.hello",
48      vec![]);
49    program.add_statement(function_call);
50    let expected = r#"class Greeter:
51    """
52    Greeter is a class to say Hello!
53    """
54
55    def __init__(self, name="World"):
56        """
57        Set up name variable for the Greeter
58
59        :param name: str The name to greet
60        """
61        self.name = name
62
63    def hello(self):
64        """
65        Say hello to self.name
66        """
67        print("Hello", self.name, "!")
68
69
70g = Greeter(name="Chris")
71g.hello()
72"#;
73    let actual = format!("{}", program);
74
75    assert_eq!(expected, actual);
76
77    println!("{}", actual);
78}

Source

pub fn unnamed_variable<T: Display>(value: T) -> Statement

Examples found in repository ?

examples/hello_world.rs (line 14)

5fn main() {
6    let mut program = Block::new();
7
8    let mut function = Function::new("hello",
9                                     vec![Argument::new("name",
10                                                        Some("\"World\""),
11                                                        Some("str"),
12                                                        Some("The name to say Hello to"))],
13                                     &program);
14    let arguments = vec![Statement::unnamed_variable("Hello"),
15                         Statement::variable("name")];
16    let function_call = Statement::function_call("print", arguments);
17    function.add_statement(function_call);
18    function.add_docstring("hello is a function that prints \"Hello\" with the given \
19                            name argument.");
20
21    program.add_function(function);
22    let function_call = Statement::function_call(
23      "hello",
24      vec![
25        Statement::unnamed_variable("Chris")
26      ]);
27    program.add_statement(function_call);
28    let expected = r#"def hello(name="World"):
29    """
30    hello is a function that prints "Hello" with the given name argument.
31
32    :param name: str The name to say Hello to
33    """
34    print("Hello", name)
35
36hello("Chris")
37"#;
38    let actual = format!("{}",program);
39    assert_eq!(expected, actual);
40
41    println!("{}", actual);
42
43}

More examples

Hide additional examples

examples/classes.rs (line 29)

5fn main() {
6    let mut program = Block::new();
7    let mut class = Class::new("Greeter", &program);
8    class.add_docstring("Greeter is a class to say Hello!");
9    let arguments = vec![
10      Argument::new("self", None, None, None),
11      Argument::new("name", Some("\"World\""), Some("str"), Some("The name to greet")),
12    ];
13    let mut init = Function::new("__init__", arguments, &class.block);
14
15    init.add_docstring("Set up name variable for the Greeter");
16    init.add_statement(
17      Statement::Assignment(
18        Assignment::new(
19          Argument::variable("self.name"), Statement::variable("name"))));
20    class.add_statement(Statement::Function(init));
21    let arguments = vec![
22      Argument::new("self", None, None, None),
23    ];
24    let mut hello = Function::new("hello", arguments, &class.block);
25    hello.add_docstring("Say hello to self.name");
26    let print = Statement::function_call(
27      "print",
28      vec![
29        Statement::unnamed_variable("Hello"),
30        Statement::variable("self.name"),
31        Statement::unnamed_variable("!"),
32      ]);
33    hello.add_statement(print);
34    class.add_statement(Statement::Function(hello));
35    program.add_statement(Statement::Class(class));
36    program.add_statement(
37        Statement::Assignment(Assignment::new(
38            Argument::variable("g"),
39            Statement::function_call(
40                "Greeter",
41                vec![
42                    Statement::KeywordArgument(KeywordArgument::new("name", "\"Chris\""))
43                ]
44            )
45    )));
46    let function_call = Statement::function_call(
47      "g.hello",
48      vec![]);
49    program.add_statement(function_call);
50    let expected = r#"class Greeter:
51    """
52    Greeter is a class to say Hello!
53    """
54
55    def __init__(self, name="World"):
56        """
57        Set up name variable for the Greeter
58
59        :param name: str The name to greet
60        """
61        self.name = name
62
63    def hello(self):
64        """
65        Say hello to self.name
66        """
67        print("Hello", self.name, "!")
68
69
70g = Greeter(name="Chris")
71g.hello()
72"#;
73    let actual = format!("{}", program);
74
75    assert_eq!(expected, actual);
76
77    println!("{}", actual);
78}

Source

pub fn function_call<T: Display>( name: T, arguments: Vec<Statement>, ) -> Statement

Examples found in repository ?

examples/hello_world.rs (line 16)

5fn main() {
6    let mut program = Block::new();
7
8    let mut function = Function::new("hello",
9                                     vec![Argument::new("name",
10                                                        Some("\"World\""),
11                                                        Some("str"),
12                                                        Some("The name to say Hello to"))],
13                                     &program);
14    let arguments = vec![Statement::unnamed_variable("Hello"),
15                         Statement::variable("name")];
16    let function_call = Statement::function_call("print", arguments);
17    function.add_statement(function_call);
18    function.add_docstring("hello is a function that prints \"Hello\" with the given \
19                            name argument.");
20
21    program.add_function(function);
22    let function_call = Statement::function_call(
23      "hello",
24      vec![
25        Statement::unnamed_variable("Chris")
26      ]);
27    program.add_statement(function_call);
28    let expected = r#"def hello(name="World"):
29    """
30    hello is a function that prints "Hello" with the given name argument.
31
32    :param name: str The name to say Hello to
33    """
34    print("Hello", name)
35
36hello("Chris")
37"#;
38    let actual = format!("{}",program);
39    assert_eq!(expected, actual);
40
41    println!("{}", actual);
42
43}

More examples

Hide additional examples

examples/classes.rs (lines 26-32)

5fn main() {
6    let mut program = Block::new();
7    let mut class = Class::new("Greeter", &program);
8    class.add_docstring("Greeter is a class to say Hello!");
9    let arguments = vec![
10      Argument::new("self", None, None, None),
11      Argument::new("name", Some("\"World\""), Some("str"), Some("The name to greet")),
12    ];
13    let mut init = Function::new("__init__", arguments, &class.block);
14
15    init.add_docstring("Set up name variable for the Greeter");
16    init.add_statement(
17      Statement::Assignment(
18        Assignment::new(
19          Argument::variable("self.name"), Statement::variable("name"))));
20    class.add_statement(Statement::Function(init));
21    let arguments = vec![
22      Argument::new("self", None, None, None),
23    ];
24    let mut hello = Function::new("hello", arguments, &class.block);
25    hello.add_docstring("Say hello to self.name");
26    let print = Statement::function_call(
27      "print",
28      vec![
29        Statement::unnamed_variable("Hello"),
30        Statement::variable("self.name"),
31        Statement::unnamed_variable("!"),
32      ]);
33    hello.add_statement(print);
34    class.add_statement(Statement::Function(hello));
35    program.add_statement(Statement::Class(class));
36    program.add_statement(
37        Statement::Assignment(Assignment::new(
38            Argument::variable("g"),
39            Statement::function_call(
40                "Greeter",
41                vec![
42                    Statement::KeywordArgument(KeywordArgument::new("name", "\"Chris\""))
43                ]
44            )
45    )));
46    let function_call = Statement::function_call(
47      "g.hello",
48      vec![]);
49    program.add_statement(function_call);
50    let expected = r#"class Greeter:
51    """
52    Greeter is a class to say Hello!
53    """
54
55    def __init__(self, name="World"):
56        """
57        Set up name variable for the Greeter
58
59        :param name: str The name to greet
60        """
61        self.name = name
62
63    def hello(self):
64        """
65        Say hello to self.name
66        """
67        print("Hello", self.name, "!")
68
69
70g = Greeter(name="Chris")
71g.hello()
72"#;
73    let actual = format!("{}", program);
74
75    assert_eq!(expected, actual);
76
77    println!("{}", actual);
78}