commit 0d2cc0e813b8aa42bd6d90c56fb7e9ff6c69b88c · drubery.com/icfp2007

+7

dna2rna/Cargo.lock

···

       5
       5
        
       [[package]]

     

       6
       6
        
       name = "dna2rna"

     

       7
       7
        
       version = "0.1.0"

     

       8
       8
       +
       dependencies = [

     

       9
       9
       +
        "dna_parsing",

     

       10
       10
       +
       ]

     

       11
       11
       +
       

     

       12
       12
       +
       [[package]]

     

       13
       13
       +
       name = "dna_parsing"

     

       14
       14
       +
       version = "0.1.0"

+1

dna2rna/Cargo.toml

···

       4
       4
        
       edition = "2024"

     

       5
       5
        
       

     

       6
       6
        
       [dependencies]

     

       7
       7
       +
       dna_parsing = { path = "../dna_parsing" }

+1 -29

dna2rna/src/dna.rs

···

       1
       1
       +
       use dna_parsing::base::Base;

     

       1
       2
        
       use std::collections::VecDeque;

     

       2
       3
        
       use std::ops::Add;

     

       3
       4
        
       use std::ops::AddAssign;

     

       4
       5
        
       use std::ops::Deref;

     

       5
       6
        
       use std::ops::Index;

     

       6
       7
        
       use std::rc::Rc;

     

       7
       7
       -
       

     

       8
       8
       -
       #[derive(Copy, Clone, PartialEq, Debug)]

     

       9
       9
       -
       pub enum Base {

     

       10
       10
       -
           I,

     

       11
       11
       -
           C,

     

       12
       12
       -
           F,

     

       13
       13
       -
           P,

     

       14
       14
       -
       }

     

       15
       8
        
       

     

       16
       9
        
       #[derive(Clone, Debug)]

     

       17
       10
        
       pub enum Dna {

     
···

       39
       32
        
           len: usize,

     

       40
       33
        
           depth: usize,

     

       41
       34
        
           children: (DnaRef, DnaRef, DnaRef),

     

       42
       42
       -
       }

     

       43
       43
       -
       

     

       44
       44
       -
       impl Base {

     

       45
       45
       -
           pub fn from_char(c: char) -> Option<Base> {

     

       46
       46
       -
               match c {

     

       47
       47
       -
                   'I' => Some(Base::I),

     

       48
       48
       -
                   'C' => Some(Base::C),

     

       49
       49
       -
                   'F' => Some(Base::F),

     

       50
       50
       -
                   'P' => Some(Base::P),

     

       51
       51
       -
                   _ => None,

     

       52
       52
       -
               }

     

       53
       53
       -
           }

     

       54
       54
       -
       

     

       55
       55
       -
           pub fn to_char(&self) -> char {

     

       56
       56
       -
               match self {

     

       57
       57
       -
                   Base::I => 'I',

     

       58
       58
       -
                   Base::C => 'C',

     

       59
       59
       -
                   Base::F => 'F',

     

       60
       60
       -
                   Base::P => 'P',

     

       61
       61
       -
               }

     

       62
       62
       -
           }

     

       63
       35
        
       }

     

       64
       36
        
       

     

       65
       37
        
       impl DnaRef {

+3 -1

dna2rna/src/match_replace.rs

···

       1
       1
       -
       use crate::dna::Base;

     

       2
       1
        
       use crate::dna::DnaRef;

     

       3
       2
        
       use crate::parser::Parser;

     

       4
       3
        
       use crate::pattern::Pattern;

     

       5
       4
        
       use crate::pattern::PatternItem;

     

       6
       5
        
       use crate::rna::Rna;

     

       7
       6
        
       use crate::template::TemplateItem;

     

       7
       7
       +
       use dna_parsing::base::Base;

     

       8
       8
        
       

     

       9
       9
        
       struct MatchResult {

     

       10
       10
        
           end: usize,

     
···

       122
       122
        
           let pattern = parser.pattern(rna)?;

     

       123
       123
        
           let template = parser.template(rna)?;

     

       124
       124
        
           let index = parser.index();

     

       125
       125
       +
       

     

       126
       126
       +
           println!("{} ; {} ;", &pattern, &template);

     

       125
       127
        
       

     

       126
       128
        
           if let Some(matched) = do_match(&dna, index, pattern) {

     

       127
       129
        
               let mut replace = DnaRef::new();

+1 -1

dna2rna/src/parser.rs

···

       1
       1
       -
       use crate::dna::Base;

     

       2
       1
        
       use crate::pattern::Pattern;

     

       3
       2
        
       use crate::pattern::PatternItem;

     

       4
       3
        
       use crate::rna::Rna;

     

       5
       4
        
       use crate::template::Template;

     

       6
       5
        
       use crate::template::TemplateItem;

     

       6
       6
       +
       use dna_parsing::base::Base;

     

       7
       7
        
       use std::mem;

     

       8
       8
        
       

     

       9
       9
        
       pub struct Parser<I>

+1 -1

dna2rna/src/pattern.rs

···

       1
       1
       -
       use crate::dna::Base;

     

       1
       1
       +
       use dna_parsing::base::Base;

     

       2
       2
        
       use std::fmt;

     

       3
       3
        
       use std::slice;

     

       4
       4
        
       use std::vec;

+1 -1

dna2rna/src/rna.rs

···

       1
       1
       -
       use crate::dna::Base;

     

       1
       1
       +
       use dna_parsing::base::Base;

     

       2
       2
        
       

     

       3
       3
        
       pub type Rna = [Base; 7];

+1 -1

dna2rna/src/template.rs

···

       1
       1
       -
       use crate::dna::Base;

     

       1
       1
       +
       use dna_parsing::base::Base;

     

       2
       2
        
       use std::fmt;

     

       3
       3
        
       use std::slice;

     

       4
       4
        
       use std::vec;

+1

dna_parsing/.dir-locals.el

···

       1
       1
       +
       ((nil . ((default-directory . "~/repos/endo/dna_parsing/"))))

+7

dna_parsing/Cargo.lock

···

       1
       1
       +
       # This file is automatically @generated by Cargo.

     

       2
       2
       +
       # It is not intended for manual editing.

     

       3
       3
       +
       version = 4

     

       4
       4
       +
       

     

       5
       5
       +
       [[package]]

     

       6
       6
       +
       name = "dna_parsing"

     

       7
       7
       +
       version = "0.1.0"

+6

dna_parsing/Cargo.toml

···

       1
       1
       +
       [package]

     

       2
       2
       +
       name = "dna_parsing"

     

       3
       3
       +
       version = "0.1.0"

     

       4
       4
       +
       edition = "2024"

     

       5
       5
       +
       

     

       6
       6
       +
       [dependencies]

+28

dna_parsing/src/base.rs

···

       1
       1
       +
       #[derive(Copy, Clone, PartialEq, Debug)]

     

       2
       2
       +
       pub enum Base {

     

       3
       3
       +
           I,

     

       4
       4
       +
           C,

     

       5
       5
       +
           F,

     

       6
       6
       +
           P,

     

       7
       7
       +
       }

     

       8
       8
       +
       

     

       9
       9
       +
       impl Base {

     

       10
       10
       +
           pub fn from_char(c: char) -> Option<Base> {

     

       11
       11
       +
               match c {

     

       12
       12
       +
                   'I' => Some(Base::I),

     

       13
       13
       +
                   'C' => Some(Base::C),

     

       14
       14
       +
                   'F' => Some(Base::F),

     

       15
       15
       +
                   'P' => Some(Base::P),

     

       16
       16
       +
                   _ => None,

     

       17
       17
       +
               }

     

       18
       18
       +
           }

     

       19
       19
       +
       

     

       20
       20
       +
           pub fn to_char(&self) -> char {

     

       21
       21
       +
               match self {

     

       22
       22
       +
                   Base::I => 'I',

     

       23
       23
       +
                   Base::C => 'C',

     

       24
       24
       +
                   Base::F => 'F',

     

       25
       25
       +
                   Base::P => 'P',

     

       26
       26
       +
               }

     

       27
       27
       +
           }

     

       28
       28
       +
       }

+1

dna_parsing/src/lib.rs

···

       1
       1
       +
       pub mod base;