commit 8d1ad245536b8dd55fae8ab3c50c98f365810d54 · drubery.com/icfp2007

+80 -20

dna2rna/src/dna.rs

···

       1
       1
        
       use std::collections::VecDeque;

     

       2
       2
        
       use std::ops::Add;

     

       3
       3
       +
       use std::ops::AddAssign;

     

       3
       4
        
       use std::ops::Deref;

     

       4
       5
        
       use std::ops::Index;

     

       5
       6
        
       use std::rc::Rc;

     
···

       135
       136
        
                       let (a, b) = &node.children;

     

       136
       137
        
                       if n < a.len() {

     

       137
       138
        
                           let (x, y) = a.split(n);

     

       138
       138
       -
                           (x, y + b.clone())

     

       139
       139
       +
                           (x, y + b)

     

       139
       140
        
                       } else if n == a.len() {

     

       140
       141
        
                           (a.clone(), b.clone())

     

       141
       142
        
                       } else {

     

       142
       143
        
                           let (x, y) = b.split(n - a.len());

     

       143
       143
       -
                           (a.clone() + x, y)

     

       144
       144
       +
                           (a + x, y)

     

       144
       145
        
                       }

     

       145
       146
        
                   }

     

       146
       147
        
                   Dna::ThreeNode(node) => {

     

       147
       148
        
                       let (a, b, c) = &node.children;

     

       148
       149
        
                       if n < a.len() {

     

       149
       150
        
                           let (x, y) = a.split(n);

     

       150
       150
       -
                           (x, y + b.clone() + c.clone())

     

       151
       151
       +
                           (x, y + b + c)

     

       151
       152
        
                       } else if n == a.len() {

     

       152
       152
       -
                           (a.clone(), b.clone() + c.clone())

     

       153
       153
       +
                           (a.clone(), b + c)

     

       153
       154
        
                       } else if n - a.len() < b.len() {

     

       154
       155
        
                           let (x, y) = b.split(n - a.len());

     

       155
       155
       -
                           (a.clone() + x, y + c.clone())

     

       156
       156
       +
                           (a + x, y + c)

     

       156
       157
        
                       } else if n == a.len() + b.len() {

     

       157
       157
       -
                           (a.clone() + b.clone(), c.clone())

     

       158
       158
       +
                           (a + b, c.clone())

     

       158
       159
        
                       } else {

     

       159
       160
        
                           let (x, y) = c.split(n - a.len() - b.len());

     

       160
       160
       -
                           (a.clone() + b.clone() + x, y)

     

       161
       161
       +
                           (a + b + x, y)

     

       161
       162
        
                       }

     

       162
       163
        
                   }

     

       163
       164
        
               }

     
