@@ -66,11 +66,9 @@ fn recurse(typ: CallTyp) -> Filter {
66
66
impl Ctx {
67
67
/// `{}[]` returns zero values.
68
68
fn empty ( & mut self ) -> Filter {
69
- // `{}`
70
- let obj = Filter :: Object ( Default :: default ( ) ) ;
71
69
// `[]`
72
70
let path = ( path:: Part :: Range ( None , None ) , path:: Opt :: Essential ) ;
73
- Filter :: Path ( self . id_of_ast ( obj ) , Path ( Vec :: from ( [ path] ) ) )
71
+ Filter :: Path ( self . id_of_ast ( Filter :: ObjEmpty ) , Path ( Vec :: from ( [ path] ) ) )
74
72
}
75
73
76
74
/// `..`, also known as `recurse/0`, is defined as `., (.[]? | ..)`
@@ -128,31 +126,52 @@ impl Ctx {
128
126
AbsId ( len)
129
127
}
130
128
129
+ fn get ( & mut self , f : Spanned < mir:: Filter > ) -> AbsId {
130
+ let f = self . filter ( f) ;
131
+ self . id_of_ast ( f)
132
+ }
133
+
134
+ fn add ( & mut self , l : Filter , r : Filter ) -> Filter {
135
+ Filter :: Math ( self . id_of_ast ( l) , MathOp :: Add , self . id_of_ast ( r) )
136
+ }
137
+
138
+ fn of_str ( & mut self , s : Str < Spanned < mir:: Filter > > ) -> Filter {
139
+ let fmt = s. fmt . map_or ( TOSTRING , |fmt| self . get ( * fmt) ) ;
140
+ use jaq_syn:: string:: Part ;
141
+ let iter = s. parts . into_iter ( ) . map ( |part| match part {
142
+ Part :: Str ( s) => Filter :: Str ( s) ,
143
+ Part :: Fun ( f) => Filter :: Pipe ( self . get ( f) , false , fmt) ,
144
+ } ) ;
145
+ let mut iter = iter. collect :: < Vec < _ > > ( ) . into_iter ( ) . rev ( ) ;
146
+ let last = iter. next ( ) . unwrap_or_else ( || Filter :: Str ( "" . into ( ) ) ) ;
147
+ iter. fold ( last, |acc, x| self . add ( x, acc) )
148
+ }
149
+
150
+ fn of_key_val ( & mut self , kv : KeyVal < Spanned < mir:: Filter > > ) -> Filter {
151
+ match kv {
152
+ KeyVal :: Filter ( k, v) => Filter :: ObjSingle ( self . get ( k) , self . get ( v) ) ,
153
+ KeyVal :: Str ( k, v) => {
154
+ let k = self . of_str ( k) ;
155
+ let k = self . id_of_ast ( k) ;
156
+ let v = match v {
157
+ None => {
158
+ self . id_of_ast ( Filter :: Path ( IDENTITY , Path :: from ( path:: Part :: Index ( k) ) ) )
159
+ }
160
+ Some ( v) => self . get ( v) ,
161
+ } ;
162
+ Filter :: ObjSingle ( k, v)
163
+ }
164
+ }
165
+ }
166
+
131
167
/// Convert a MIR filter to a LIR filter.
132
168
fn filter ( & mut self , f : Spanned < mir:: Filter > ) -> Filter {
133
- let get = |f, ctx : & mut Self | {
134
- let f = ctx. filter ( f) ;
135
- ctx. id_of_ast ( f)
136
- } ;
137
- let of_str = |s : Str < _ > , ctx : & mut Self | {
138
- let fmt = s. fmt . map_or ( TOSTRING , |fmt| get ( * fmt, ctx) ) ;
139
- use jaq_syn:: string:: Part ;
140
- let iter = s. parts . into_iter ( ) . map ( |part| match part {
141
- Part :: Str ( s) => Filter :: Str ( s) ,
142
- Part :: Fun ( f) => Filter :: Pipe ( get ( f, ctx) , false , fmt) ,
143
- } ) ;
144
- let mut iter = iter. collect :: < Vec < _ > > ( ) . into_iter ( ) . rev ( ) ;
145
- let last = iter. next ( ) ;
146
- iter. fold ( last. unwrap_or_else ( || Filter :: Str ( "" . into ( ) ) ) , |acc, x| {
147
- Filter :: Math ( ctx. id_of_ast ( x) , MathOp :: Add , ctx. id_of_ast ( acc) )
148
- } )
149
- } ;
150
169
use mir:: Filter as Expr ;
151
170
152
171
match f. 0 {
153
172
Expr :: Var ( v) => Filter :: Var ( v) ,
154
173
Expr :: Call ( call, args) => {
155
- let args: Vec < _ > = args. into_iter ( ) . map ( |a| get ( a, self ) ) . collect ( ) ;
174
+ let args: Vec < _ > = args. into_iter ( ) . map ( |a| self . get ( a) ) . collect ( ) ;
156
175
match call {
157
176
mir:: Call :: Arg ( a) if args. is_empty ( ) => Filter :: Var ( a) ,
158
177
mir:: Call :: Arg ( _) => panic ! ( "higher-order argument encountered" ) ,
@@ -180,38 +199,26 @@ impl Ctx {
180
199
}
181
200
182
201
Expr :: Fold ( typ, Fold { xs, init, f, .. } ) => {
183
- Filter :: Fold ( typ, get ( * xs, self ) , get ( * init, self ) , get ( * f, self ) )
202
+ Filter :: Fold ( typ, self . get ( * xs) , self . get ( * init) , self . get ( * f) )
184
203
}
185
204
186
205
Expr :: Id => Filter :: Id ,
187
206
Expr :: Num ( hir:: Num :: Float ( f) ) => Filter :: Float ( f) ,
188
207
Expr :: Num ( hir:: Num :: Int ( i) ) => Filter :: Int ( i) ,
189
- Expr :: Str ( s) => of_str ( * s, self ) ,
190
- Expr :: Array ( a) => Filter :: Array ( a. map_or ( EMPTY , |a| get ( * a, self ) ) ) ,
208
+ Expr :: Str ( s) => self . of_str ( * s) ,
209
+ Expr :: Array ( a) => Filter :: Array ( a. map_or ( EMPTY , |a| self . get ( * a) ) ) ,
191
210
Expr :: Object ( o) => {
192
- let kvs = o. into_iter ( ) . map ( |kv| match kv {
193
- KeyVal :: Filter ( k, v) => ( get ( k, self ) , get ( v, self ) ) ,
194
- KeyVal :: Str ( k, v) => {
195
- let k = of_str ( k, self ) ;
196
- let k = self . id_of_ast ( k) ;
197
- let v = match v {
198
- None => self . id_of_ast ( Filter :: Path (
199
- IDENTITY ,
200
- Path :: from ( path:: Part :: Index ( k) ) ,
201
- ) ) ,
202
- Some ( v) => get ( v, self ) ,
203
- } ;
204
- ( k, v)
205
- }
206
- } ) ;
207
- Filter :: Object ( kvs. collect ( ) )
211
+ let kvs = o. into_iter ( ) . map ( |kv| self . of_key_val ( kv) ) ;
212
+ let mut kvs = kvs. collect :: < Vec < _ > > ( ) . into_iter ( ) . rev ( ) ;
213
+ let last = kvs. next ( ) . unwrap_or ( Filter :: ObjEmpty ) ;
214
+ kvs. fold ( last, |acc, x| self . add ( x, acc) )
208
215
}
209
- Expr :: Try ( f) => Filter :: Try ( get ( * f, self ) , EMPTY ) ,
210
- Expr :: Neg ( f) => Filter :: Neg ( get ( * f, self ) ) ,
216
+ Expr :: Try ( f) => Filter :: Try ( self . get ( * f) , EMPTY ) ,
217
+ Expr :: Neg ( f) => Filter :: Neg ( self . get ( * f) ) ,
211
218
Expr :: Recurse => recurse ( CallTyp :: Catch ) ,
212
219
213
220
Expr :: Binary ( l, op, r) => {
214
- let ( l, r) = ( get ( * l, self ) , get ( * r, self ) ) ;
221
+ let ( l, r) = ( self . get ( * l) , self . get ( * r) ) ;
215
222
match op {
216
223
BinaryOp :: Pipe ( bind) => Filter :: Pipe ( l, bind. is_some ( ) , r) ,
217
224
BinaryOp :: Comma => Filter :: Comma ( l, r) ,
@@ -229,20 +236,20 @@ impl Ctx {
229
236
Expr :: Ite ( if_thens, else_) => {
230
237
let else_ = else_. map_or ( Filter :: Id , |else_| self . filter ( * else_) ) ;
231
238
if_thens. into_iter ( ) . rev ( ) . fold ( else_, |acc, ( if_, then_) | {
232
- Filter :: Ite ( get ( if_, self ) , get ( then_, self ) , self . id_of_ast ( acc) )
239
+ Filter :: Ite ( self . get ( if_) , self . get ( then_) , self . id_of_ast ( acc) )
233
240
} )
234
241
}
235
242
Expr :: TryCatch ( try_, catch_) => {
236
- Filter :: Try ( get ( * try_, self ) , catch_. map_or ( EMPTY , |c| get ( * c, self ) ) )
243
+ Filter :: Try ( self . get ( * try_) , catch_. map_or ( EMPTY , |c| self . get ( * c) ) )
237
244
}
238
245
Expr :: Path ( f, path) => {
239
- let f = get ( * f, self ) ;
246
+ let f = self . get ( * f) ;
240
247
use jaq_syn:: path:: Part ;
241
248
let path = path. into_iter ( ) . map ( |( p, opt) | match p {
242
- Part :: Index ( i) => ( path:: Part :: Index ( get ( i, self ) ) , opt) ,
249
+ Part :: Index ( i) => ( path:: Part :: Index ( self . get ( i) ) , opt) ,
243
250
Part :: Range ( lower, upper) => {
244
- let lower = lower. map ( |f| get ( f, self ) ) ;
245
- let upper = upper. map ( |f| get ( f, self ) ) ;
251
+ let lower = lower. map ( |f| self . get ( f) ) ;
252
+ let upper = upper. map ( |f| self . get ( f) ) ;
246
253
( path:: Part :: Range ( lower, upper) , opt)
247
254
}
248
255
} ) ;
0 commit comments