Formal

syn_args

Struct Formal 

Source 
pub struct Formal {}
Expand description

parse the input into Arguments

Implementations§

Source§

impl Formal

Source

pub fn new() -> Self

Examples found in repository?
examples/test.rs (line 39)
38fn test_formal_f1() {
39    let f = Formal::new();
40
41    // fm.parse("F(Object{ a: Int, b: Optional(Int) }, Array(Int))");
42    let args = f.parse("F(1, 3)").unwrap();
43    // let args = f.parse("F(1)").unwrap();
44    // let args = f.parse("F(Hello)").unwrap();
45    println!("{:?}", args);
46
47    let res = ModuleArgs::try_from(args).unwrap();
48    println!("{:?}", res);
49
50    assert_eq!(res, ModuleArgs::F1(def::Int(1), def::Int(3)));
51}
52
53fn test_formal_f2() {
54    let f = Formal::new();
55
56    let args = f.parse("F(1)").unwrap();
57    // let args = f.parse("F(Hello)").unwrap();
58    println!("{:?}", args);
59
60    let res = ModuleArgs::try_from(args).unwrap();
61    println!("{:?}", res);
62
63    assert_eq!(res, ModuleArgs::F2(def::Int(1)));
64}
65
66fn test_formal_f3() {
67    let res = ModuleArgs::parse("F(Hello)").unwrap();
68    println!("{:?}", res);
69
70    assert_eq!(res, ModuleArgs::F3(def::Expr::from("Hello")));
71}
72
73fn test_formal_f4() {
74    let res = ModuleArgs::parse("F([Ident1, Ident2])").unwrap();
75    println!("{:?}", res);
76
77    assert_eq!(res, ModuleArgs::F4(def::Array(vec![def::Expr::from("Ident1"), def::Expr::from("Ident2")])));
78}
79
80fn test_formal_f5() {
81    let res = ModuleArgs::parse("F({ imports: [Ident1, Ident2] })").unwrap();
82    println!("{:?}", res);
83
84    assert_eq!(
85        res,
86        ModuleArgs::F5(ModuleSubObj {
87            imports: def::Array(vec![def::Expr::from("Ident1"), def::Expr::from("Ident2")]),
88            global: def::Option(None),
89            sub: def::Option(None)
90        })
91    );
92}
93
94fn test_formal_f6() {
95    let res = ModuleArgs::parse("F([{ imports: [Ident1, Ident2] }, { imports: [Ident3, Ident4] }])").unwrap();
96    println!("{:?}", res);
97
98    assert_eq!(
99        res,
100        ModuleArgs::F6(def::Array(vec![
101            ModuleSubObj {
102                imports: def::Array(vec![def::Expr::from("Ident1"), def::Expr::from("Ident2")]),
103                global: def::Option(None),
104                sub: def::Option(None)
105            },
106            ModuleSubObj {
107                imports: def::Array(vec![def::Expr::from("Ident3"), def::Expr::from("Ident4")]),
108                global: def::Option(None),
109                sub: def::Option(None)
110            }
111        ]))
112    );
113}
114
115fn test_formal_f6_2() {
116    let res = ModuleArgs::parse("F([{ imports: [Ident1, Ident2], global: true }, { imports: [Ident3, Ident4] }])").unwrap();
117    println!("{:?}", res);
118
119    assert_eq!(
120        res,
121        ModuleArgs::F6(def::Array(vec![
122            ModuleSubObj {
123                imports: def::Array(vec![def::Expr::from("Ident1"), def::Expr::from("Ident2")]),
124                global: def::Option(Some(def::Bool(true))),
125                sub: def::Option(None)
126            },
127            ModuleSubObj {
128                imports: def::Array(vec![def::Expr::from("Ident3"), def::Expr::from("Ident4")]),
129                global: def::Option(None),
130                sub: def::Option(None)
131            }
132        ]))
133    );
134}
135
136fn test_formal_f6_3() {
137    let res = ModuleArgs::parse("F([{ imports: [Ident1, Ident2], global: true, sub: { value: true } }, { imports: [Ident3, Ident4] }])").unwrap();
138    println!("{:?}", res);
139
140    assert_eq!(
141        res,
142        ModuleArgs::F6(def::Array(vec![
143            ModuleSubObj {
144                imports: def::Array(vec![def::Expr::from("Ident1"), def::Expr::from("Ident2")]),
145                global: def::Option(Some(def::Bool(true))),
146                sub: def::Option(Some(Sub { value: def::Bool(true) }))
147            },
148            ModuleSubObj {
149                imports: def::Array(vec![def::Expr::from("Ident3"), def::Expr::from("Ident4")]),
150                global: def::Option(None),
151                sub: def::Option(None)
152            }
153        ]))
154    );
155}
156
157fn test_formal_f7() {
158    let res = ModuleArgs::parse("F({ s1: { value: false }, s2: { value: true } })").unwrap();
159    println!("{:?}", res);
160
161    assert_eq!(res, ModuleArgs::F7(SubWrap { s1: Sub { value: def::Bool(false) }, s2: Sub { value: def::Bool(true) } }));
162}
163
164fn test_tokens_formal_f7() {
165    let res = ModuleArgs::parse("F({ s1: { value: false }, s2: { value: true } })").unwrap();
166    println!("{:?}", res);
167
168    assert_eq!(res, ModuleArgs::F7(SubWrap { s1: Sub { value: def::Bool(false) }, s2: Sub { value: def::Bool(true) } }));
169}
170
171fn test_formal_f8() {
172    let res = ModuleArgs::parse("F({ controllers: [Ident1, Ident2] })").unwrap();
173    println!("{:?}", res);
174
175    assert_eq!(
176        res,
177        ModuleArgs::F8(def::Option(Some(T1 {
178            controllers: def::Option(Some(def::Array(vec![def::Expr::from("Ident1"), def::Expr::from("Ident2")])))
179        })))
180    );
181
182    let res = ModuleArgs::parse("F()").unwrap();
183    println!("{:?}", res);
184
185    assert_eq!(res, ModuleArgs::F8(def::Option(None)));
186}
187
188//
189fn test_value_p1() {
190    let f = Formal::new();
191
192    let args = f.parse("F(1, { a:1, b:2 })").unwrap();
193    println!("{:?}", args);
194
195    assert_eq!(
196        args.0,
197        Value::Array(def::Array(vec![
198            Value::Int(def::Int(1)),
199            Value::Object(def::Object(
200                vec![("a".to_string(), Value::Int(def::Int(1))), ("b".to_string(), Value::Int(def::Int(2)))].into_iter().collect()
201            ))
202        ]))
203    );
204}
205
206fn test_into_object_p1() {
207    let f = Formal::new();
208    let args = f.parse("F({ imports: [Ident1::register(), Ident2] })").unwrap();
209    println!("{:?}", args);
210    let res = ModuleSubObj::try_from(args).unwrap();
211
212    assert_eq!(
213        res,
214        ModuleSubObj {
215            imports: def::Array(vec![def::Expr::from("Ident1::register ()"), def::Expr::from("Ident2")]),
216            global: def::Option(None),
217            sub: def::Option(None)
218        }
219    );
220}
Source

