Kembali pada bulan Desember, saya menemukan satu artikel yang benar-benar luar biasa dalam bahasa Inggris, yang ditujukan untuk penggunaan sistem jenis bahasa untuk kelas tugas yang lebih luas, untuk meningkatkan keandalan aplikasi dan kemudahan refactoring. Sayangnya, pada saat itu saya terlalu sibuk menulis artikel tentang AF, yang sangat penting untuk ditulis ketika ingatannya masih segar. Tetapi sekarang, ketika saya mengatasi tugas ini, saya akhirnya berkeliling untuk menerjemahkan catatan yang indah ini. Bahasa asli dari contoh-contoh tersebut adalah Haskell, tetapi saya memutuskan untuk menyalinnya ke sebuah rast, untuk jangkauan audiens yang lebih luas. Namun, bahasa di sini benar-benar tidak penting, tips dari artikel ini saya gunakan dalam pengembangan sehari-hari pada C # dan TypScript "biasa", jadi jika Anda hanya mencoba untuk menulis kode yang dapat diandalkan dan didukung, maka, terlepas dari bahasa, artikel tersebut akan berada dalam subjek.

Terima kasih atas bantuan proofreading dan terjemahan. Hirrolot, funkill dan dan refleks

Selama periode waktu yang cukup lama, saya berjuang untuk menemukan cara yang akurat dan sederhana untuk menjelaskan apa itu Type-Driven Design ( selanjutnya - TypeDD, kira-kira Trans. ). Cukup sering mereka bertanya kepada saya, "Bagaimana Anda membuat keputusan seperti itu?", Tetapi saya tidak memiliki jawaban yang memuaskan. Saya tahu pasti bahwa itu tidak datang kepada saya sebagai sebuah visi: Saya memiliki proses desain berulang yang tidak mengharuskan saya untuk mendapatkan arsitektur yang "benar" dari ketiadaan saat ini, tetapi sejauh ini saya belum terlalu mampu menafsirkan proses ini untuk orang lain.

: JSON , , . , , , TypeDD, , , :

, .

TypeDD

, : TypeDD, , , . , . , , , .

, , , " ?". :

enum Void {}

fn foo(x: i32) -> Void

? , — , .. Void — , , Void. , , :

fn head<T>(xs: Vec<T>) -> T

. ? , - , , :

fn head<T>(xs: Vec<T>) -> T {
    match xs.as_slice() {
        [x, ..] => *x
    }
}

error[E0004]: non-exhaustive patterns: `&[]` not covered
 --> src/lib.rs:2:11
  |
2 |     match xs.as_slice() {
  |           ^^^^^^^^^^^^^ pattern `&[]` not covered
  |

, , , . , , [], . , .. , , , ! , , , ( , . .).

- . , . , " " - , . head, , .

, head , .. : , . , : . , , , , : , , . Rust Option:

fn head<T>(xs: Vec<T>) -> Option<T>

, head — None, , T:

fn head<T>(xs: Vec<T>) -> Option<T> {
    match xs.as_slice() {
        [x, ..] => Some(*x),
        [] => None,
    }
}

, ? , — … .

Option, , , head. . head None, , . , :

fn get_configuration_directories() -> Result<Vec<String>, &'static str> {
    let config_dirs_string = std::env::var("CONFIG_DIRS").map_err(|_| "cannot read env")?;
    let list: Vec<_> = config_dirs_string.split(',').map(|x| x.to_string()).collect();
    if list.is_empty() {
        return Err("CONFIG_DIRS cannot be empty");
    }
    Ok(list)
}

fn main() -> Result<(), &'static str> {
    let config_dirs = get_configuration_directories()?;
    match head(config_dirs) {
        Some(cacheDir) => initialize_cache(cacheDir),
        None => panic!("should never happen; already checked config_dirs is non-empty")
    }
    Ok(())
}

get_configuration_directories , . head main, , Option<&str> None, , , ! :

1. -, . , , ?

   
   

2. -, . , , , , , .

   
   

3. , , . , get_configuration_directories , , , ? , main, "" , .

   
   

. None , get_configuration_directories .
, , .

, head , . , - : , , head , , , . ?

() head .

