Option/Maybe Type Pattern

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// Rust's Option type (from std::option)
pub enum Option<T> {
    Some(T),  // Contains a value
    None,     // No value
}
 
// Usage examples
fn find_user_by_email(email: &str) -> Option<User> {
    // Returns Some(user) if found, None if not
    users.iter().find(|u| u.email == email).cloned()
}
 
fn main() {
    let maybe_user = find_user_by_email("alice@example.com");
    
    // Pattern matching forces handling both cases
    match maybe_user {
        Some(user) => println!("Found: {}", user.name),
        None => println!("User not found"),
    }
    
    // if let for when you only care about Some
    if let Some(user) = find_user_by_email("bob@example.com") {
        send_notification(&user);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

// Option: when absence is expected, not an error
fn find_in_cache(&self, key: &str) -> Option<&CacheEntry> {
    self.entries.get(key)  // Cache miss is normal
}
 
fn first(&self) -> Option<&T> {
    self.items.get(0)  // Empty collection is valid
}
 
fn find_matching(&self, predicate: impl Fn(&T) -> bool) -> Option<&T> {
    self.items.iter().find(|x| predicate(x))  // No match is fine
}
 
// Result: when absence is a failure requiring explanation
fn load_user(&self, id: UserId) -> Result<User, LoadUserError> {
    // We need to distinguish: not found vs db error vs permission error
    let row = self.db.query_one(/* ... */)
        .map_err(|e| match e {
            DbError::NotFound => LoadUserError::NotFound(id),
            DbError::Connection(c) => LoadUserError::Database(c),
            DbError::Permission => LoadUserError::Unauthorized,
        })?;
    
    Ok(User::from_row(row))
}
 
fn parse_config(&self, path: &Path) -> Result<Config, ConfigError> {
    // Multiple failure modes that caller must handle differently
    let contents = fs::read_to_string(path)
        .map_err(|e| ConfigError::IoError(path.to_owned(), e))?;
    
    let config: Config = serde_json::from_str(&contents)
        .map_err(|e| ConfigError::ParseError(e))?;
    
    self.validate(&config)?;
    
    Ok(config)
}
 
// Converting between Option and Result
fn get_required_config(&self, key: &str) -> Result<String, ConfigError> {
    self.get_optional_config(key)  // Returns Option<String>
        .ok_or_else(|| ConfigError::MissingKey(key.to_string()))
}
 
fn try_get_user(&self, id: UserId) -> Option<User> {
    self.load_user(id).ok()  // Discard error info, just get Option
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

// Filtering Nones with filter_map
let strings = vec!["1", "two", "3", "four", "5"];
let numbers: Vec<i32> = strings
    .iter()
    .filter_map(|s| s.parse::<i32>().ok())  // Parse, keep only successful
    .collect();
// numbers = [1, 3, 5]
 
// Same with .flatten() after map
let numbers: Vec<i32> = strings
    .iter()
    .map(|s| s.parse::<i32>().ok())  // Iterator<Item = Option<i32>>
    .flatten()                         // Iterator<Item = i32>
    .collect();
 
// Collecting where ANY None fails the whole thing
let strings = vec!["1", "2", "3"];
let all_numbers: Option<Vec<i32>> = strings
    .iter()
    .map(|s| s.parse::<i32>().ok())
    .collect();  // Returns None if any parse fails
// all_numbers = Some([1, 2, 3])
 
let strings = vec!["1", "oops", "3"];
let all_numbers: Option<Vec<i32>> = strings
    .iter()
    .map(|s| s.parse::<i32>().ok())
    .collect();
// all_numbers = None (because "oops" failed)
 
// Finding first Some
let attempts = vec![
    try_server_a(),  // Option<Connection>
    try_server_b(),
    try_server_c(),
];
let connection: Option<Connection> = attempts.into_iter().flatten().next();
 
// Or lazily (short-circuits on first success)
let connection = try_server_a()
    .or_else(|| try_server_b())
    .or_else(|| try_server_c());
 
// Transpose: Option<Vec<T>> <-> Vec<Option<T>>
let options: Vec<Option<i32>> = vec![Some(1), Some(2), Some(3)];
let transposed: Option<Vec<i32>> = options.into_iter().collect();
// Some([1, 2, 3])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

// Kotlin: Types are non-null by default
fun processUser(user: User) {  // user cannot be null
    println(user.name)  // Always safe
}
 
// Nullable types use ?
fun findUser(id: Long): User? {  // Might return null
    return database.findById(id)
}
 
// Compiler enforces null handling
fun greetUser(id: Long) {
    val user: User? = findUser(id)
    
    // This won't compile:
    // println(user.name)  // Error: user might be null
    
    // These work:
    println(user?.name)           // Prints null or name
    println(user?.name ?: "Guest")  // Prints name or "Guest"
    
    if (user != null) {
        println(user.name)  // Smart cast: compiler knows user is non-null here
    }
    
    user?.let { 
        println(it.name)  // user is non-null inside let block
    }
}
 
// Platform types (from Java interop) are uncertain
fun handleJavaReturn() {
    val result: String = javaMethod()  // Might crash if Java returns null!
    val safe: String? = javaMethod()   // Treat as nullable to be safe
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

// ❌ Anti-pattern: Blind unwrap
fn get_config_value(key: &str) -> String {
    config.get(key).unwrap()  // Will panic if key missing!
}
 
// ✅ Better: Handle the None case
fn get_config_value(key: &str) -> String {
    config.get(key)
        .cloned()
        .unwrap_or_else(|| format!("default_for_{}", key))
}
 
// ❌ Anti-pattern: Option<Option<T>>
struct User {
    // What does None mean? No preference? Or preference is "no favorite"?
    favorite_color: Option<Option<Color>>,
}
 
// ✅ Better: Model the states explicitly
enum ColorPreference {
    Unknown,      // We don't know their preference
    NoFavorite,   // They explicitly have no favorite
    Favorite(Color),  // They have a favorite
}
 
// ❌ Anti-pattern: Using None as error
fn parse_number(s: &str) -> Option<i32> {
    s.parse().ok()  // Loses all error information
}
 
// ✅ Better: Use Result when failure has meaning
fn parse_number(s: &str) -> Result<i32, ParseError> {
    s.parse().map_err(|_| ParseError::InvalidNumber(s.to_string()))
}
 
// ❌ Anti-pattern: Immediately unwrapping
let user = find_user(id);
if user.is_some() {
    let u = user.unwrap();  // Wasteful check + unwrap
    process(u);
}
 
// ✅ Better: Use pattern matching
if let Some(user) = find_user(id) {
    process(user);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

// Options in data structures
struct SearchQuery {
    term: String,
    category: Option<Category>,      // Optional filter
    min_price: Option<Money>,
    max_price: Option<Money>,
    sort_by: Option<SortField>,
}
 
impl SearchQuery {
    fn apply_filters(&self, items: Vec<Item>) -> Vec<Item> {
        items.into_iter()
            .filter(|item| {
                self.category
                    .as_ref()
                    .map_or(true, |cat| item.category == *cat)
            })
            .filter(|item| {
                self.min_price
                    .as_ref()
                    .map_or(true, |min| item.price >= *min)
            })
            .filter(|item| {
                self.max_price
                    .as_ref()
                    .map_or(true, |max| item.price <= *max)
            })
            .collect()
    }
}
 
// Options as function parameters for optional behavior
fn connect(
    host: &str, 
    port: u16, 
    timeout: Option<Duration>,   // Optional timeout
    certificate: Option<&Path>,  // Optional client cert
) -> Result<Connection, Error> {
    let mut builder = ConnectionBuilder::new(host, port);
    
    if let Some(t) = timeout {
        builder = builder.timeout(t);
    }
    
    if let Some(cert) = certificate {
        builder = builder.with_cert(cert)?;
    }
    
    builder.connect()
}
 
// Option zip — combine two Options
let name: Option<String> = Some("Alice".to_string());
let age: Option<u32> = Some(30);
 
let combined: Option<(String, u32)> = name.zip(age);
// Some(("Alice", 30))
 
// If either is None, result is None
let name: Option<String> = Some("Bob".to_string());
let age: Option<u32> = None;
let combined = name.zip(age);  // None