Useful Rust

Transcript

3. $ cat ~/.profile GIT_AUTHOR_NAME=Florian Gilcher GIT_AUTHOR_EMAIL=florian@rustfest.eu TWITTER_HANDLE=argorak GITHUB_HANDLE=skade BLOG=skade.me YAKS=yakshav.es
4. • Backend Developer • Ruby Programmer since 2003 • Rust Programmer since 2013 • CEO asquera GmbH
5. • Community person • Rust UG Berlin/Karlsruhe • Search UG Berlin • Ex-chairman of Ruby Berlin e.V.
6. • Part of the global Rust community team • Organiser eurucamp/jrubyconf.eu • Organiser RustFest
7. Useful Rust
8. Ownership struct Meal { name: String } fn eat(m: Meal) { println!("Ate: {}", m.name); // m will be destroyed here }
9. fn eat(m: Meal) { println!("Ate: {}", m.name); drop(m) }
10. fn eat(m: Meal) { let mut mutated = m; mutated.name = String::from("Godzilla & Chips"); println!("Ate: {}", mutated.name); drop(m) }
11. This is also called "consuming".
12. Traits trait Edible { fn eat(self); fn describe(&self); }
13. impl Edible for Meal { fn eat(self) { println!("Ate: {}", self.name); } fn describe(&self) { println!("This is: {}", self.name); } }
14. fn main() { let meal = Meal { name: String::from("Fish & Chips") }; meal.describe(); meal.eat(); meal.eat(); //~^ ERROR use of moved value: `meal` }
15. Generics fn eat_anything<F: Edible>(f: F) { f.eat(); }
16. fn eat_anything<F>(f: F) where F: Edible { f.eat(); }
17. Generic calls are monomorphised and have no runtime overhead.
18. struct Course<F: Edible> { items: Vec<F> }
19. Items must be homogenous.
20. Errors and Results
21. We call algebraic datatypes "enums".
22. enum Option<T> { Some(T), None }
23. enum Result<T, E> { Ok(T), Err(E) }
24. Enough theory
25. Example: JSON
26. decode json_string :: Maybe MyData
27. “ Hey, describe me the data in the way we both know best, and I will derive the rest.”
28. extern crate serde_json; // define MyApiMessage fn main() { use serde_json::from_str; let res = from_str::<MyApiMessage>("..."); }
29. • Uses internal type information • Fails early if the received message is unknown • Does not raise exceptions
30. Who likes checked exceptions?
31. I do
32. fn main() { use serde_json::from_str; let res = from_str::<MyApiMessage>("..."); match res { Ok(message) => ..., Err(e) => println!("Error: {}", e) } }
33. Rust ships with a lot of machinery around converting errors, though...
34. pub trait From<T>: Sized { fn from(T) -> Self; }
35. impl From<MyApiMessage> for MyDomainModel { fn from(T) -> Self { // here be alpaca } }
36. fn main() { use serde_json::from_str; let res = from_str::<MyApiMessage>("...") .and_then(|message|{ MyDomainModel::from(message) }) //~^ WARNING: unused result which must be used }
37. Checking the compiler: compile-test https://is.gd/compiletest
38. fn main() { use serde_json::from_str; let res = from_str::<MyApiMessage>("...") .and_then(|message|{ MyDomainModel::from(message) }) //~^ WARNING: unused result which must be used }
39. It’s not unusual for libraries to have test suites for the cases that should error/warn at complain time.
40. It’s not unusual for libraries to have test suites for the cases that should error/warn at compile time.
41. Example: CouchDB replication
42. CouchDB Replication protocol https://is.gd/couchdbrep
43. Describes the process to replicate a source database to a target database.
44. Replicator pub struct Replicator { source: String, target: String }
45. fn main() { let r = Replicator { source: "source_name".into(), target: "target_name".into() } }
46. Inconvenient • Initialisation depending on exact structure • Struct fields are by default private, this is not going to work outside of the defining module.
47. Seperation of functions and state impl Replicator { pub fn new(s: String, t: String) -> Replicator { Replicator { source: s, target: t } } }
48. fn main() { let r = Replicator::new( "source_name".into(), "target_name".into() ); }
49. This is still a bit inconvenient Can we get rid of the into() calls?
50. impl Replicator { pub fn new<S,T>(source: S, target: T) -> Replicator where S: Into<String>, T: Into<String> { Replicator { source: source.into(), target: target.into() } } }
51. fn main() { let r = Replicator::new("source_name", "target_name"); }
52. The VerifyPeers steps Given a replicator between two databases: • Check source existence • Check target existence • Create target if absent • Done
53. Can we describe that in Rust?
54. Defining states pub struct Start; pub struct SourceExisting; pub struct TargetExisting; pub struct TargetAbsent; pub struct VerifiedPeers;
55. A stateful wrapper pub struct VerifyPeers<T> { replicator: Replicator, state: T }
56. impl<S> VerifyPeers<S> { pub fn transition<X>(self, new_state: X) -> VerifyPeers<X> { VerifyPeers { replicator: self.replicator, state: new_state } } }
57. let replicator = Replicator::new("source_name", "target_name"); let verification = VerifyPeers::new(replicator); let end = verification .transition(SourceExisting) .transition(TargetExisting) .transition(VerifiedPeers);
58. Safety gains
59. let replicator = Replicator::new("source_name", "target_name"); let verification = VerifyPeers::new(replicator); let end = verification .transition(SourceExisting) .transition(TargetExisting) .transition(VerifiedPeers); verification.transition(SourceExisting); //~^ ERROR use of moved value: `verification`
60. Obvious flaws
61. Nonsensical transitions struct Counter { count: i32 } fn main() { let r = Replicator::new("source", "target"); let v = VerifyPeers::new(r); let counter = Counter { count: 0 }; let end = v .transition(counter); }
62. Illegal transitions let end = verification .transition(VerifiedPeers) .transition(SourceExisting);
63. Marking states pub trait State {} impl State for Start {} impl State for SourceExisting {} impl State for TargetExisting {} impl State for TargetAbsent {} impl State for VerifiedPeers {}
64. Constraining to States impl<S: State> VerifyPeers<S> { pub fn transition<X>(self, new_state: X) -> VerifyPeers<X> where X: State { VerifyPeers { replicator: self.replicator, state: new_state } } }
65. Now failing struct Counter { count: i32 } fn main() { let r = Replicator::new("source", "target"); let v = VerifyPeers::new(r); let counter = Counter { count: 0 }; let end = v .transition(counter); }
66. “ the trait bound Counter: statemachines::State is not satisfied”
67. Constraining Transitions Rust conversion traits: • From, TryFrom • Into, TryInto Use is very common!
68. We can use them to model state transitions.
69. impl From<Start> for SourceExisting { fn from(_: Start) -> SourceExisting { SourceExisting } }
70. We implement in the same fashion: • SourceExisting -> TargetAbsent • SourceExisting -> TargetExisting • TargetAbsent -> TargetExisting • TargetExisting -> VerifiedPeers
71. impl<S: State> VerifyPeers<S> { pub fn transition<X>(self, new_state: X) -> VerifyPeers<X> where X: State + From<S> { VerifyPeers { replicator: self.replicator, state: new_state } } }
72. Now failing fn main() { let r = Replicator::new("source", "target"); let v = VerifyPeers::new(r); let end = v .transition(VerifiedPeers); }
73. “ the trait bound statemachines::VerifiedPeers: std::con- vert::From<statemachines::Start> is not satisfied”
74. “ I was promised Useful Rust and all I got was a lousy state machine!”
75. How do we implement work? type Error = String;
76. impl VerifyPeers<Start> { pub fn check_source_existence(self) -> Result<VerifyPeers<SourceExisting>, Error> { if try!(check_source_existence()) { Ok(self.transition(SourceExisting)) } else { Err("Source doesn’t exist!".into()) } } }
77. Horray, we also got the failure state!
78. How do we implement a branch? pub enum TargetChecked { TargetExists(VerifyPeers<TargetExisting>), TargetAbsent(VerifyPeers<TargetAbsent>) }
79. impl VerifyPeers<SourceExisting> { pub fn check_target_existence(self) -> Result<TargetChecked, Error> { if try!(target_exists()) { Ok(self.transition(TargetExisting)) } else { Ok(self.transition(TargetAbsent)) } } }
80. extern crate statemachines; use statemachines::*; fn main() { let r = Replicator::new("source", "target"); let v = VerifyPeers::new(r); let end = v .check_source_existence() .and_then(|state| { state.check_target_existence() }).and_then(|state| { //... }
81. .and_then(|state| { match state { TargetChecked::TargetExists(s) => { s.finish() } TargetChecked::TargetAbsent(s) => { try!(s.create_target()).finish() } } });
82. Free This abstraction is free!
83. • Fully at compile-time • Vanishes at runtime
84. A bit of low-level #[test] fn verify_peers_not_larger_then_replicator() { use std::mem::size_of; assert_eq!(size_of::<VerifyPeers<Start>>(), size_of::<Replicator>()) }
85. Final comments
86. • We’re exclusively using static dis- patch • The whole state machine is on the stack
87. • This pattern extends well and also works with, e.g. Futures instead of Results • Other implementations are possible
88. Real-world: Laze RS Experimental CouchDB toolkit, see: http://laze.rs
89. Conclusion Rust is sufficiently useful for patterns beyond the main focus to emerge.
90. Rust is focused on usability • Usability is tough if you want fine- grained control for the user • In systems programming, usability is not champion
91. Interview If you have a Rust project, private or commercial, I’d like to interview you.
92. twitter.com/argorak
93. http://community.rs/ community-team@rust-lang.org rust-lang.org
94. Links • https://is.gd/statepatterns • https://is.gd/2017vision