commit 8d1ad245536b8dd55fae8ab3c50c98f365810d54 · drubery.com/icfp2007

+80 -20

dna2rna/src/dna.rs

···

       1
        
       use std::collections::VecDeque;

     

       2
        
       use std::ops::Add;

     

       0
        
       
     

       3
        
       use std::ops::Deref;

     

       4
        
       use std::ops::Index;

     

       5
        
       use std::rc::Rc;

     
···

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

     

       136
        
                       if n < a.len() {

     

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

     

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

     

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

     

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

     

       141
        
                       } else {

     

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

     

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

     

       144
        
                       }

     

       145
        
                   }

     

       146
        
                   Dna::ThreeNode(node) => {

     

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

     

       148
        
                       if n < a.len() {

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       158
        
                       } else {

     

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

     

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

     

       161
        
                       }

     

       162
        
                   }

     

       163
        
               }

     
···

       281
        
           Two(DnaRef, DnaRef),

     

       282
        
       }

     

       283
        
       

     

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

     

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

     

       286
       -
               AddState::Two(lhs, rhs)

     

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

     

       288
       -
               match &*rhs {

     

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

     

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

     

       291
        
                   Dna::TwoNode(node) => {

     

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

     

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

     

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

     

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

     

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

     
···

       299
        
                   }

     

       300
        
                   Dna::ThreeNode(node) => {

     

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

     

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

     

       303
        
                           AddState::One(x) => {

     

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

     

       305
        
                           }

     
···

       311
        
                   }

     

       312
        
               }

     

       313
        
           } else {

     

       314
       -
               match &*lhs {

     

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

     

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

     

       317
        
                   Dna::TwoNode(node) => {

     

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

     

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

     

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

     

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

     

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

     
···

       325
        
                   }

     

       326
        
                   Dna::ThreeNode(node) => {

     

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

     

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

     

       329
        
                           AddState::One(x) => {

     

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

     

       331
        
                           }

     
···

       339
        
           }

     

       340
        
       }

     

       341
        
       

     

       342
       -
       impl Add for DnaRef {

     

       343
       -
           type Output = Self;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       344
        
       

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       346
        
               match add_helper(self, other) {

     

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

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       349
        
               }

     

       350
        
           }

     

       351
        
       }

···

       1
        
       use std::collections::VecDeque;

     

       2
        
       use std::ops::Add;

     

       3
       +
       use std::ops::AddAssign;

     

       4
        
       use std::ops::Deref;

     

       5
        
       use std::ops::Index;

     

       6
        
       use std::rc::Rc;

     
···

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

     

       137
        
                       if n < a.len() {

     

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

     

       139
       +
                           (x, y + b)

     

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

     

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

     

       142
        
                       } else {

     

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

     

       144
       +
                           (a + x, y)

     

       145
        
                       }

     

       146
        
                   }

     

       147
        
                   Dna::ThreeNode(node) => {

     

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

     

       149
        
                       if n < a.len() {

     

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

     

       151
       +
                           (x, y + b + c)

     

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

     

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

     

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

     

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

     

       156
       +
                           (a + x, y + c)

     

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

     

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

     

       159
        
                       } else {

     

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

     

       161
       +
                           (a + b + x, y)

     

       162
        
                       }

     

       163
        
                   }

     

       164
        
               }

     
···

       282
        
           Two(DnaRef, DnaRef),

     

       283
        
       }

     

       284
        
       

     

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

     

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

     

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

     

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

     

       289
       +
               match &**rhs {

     

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

     

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

     

       292
        
                   Dna::TwoNode(node) => {

     

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

     

       294
       +
                       match add_helper(lhs, a) {

     

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

     

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

     

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

     
···

       300
        
                   }

     

       301
        
                   Dna::ThreeNode(node) => {

     

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

     

       303
       +
                       match add_helper(lhs, a) {

     

       304
        
                           AddState::One(x) => {

     

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

     

       306
        
                           }

     
···

       312
        
                   }

     

       313
        
               }

     

       314
        
           } else {

     

       315
       +
               match &**lhs {

     

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

     

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

     

       318
        
                   Dna::TwoNode(node) => {

     

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

     

       320
       +
                       match add_helper(b, rhs) {

     

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

     

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

     

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

     
···

       326
        
                   }

     

       327
        
                   Dna::ThreeNode(node) => {

     

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

     

       329
       +
                       match add_helper(c, rhs) {

     

       330
        
                           AddState::One(x) => {

     

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

     

       332
        
                           }

     
···

       340
        
           }

     

       341
        
       }

     

       342
        
       

     

       343
       +
       impl Add<DnaRef> for DnaRef {

     

       344
       +
           type Output = DnaRef;

     

       345
       +
       

     

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

     

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

     

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

     

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

     

       350
       +
               }

     

       351
       +
           }

     

       352
       +
       }

     

       353
        
       

     

       354
       +
       impl Add<&DnaRef> for DnaRef {

     

       355
       +
           type Output = DnaRef;

     

       356
       +
       

     

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

     

       358
       +
               match add_helper(&self, other) {

     

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

     

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

     

       361
       +
               }

     

       362
       +
           }

     

       363
       +
       }

     

       364
       +
       

     

       365
       +
       impl Add<DnaRef> for &DnaRef {

     

       366
       +
           type Output = DnaRef;

     

       367
       +
       

     

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

     

       369
       +
               match add_helper(self, &other) {

     

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

     

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

     

       372
       +
               }

     

       373
       +
           }

     

       374
       +
       }

     

       375
       +
       

     

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

     

       377
       +
           type Output = DnaRef;

     

       378
       +
       

     

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

     

       380
        
               match add_helper(self, other) {

     

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

     

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

     

       383
       +
               }

     

       384
       +
           }

     

       385
       +
       }

     

       386
       +
       

     

       387
       +
       impl AddAssign<DnaRef> for DnaRef {

     

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

     

       389
       +
               match add_helper(self, &other) {

     

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

     

       391
       +
                       *self = a;

     

       392
       +
                   }

     

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

     

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

     

       395
       +
                   }

     

       396
       +
               }

     

       397
       +
           }

     

       398
       +
       }

     

       399
       +
       

     

       400
       +
       impl AddAssign<&DnaRef> for DnaRef {

     

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

     

       402
       +
               match add_helper(self, other) {

     

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

     

       404
       +
                       *self = a;

     

       405
       +
                   }

     

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

     

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

     

       408
       +
                   }

     

       409
        
               }

     

       410
        
           }

     

       411
        
       }

+3 -4

dna2rna/src/match_replace.rs

···

       128
        
               for t in template.into_iter() {

     

       129
        
                   match t {

     

       130
        
                       TemplateItem::Base(b) => {

     

       131
       -
                           // TODO: Implement AddAssign

     

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

     

       133
        
                       }

     

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

     

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

     

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

     

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

     

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

     

       139
        
                       }

     

       140
        
                       TemplateItem::Len(n) => {

     

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

     

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

     

       143
        
                       }

     

       144
        
                   }

     

       145
        
               }

···

       128
        
               for t in template.into_iter() {

     

       129
        
                   match t {

     

       130
        
                       TemplateItem::Base(b) => {

     

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

     

       0
        
       
     

       132
        
                       }

     

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

     

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

     

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

     

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

     

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

     

       138
        
                       }

     

       139
        
                       TemplateItem::Len(n) => {

     

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

     

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

     

       142
        
                       }

     

       143
        
                   }

     

       144
        
               }