pub fn parse(&self, input: &str) -> Result<Arguments, Error>

Examples found in repository?
examples/test.rs (line 42)
38fn test_formal_f1() {
39    let f = Formal::new();
40
41    // fm.parse("F(Object{ a: Int, b: Optional(Int) }, Array(Int))");
42    let args = f.parse("F(1, 3)").unwrap();
43    // let args = f.parse("F(1)").unwrap();
44    // let args = f.parse("F(Hello)").unwrap();
45    println!("{:?}", args);
46
47    let res = ModuleArgs::try_from(args).unwrap();
48    println!("{:?}", res);
49
50    assert_eq!(res, ModuleArgs::F1(def::Int(1), def::Int(3)));
51}
52
53fn test_formal_f2() {
54    let f = Formal::new();
55
56    let args = f.parse("F(1)").unwrap();
57    // let args = f.parse("F(Hello)").unwrap();
58    println!("{:?}", args);
59
60    let res = ModuleArgs::try_from(args).unwrap();
61    println!("{:?}", res);
62
63    assert_eq!(res, ModuleArgs::F2(def::Int(1)));
64}
65
66fn test_formal_f3() {
67    let res = ModuleArgs::parse("F(Hello)").unwrap();
68    println!("{:?}", res);
69
70    assert_eq!(res, ModuleArgs::F3(def::Expr::from("Hello")));
71}
72
73fn test_formal_f4() {
74    let res = ModuleArgs::parse("F([Ident1, Ident2])").unwrap();
75    println!("{:?}", res);
76
77    assert_eq!(res, ModuleArgs::F4(def::Array(vec![def::Expr::from("Ident1"), def::Expr::from("Ident2")])));
78}
79
80fn test_formal_f5() {
81    let res = ModuleArgs::parse("F({ imports: [Ident1, Ident2] })").unwrap();
82    println!("{:?}", res);
83
84    assert_eq!(
85        res,
86        ModuleArgs::F5(ModuleSubObj {
87            imports: def::Array(vec![def::Expr::from("Ident1"), def::Expr::from("Ident2")]),
88            global: def::Option(None),
89            sub: def::Option(None)
90        })
91    );
92}
93
94fn test_formal_f6() {
95    let res = ModuleArgs::parse("F([{ imports: [Ident1, Ident2] }, { imports: [Ident3, Ident4] }])").unwrap();
96    println!("{:?}", res);
97
98    assert_eq!(
99        res,
100        ModuleArgs::F6(def::Array(vec![
101            ModuleSubObj {
102                imports: def::Array(vec![def::Expr::from("Ident1"), def::Expr::from("Ident2")]),
103                global: def::Option(None),
104                sub: def::Option(None)
105            },
106            ModuleSubObj {
107                imports: def::Array(vec![def::Expr::from("Ident3"), def::Expr::from("Ident4")]),
108                global: def::Option(None),
109                sub: def::Option(None)
110            }
111        ]))
112    );
113}
114
115fn test_formal_f6_2() {
116    let res = ModuleArgs::parse("F([{ imports: [Ident1, Ident2], global: true }, { imports: [Ident3, Ident4] }])").unwrap();
117    println!("{:?}", res);
118
119    assert_eq!(
120        res,
121        ModuleArgs::F6(def::Array(vec![
122            ModuleSubObj {
123                imports: def::Array(vec![def::Expr::from("Ident1"), def::Expr::from("Ident2")]),
124                global: def::Option(Some(def::Bool(true))),
125                sub: def::Option(None)
126            },
127            ModuleSubObj {
128                imports: def::Array(vec![def::Expr::from("Ident3"), def::Expr::from("Ident4")]),
129                global: def::Option(None),
130                sub: def::Option(None)
131            }
132        ]))
133    );
134}
135
136fn test_formal_f6_3() {
137    let res = ModuleArgs::parse("F([{ imports: [Ident1, Ident2], global: true, sub: { value: true } }, { imports: [Ident3, Ident4] }])").unwrap();
138    println!("{:?}", res);
139
140    assert_eq!(
141        res,
142        ModuleArgs::F6(def::Array(vec![
143            ModuleSubObj {
144                imports: def::Array(vec![def::Expr::from("Ident1"), def::Expr::from("Ident2")]),
145                global: def::Option(Some(def::Bool(true))),
146                sub: def::Option(Some(Sub { value: def::Bool(true) }))
147            },
148            ModuleSubObj {
149                imports: def::Array(vec![def::Expr::from("Ident3"), def::Expr::from("Ident4")]),
150                global: def::Option(None),
151                sub: def::Option(None)
152            }
153        ]))
154    );
155}
156
157fn test_formal_f7() {
158    let res = ModuleArgs::parse("F({ s1: { value: false }, s2: { value: true } })").unwrap();
159    println!("{:?}", res);
160
161    assert_eq!(res, ModuleArgs::F7(SubWrap { s1: Sub { value: def::Bool(false) }, s2: Sub { value: def::Bool(true) } }));
162}
163
164fn test_tokens_formal_f7() {
165    let res = ModuleArgs::parse("F({ s1: { value: false }, s2: { value: true } })").unwrap();
166    println!("{:?}", res);
167
168    assert_eq!(res, ModuleArgs::F7(SubWrap { s1: Sub { value: def::Bool(false) }, s2: Sub { value: def::Bool(true) } }));
169}
170
171fn test_formal_f8() {
172    let res = ModuleArgs::parse("F({ controllers: [Ident1, Ident2] })").unwrap();
173    println!("{:?}", res);
174
175    assert_eq!(
176        res,
177        ModuleArgs::F8(def::Option(Some(T1 {
178            controllers: def::Option(Some(def::Array(vec![def::Expr::from("Ident1"), def::Expr::from("Ident2")])))
179        })))
180    );
181
182    let res = ModuleArgs::parse("F()").unwrap();
183    println!("{:?}", res);
184
185    assert_eq!(res, ModuleArgs::F8(def::Option(None)));
186}
187
188//
189fn test_value_p1() {
190    let f = Formal::new();
191
192    let args = f.parse("F(1, { a:1, b:2 })").unwrap();
193    println!("{:?}", args);
194
195    assert_eq!(
196        args.0,
197        Value::Array(def::Array(vec![
198            Value::Int(def::Int(1)),
199            Value::Object(def::Object(
200                vec![("a".to_string(), Value::Int(def::Int(1))), ("b".to_string(), Value::Int(def::Int(2)))].into_iter().collect()
201            ))
202        ]))
203    );
204}
205
206fn test_into_object_p1() {
207    let f = Formal::new();
208    let args = f.parse("F({ imports: [Ident1::register(), Ident2] })").unwrap();
209    println!("{:?}", args);
210    let res = ModuleSubObj::try_from(args).unwrap();
211
212    assert_eq!(
213        res,
214        ModuleSubObj {
215            imports: def::Array(vec![def::Expr::from("Ident1::register ()"), def::Expr::from("Ident2")]),
216            global: def::Option(None),
217            sub: def::Option(None)
218        }
219    );
220}

Trait Implementations§

Source§

impl Default for Formal

Source§

fn default() -> Self

Returns the “default value” for a type. Read more

Auto Trait Implementations§

§

impl Freeze for Formal

§

impl RefUnwindSafe for Formal

§

impl Send for Formal

§

impl Sync for Formal

§

impl Unpin for Formal

§

impl UnwindSafe for Formal

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.