fn __zero_std_env_has(name: String) -> Bool {
    let value: Maybe<String> = std.env.get(name)
    return value.has
}

fn __zero_std_env_get_or(name: String, fallback: String) -> String {
    let value: Maybe<String> = std.env.get(name)
    if value.has {
        return value.value
    }
    return fallback
}

fn __zero_std_env_parse_bool(name: String) -> Maybe<Bool> {
    let value: Maybe<String> = std.env.get(name)
    if value.has {
        return std.parse.parseBool(value.value)
    }
    return null
}

fn __zero_std_env_parse_u32(name: String) -> Maybe<u32> {
    let value: Maybe<String> = std.env.get(name)
    if value.has {
        return std.parse.parseU32(value.value)
    }
    return null
}

fn __zero_std_env_parse_i32(name: String) -> Maybe<i32> {
    let value: Maybe<String> = std.env.get(name)
    if value.has {
        return std.parse.parseI32(value.value)
    }
    return null
}

fn __zero_std_env_parse_usize(name: String) -> Maybe<usize> {
    let value: Maybe<String> = std.env.get(name)
    if value.has {
        return std.parse.parseUsize(value.value)
    }
    return null
}

fn __zero_std_env_equals(name: String, expected: String) -> Bool {
    let value: Maybe<String> = std.env.get(name)
    if value.has {
        return std.mem.eql(value.value, expected)
    }
    return false
}

fn __zero_std_env_parse_bool_or(name: String, fallback: Bool) -> Bool {
    let value: Maybe<Bool> = std.env.parseBool(name)
    if value.has {
        return value.value
    }
    return fallback
}

fn __zero_std_env_parse_u32_or(name: String, fallback: u32) -> u32 {
    let value: Maybe<u32> = std.env.parseU32(name)
    if value.has {
        return value.value
    }
    return fallback
}

fn __zero_std_env_parse_i32_or(name: String, fallback: i32) -> i32 {
    let value: Maybe<i32> = std.env.parseI32(name)
    if value.has {
        return value.value
    }
    return fallback
}

fn __zero_std_env_parse_usize_or(name: String, fallback: usize) -> usize {
    let value: Maybe<usize> = std.env.parseUsize(name)
    if value.has {
        return value.value
    }
    return fallback
}