Em dezembro, deparei com um artigo absolutamente notável em inglês, dedicado ao uso do sistema de tipos de idiomas para uma classe mais ampla de tarefas, para aumentar a confiabilidade dos aplicativos e facilitar a refatoração. Infelizmente, naquele momento, eu estava muito ocupado escrevendo artigos sobre AF, que era extremamente importante escrever enquanto as memórias ainda estavam frescas. Mas agora, quando lidei com essa tarefa, finalmente consegui traduzir esta nota maravilhosa. O idioma original dos exemplos é Haskell, mas eu decidi copiá-los para um grande número, para um alcance mais amplo da audiência. No entanto, a linguagem aqui é completamente sem importância, eu uso os conselhos deste artigo no desenvolvimento diário de C # e TypeScript completamente "mundanos"; portanto, se você apenas tentar escrever um código confiável e suportado, independentemente do idioma, o artigo estará no assunto.
Obrigado pela revisão e pela assistência de tradução. Hirrolot, funkill e andreevlex
Durante um período bastante longo, lutei para encontrar uma maneira simples e precisa de explicar o que é Design Orientado a Tipo ( daqui em diante - TypeDD, aprox. Trans. ). Muitas vezes eles me perguntavam: "Como você chegou a essa decisão?", Mas eu não tive uma resposta satisfatória. Tenho certeza de que isso não me veio como uma visão: eu tinha um processo de design iterativo que não obriga a obter a arquitetura "correta" do nada agora, mas até agora não consegui interpretar esse processo muito para outras pessoas.
: 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, , , ! :
-, . , , ?
-, . , , , , , .
, , . , 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 , :
: . - -, , . , , , , , .
, , : , . : - , . , 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> { ... }
, !
:
, . , . , , .
, . , . , , , .
, . - , .
, , , , . , , - . , - !
, :
, . bool , ( , , . .). , — , , ,
Result<(), Error> . , - , , .
. , , , , , , . — -.
, , : .
, " " . , , , , , . (newtype) , - .
, . , error "impossible" - — , , . , , .
, -. , , — ! , .
. , — " " — . , , , . , — ! — . , — .
, , : Type Safety Back and Forth. , . Ghosts of Departed Proofs, , , .
, , , . , — , . , TypeDD, , , , . , , . , — .
, — , .