fn head<T>(xs: Vec<T>) -> T

, . , , : ( — Vec<T>). , head .

, , .
, NonEmptyVec . :

struct NonEmptyVec<T>(T, Vec<T>);

, NonEmptyVec — T (, ) Vec<T>. , Vec<T> [], . , head :

fn head<T>(xs: NonEmptyVec<T>) -> T {
    xs.0
}

, , , , . :

fn get_configuration_directories() -> Result<NonEmptyVec<String>, &'static str> {
    let config_dirs_string = std::env::var("CONFIG_DIRS").map_err(|_| "cannot read env")?;
    let list: Vec<_> = config_dirs_string.split(',').map(|x| x.to_string()).collect();
    match non_empty(list) {
        Some(x) => Ok(x),
        None => Err("CONFIG_DIRS cannot be empty")
    }
}

fn main() -> Result<(), &'static str> {
    let config_dirs = get_configuration_directories()?;
    initialize_cache(head(config_dirs));
    Ok(())
}

, main ! , get_configuration_directories. NonEmptyVec Vec non_empty, :

fn non_empty<T>(list: Vec<T>) -> Option<NonEmptyVec<T>>

, Option , None : . , NonEmptyVec, ( !) , . , NonEmptyVec Vec<T> , .

head , :

• , .

  
  

• , get_configuration_directories , . , main , !

  
  

, head , non_empty:

fn old_head<T>(xs: Vec<T>) -> Option<T> {
    non_empty(xs).map(head)
}

, : head . , .

? , — , , . , : , , . :

fn validate_non_empty<T>(xs: Vec<T>) -> Result<(), UserError> {
    if !xs.is_empty() {
        Ok(())
    } else {
        Err(UserError::new("list cannot be empty"))
    }
}

fn parse_non_empty<T>(mut xs: Vec<T>) -> Result<NonEmptyVec<T>, UserError> {
    if !xs.is_empty() {
        let head = xs.remove(0);
        Ok(NonEmptyVec(head, xs))
    } else {
        Err(UserError::new("list cannot be empty"))
    }
}

: , , . : validate_non_empty (), , , parse_non_empty NonEmptyVec<T>, , . , parse_non_empty , validate_non_empty .

: validate_non_empty , parse_non_empty , . , parse_non_empty , , ", ". parse_non_empty. - , ? , , , , parse_non_empty , .

: ? , , , . , — — , - . , , , parse_non_empty : , .

: , , , ! Rust , :

• serde_json from_str JSON

  
  

• clap -

  
  

• diesel , .

  
  

• actix-web Rust , , HTTP .

  
  

: . - -, , . , , , , , .

, , : , . : - , . , NonEmpty : , .

, , , . , ? , , , ?

, . Ad-hoc , - . 2016 The Seven Turrets of Babel: A Taxonomy of LangSec Errors and How to Expunge Them :

— , , , ; , ( - ), "" .

, :

, . , - , .

, , , , , , , . — , , , — .

, — , , . , , , , "" . , , .

, : , , , . , .

, ,

, . ", , !", , , . "" "", "".

: .

, , , , , - . — , , :

fn check_no_duplicate_keys<K: Eq, V>(xs: &[(K,V)]) { ... }

"" — : . - , , , . , , , HashMap. , HashMap , , .

, , , , , . - , HashMap . , , , . check_no_duplicate_keys:

fn check_no_duplicate_keys<K: Eq, V>(xs: &[(K,V)]) -> HashMap<K,V> { ... }

, !

:

1. , . , . , , .

   
   

2. , . , . , , , .

   
   

   , . - , .

   
   

, , , , . , , - . , - !

, :

• , . bool , ( , , . .). , — , , ,

  
  

• Result<(), Error> . , - , , .

  
  

• . , , , , , , . — -.

  
  

• , , : .

  
  
  • . , , , .
  
  

• , " " . , , , , , . (newtype) , - .

  
  

, . , error "impossible" - — , , . , , .

, -. , , — ! , .

. , — " " — . , , , . , — ! — . , — .

, , : Type Safety Back and Forth. , . Ghosts of Departed Proofs, , , .

, , , . , — , . , TypeDD, , , , . , , . , — .

, — , .