iframe-proxy | Sunbelt Computer Software

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

use std::error::Error as StdError;

use std::fmt::{self, Error};

use std::num::ParseIntError;

use std::ops::Not;

/**

In rust there is no such things like [runtime] errors. In case an Error happens is consider a [Panic] error type

and is not recoverable, so the Thread will die.

For any other possible side-effect that might happen when we interact with real world, rust provide by design

a Monad Error Transformer called [Result] which we can use to map error and compose them, or just pass the successful value.

Just like a monad it's allow you to use all common functional operations.

fn result_effect() {

let result: Result<String, Error> = Result::Ok("hello world").map(|v| v.to_uppercase());

match result {

Ok(v) => println!("{}", v.to_string()),

_ => println!("Side effect found"),

}

#[derive(Debug)]

struct ErrorFold{}

fn fold_effect(){

let result= Ok::<String, ErrorFold>(String::from("Hello "))

.into_iter()

.fold(Ok(String::from(" Mate")), |r:Result<String, ErrorFold>, acc| return Ok(acc.to_string() + &r.unwrap().to_string()));

println!("{:?}", result);

}

/**

Rust does not allow produce NULL values by design. So in case we need to express absence of value,

We can use Option type.

In rust String API we can concat some operators to transform the String into Option type.

fn option_effect(value: &str) {

let option: Option<String> = value

.is_empty()

.not()

.then(|| value)

.map(|v| v.to_uppercase());

match option {

Some(v) => println!("{}", v.to_string()),

None => println!("No element found "),

}

/**

Using operator [?] is sugar syntax to unwrap the happy path values from [Option] and [Result]

But compiler will force you to return same Result type in function, just in case of [Error] or [None]

fn extract_result_effect() -> Result<String, Error> {

let result = get_result_type()?;

println!("{}", result);

Ok(result)

}

fn get_result_type() -> Result<String, Error> {

Ok(String::from("hello Result effect"))

}

/**

In the example of option using [?] we dont have a value so the lines 64,65 never are executed, and

we return the [Option] with [None] value

fn extract_option_effect() -> Option<String> {

let result = get_option_type()?;

println!("{}", result);

Some(result)

}

fn get_option_type() -> Option<String> {

None

}

/**

Traverse can be performance by compiler magically just changing the order of types, when we use a type inside the [map]

In this example same iterator it can produce a [Result] of [Vector], or a [Vector] of [Results].

All this magic is thanks to [collect] operator, which it force you to specify types when you define your output,

just to performance the traverse transformation in compilation time.

fn traverse_feature() {

let result: Result<Vec<String>, TextError> = vec!["hello", "effect", "world"]

.into_iter()

.map(|text| {

if text.len() > 3 {

Ok(text.to_uppercase())

} else {

Err(TextError)

}

})

.collect();

println!("{:?}", result.is_ok());

}

/**

Same iteration implementation than previous function, but just changing the type order.

fn traverse_feature_swap() {

let result: Vec<Result<String, TextError>> = vec!["hello", "effect", "world"]

.into_iter()

.map(|text| {

if text.len() > 3 {

Ok(text.to_uppercase())

} else {

Err(TextError)

}

})

.collect();

println!("{:?}", result.len());

}

struct TextError;

// Idiomatic error handling

//-------------------------

#[derive(Clone, Copy, Debug, Eq, PartialEq)]

struct Port(u16);

impl Port {

fn value(self) -> u16 {

self.0

}

#[derive(Debug)]

enum ConfigError {

MissingValue,

InvalidNumber(ParseIntError),

ReservedPort(u16),

}

impl fmt::Display for ConfigError {

fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {

match self {

ConfigError::MissingValue => formatter.write_str("missing port value"),

ConfigError::InvalidNumber(error) => write!(formatter, "invalid port: {}", error),

ConfigError::ReservedPort(port) => {

write!(formatter, "port {} is reserved for the system", port)

}

impl StdError for ConfigError {

fn source(&self) -> Option<&(dyn StdError + 'static)> {

match self {

ConfigError::InvalidNumber(error) => Some(error),

_ => None,

}

impl From<ParseIntError> for ConfigError {

fn from(error: ParseIntError) -> Self {

ConfigError::InvalidNumber(error)

}

/**

Instead of panic or unwrap, expose precise domain errors. The `?` operator is still used,

but the parse error is converted into ConfigError through the From implementation.

fn parse_port(raw: Option<&str>) -> Result<Port, ConfigError> {

let port = raw.ok_or(ConfigError::MissingValue)?.parse::<u16>()?;

if port < 1024 {

return Err(ConfigError::ReservedPort(port));

}

Ok(Port(port))

}

fn idiomatic_error_handling() -> Result<u16, ConfigError> {

let port = parse_port(Some("8080"))?;

println!("Configured port: {}", port.value());

Ok(port.value())

}

#[cfg(test)]

mod error_handling_tests {

use super::*;

#[test]

pub fn run() {

fold_effect();

result_effect();

option_effect("hello option monad");

option_effect("");

extract_result_effect();

extract_option_effect();

traverse_feature();

traverse_feature_swap();

if let Err(error) = idiomatic_error_handling() {

eprintln!("Config parsing failed: {}", error);

}

#[test]

fn rejects_reserved_ports_without_panicking() {

assert!(matches!(

parse_port(Some("80")),

Err(ConfigError::ReservedPort(80))

));

}

Sunbelt Computer Software

PL/B Language Development and Support

Navigation Menu

Repository navigation

effect_system.rs

effect_system.rs

Sunbelt Computer Software

PL/B Language Development and Support

FilesExpand file tree

effect_system.rs

Latest commit

History

effect_system.rs

File metadata and controls