···

       281
       282
        
           Two(DnaRef, DnaRef),

     

       282
       283
        
       }

     

       283
       284
        
       

     

       284
       284
       -
       fn add_helper(lhs: DnaRef, rhs: DnaRef) -> AddState {

     

       285
       285
       +
       fn add_helper(lhs: &DnaRef, rhs: &DnaRef) -> AddState {

     

       285
       286
        
           if lhs.depth() == rhs.depth() {

     

       286
       286
       -
               AddState::Two(lhs, rhs)

     

       287
       287
       +
               AddState::Two(lhs.clone(), rhs.clone())

     

       287
       288
        
           } else if lhs.depth() < rhs.depth() {

     

       288
       288
       -
               match &*rhs {

     

       289
       289
       +
               match &**rhs {

     

       289
       290
        
                   Dna::Empty => unreachable!(),

     

       290
       290
       -
                   Dna::Leaf(_) => AddState::One(rhs),

     

       291
       291
       +
                   Dna::Leaf(_) => AddState::One(rhs.clone()),

     

       291
       292
        
                   Dna::TwoNode(node) => {

     

       292
       293
        
                       let (a, b) = &node.children;

     

       293
       293
       -
                       match add_helper(lhs, a.clone()) {

     

       294
       294
       +
                       match add_helper(lhs, a) {

     

       294
       295
        
                           AddState::One(x) => AddState::One(DnaRef::from_two_children(x, b.clone())),

     

       295
       296
        
                           AddState::Two(x, y) => {

     

       296
       297
        
                               AddState::One(DnaRef::from_three_children(x, y, b.clone()))

     
···

       299
       300
        
                   }

     

       300
       301
        
                   Dna::ThreeNode(node) => {

     

       301
       302
        
                       let (a, b, c) = &node.children;

     

       302
       302
       -
                       match add_helper(lhs, a.clone()) {

     

       303
       303
       +
                       match add_helper(lhs, a) {

     

       303
       304
        
                           AddState::One(x) => {

     

       304
       305
        
                               AddState::One(DnaRef::from_three_children(x, b.clone(), c.clone()))

     

       305
       306
        
                           }

     
···

       311
       312
        
                   }

     

       312
       313
        
               }

     

       313
       314
        
           } else {

     

       314
       314
       -
               match &*lhs {

     

       315
       315
       +
               match &**lhs {

     

       315
       316
        
                   Dna::Empty => unreachable!(),

     

       316
       317
        
                   Dna::Leaf(_) => AddState::One(lhs.clone()),

     

       317
       318
        
                   Dna::TwoNode(node) => {

     

       318
       319
        
                       let (a, b) = &node.children;

     

       319
       319
       -
                       match add_helper(b.clone(), rhs) {

     

       320
       320
       +
                       match add_helper(b, rhs) {

     

       320
       321
        
                           AddState::One(x) => AddState::One(DnaRef::from_two_children(a.clone(), x)),

     

       321
       322
        
                           AddState::Two(x, y) => {

     

       322
       323
        
                               AddState::One(DnaRef::from_three_children(a.clone(), x, y))

     
···

       325
       326
        
                   }

     

       326
       327
        
                   Dna::ThreeNode(node) => {

     

       327
       328
        
                       let (a, b, c) = &node.children;

     

       328
       328
       -
                       match add_helper(c.clone(), rhs) {

     

       329
       329
       +
                       match add_helper(c, rhs) {

     

       329
       330
        
                           AddState::One(x) => {

     

       330
       331
        
                               AddState::One(DnaRef::from_three_children(a.clone(), b.clone(), x))

     

       331
       332
        
                           }

     
···

       339
       340
        
           }

     

       340
       341
        
       }

     

       341
       342
        
       

     

       342
       342
       -
       impl Add for DnaRef {

     

       343
       343
       -
           type Output = Self;

     

       343
       343
       +
       impl Add<DnaRef> for DnaRef {

     

       344
       344
       +
           type Output = DnaRef;

     

       345
       345
       +
       

     

       346
       346
       +
           fn add(self, other: DnaRef) -> DnaRef {

     

       347
       347
       +
               match add_helper(&self, &other) {

     

       348
       348
       +
                   AddState::One(a) => a,

     

       349
       349
       +
                   AddState::Two(a, b) => DnaRef::from_two_children(a, b),

     

       350
       350
       +
               }

     

       351
       351
       +
           }

     

       352
       352
       +
       }

     

       344
       353
        
       

     

       345
       345
       -
           fn add(self, other: Self) -> Self {

     

       354
       354
       +
       impl Add<&DnaRef> for DnaRef {

     

       355
       355
       +
           type Output = DnaRef;

     

       356
       356
       +
       

     

       357
       357
       +
           fn add(self, other: &DnaRef) -> DnaRef {

     

       358
       358
       +
               match add_helper(&self, other) {

     

       359
       359
       +
                   AddState::One(a) => a,

     

       360
       360
       +
                   AddState::Two(a, b) => DnaRef::from_two_children(a, b),

     

       361
       361
       +
               }

     

       362
       362
       +
           }

     

       363
       363
       +
       }

     

       364
       364
       +
       

     

       365
       365
       +
       impl Add<DnaRef> for &DnaRef {

     

       366
       366
       +
           type Output = DnaRef;

     

       367
       367
       +
       

     

       368
       368
       +
           fn add(self, other: DnaRef) -> DnaRef {

     

       369
       369
       +
               match add_helper(self, &other) {

     

       370
       370
       +
                   AddState::One(a) => a,

     

       371
       371
       +
                   AddState::Two(a, b) => DnaRef::from_two_children(a, b),

     

       372
       372
       +
               }

     

       373
       373
       +
           }

     

       374
       374
       +
       }

     

       375
       375
       +
       

     

       376
       376
       +
       impl Add<&DnaRef> for &DnaRef {

     

       377
       377
       +
           type Output = DnaRef;

     

       378
       378
       +
       

     

       379
       379
       +
           fn add(self, other: &DnaRef) -> DnaRef {

     

       346
       380
        
               match add_helper(self, other) {

     

       347
       381
        
                   AddState::One(a) => a,

     

       348
       348
       -
                   AddState::Two(a, b) => Self::from_two_children(a, b),

     

       382
       382
       +
                   AddState::Two(a, b) => DnaRef::from_two_children(a, b),

     

       383
       383
       +
               }

     

       384
       384
       +
           }

     

       385
       385
       +
       }

     

       386
       386
       +
       

     

       387
       387
       +
       impl AddAssign<DnaRef> for DnaRef {

     

       388
       388
       +
           fn add_assign(&mut self, other: DnaRef) {

     

       389
       389
       +
               match add_helper(self, &other) {

     

       390
       390
       +
                   AddState::One(a) => {

     

       391
       391
       +
                       *self = a;

     

       392
       392
       +
                   }

     

       393
       393
       +
                   AddState::Two(a, b) => {

     

       394
       394
       +
                       *self = Self::from_two_children(a, b);

     

       395
       395
       +
                   }

     

       396
       396
       +
               }

     

       397
       397
       +
           }

     

       398
       398
       +
       }

     

       399
       399
       +
       

     

       400
       400
       +
       impl AddAssign<&DnaRef> for DnaRef {

     

       401
       401
       +
           fn add_assign(&mut self, other: &DnaRef) {

     

       402
       402
       +
               match add_helper(self, other) {

     

       403
       403
       +
                   AddState::One(a) => {

     

       404
       404
       +
                       *self = a;

     

       405
       405
       +
                   }

     

       406
       406
       +
                   AddState::Two(a, b) => {

     

       407
       407
       +
                       *self = Self::from_two_children(a, b);

     

       408
       408
       +
                   }

     

       349
       409
        
               }

     

       350
       410
        
           }

     

       351
       411
        
       }

+3 -4

dna2rna/src/match_replace.rs

···

       128
       128
        
               for t in template.into_iter() {

     

       129
       129
        
                   match t {

     

       130
       130
        
                       TemplateItem::Base(b) => {

     

       131
       131
       -
                           // TODO: Implement AddAssign

     

       132
       132
       -
                           replace = replace + DnaRef::from_base(b);

     

       131
       131
       +
                           replace += DnaRef::from_base(b);

     

       133
       132
        
                       }

     

       134
       133
        
                       TemplateItem::Ref(n, l) => {

     

       135
       134
        
                           let (start, end) = matched.groups[n];

     

       136
       135
        
                           let (_, rhs) = dna.split(start);

     

       137
       136
        
                           let (group, _) = rhs.split(end - start);

     

       138
       138
       -
                           replace = replace + protect(group, l);

     

       137
       137
       +
                           replace += protect(group, l);

     

       139
       138
        
                       }

     

       140
       139
        
                       TemplateItem::Len(n) => {

     

       141
       140
        
                           let (start, end) = matched.groups[n];

     

       142
       142
       -
                           replace = replace + asnat(end - start);

     

       141
       141
       +
                           replace += asnat(end - start);

     

       143
       142
        
                       }

     

       144
       143
        
                   }

     

       145
       144
        
               }