{"id":219,"date":"2024-05-07T18:39:00","date_gmt":"2024-05-07T18:39:00","guid":{"rendered":"https:\/\/permutationcity.co.uk\/bp\/?p=219"},"modified":"2024-07-27T08:52:29","modified_gmt":"2024-07-27T08:52:29","slug":"rust","status":"publish","type":"post","link":"https:\/\/permutationcity.co.uk\/bp\/2024\/05\/07\/rust\/","title":{"rendered":"Rust"},"content":{"rendered":"\n

I heard about Rust’s unusual approach to memory management and thought have a look.\nProgramming Rust<\/a> from O’Reilly\nis chunky at about 700 pages and has taken a while to get through but does seem to cover all the bases.\nI’ve not gone as far as coding in this language so this will just be my opinion looking in from the outside.<\/p>\n\n\n\n

Rust<\/a> is a modern general purpose programming language.\nIf your familiar with C++, C# or Java then you’re going to see a lot of familiar things here:\ndata abstraction and encapsulation, generics, closers and libraries.\nHowever there’s a big difference: variable ownership and lifetimes.<\/p>\n\n\n\n

Ownership and lifetime<\/h2>\n\n\n\n

Rust doesn’t have explicit deletion of pointer objects nor does it have garbage collection.\nInstead the ownership of a variable is tracked throughout it’s lifetime.\nThis ensure that the variable destroyed or “dropped” when appropriate and\nthat nothing can access that variable when it is unsafe to do so.\nThe language enforces strict rules about access to each variable or it’s references.\nEither a single mutable references can be “borrowed” or multiple constant references, but never both at once.\nReferences to a variable can only be borrowed by something with a greater lifetime,\ndangling pointers cannot occur.\nSometimes Rust can infer the lifetime of variables but\nyou may need to add explicit markers to ensure certain variables have matching lifetimes.\nIt looks a bit like adding template parameters to something.\nVariables are allocated on the stack by default but, if you want to use the heap,\nyou can create a Box<T><\/code><\/a> similar to\nstd::unique_ptr<\/code><\/a>.\nAssignment is a move operation by default which transfers ownership.<\/p>\n\n\n\n

This is all about making code safe by default.\nConcurrency is much easier because lots of unsafe options are just disallowed.\nErrors occur at build time and must be fixed to compile the code.\nI can see this is beneficial in safety critical systems where you have to get it right the first time.\nHowever it also make everything that might<\/em> be an error a build time error\nincluding situations that will never occur in practice.\nIt feels like you will always have to go the extra mile to make correct code even if you don’t want to.\nI think this could be a problem if your goals and how to achieve them is unclear or if things change along the way.\nI am normally for doing things correctly but this makes me wary.\nBalancing things needs both sides to be available to make choices.\nFor all the good that it brings it also seems to remove choice.<\/p>\n\n\n\n

Crates and modules<\/h2>\n\n\n\n

Crates and packages<\/a> \nare Rust’s answer for sharing code between projects.\nThese can contain both fully compiled code and generics that must be combined with other code before compilation.\nModules<\/a>\nare it’s answer to organising source files internally and separating private and public access.\nUnlike other languages I’ve seen it makes the simplifying assumption that everything within a module\ncan access everything else within a module, even if it is otherwise private.\nThis means that, say, any test code in the module has free access.\nIf you want things to stay private then put it in another module.<\/p>\n\n\n\n

Testing and documentation systems are built in.\nTest functions just have to be marked up with an attribute, #[test]<\/code>, to be included in the unit-test.\nDocumentation is marked with a triple slash, \/\/\/<\/code><\/a>.\nBy default all code snippets within documentation will also be run as unit-tests to ensure correctness.\nThis does make things simple but it could mean a lack of alternative systems.<\/p>\n\n\n\n

Matching and patterns<\/h2>\n\n\n\n

We’re all familiar with the switch-statement.\nRust doesn’t have those, it has\nmatch-statements<\/a>.<\/p>\n\n\n\n

match point {\n    Point { x: 0, y: 0 } => println!("At origin"),\n    Point { x: 0, y } => println!("On x-axis, y = {}", y),\n    Point { x, y: 0 } => println!("On y-axis, x = {}", x),\n    Point { x, y } => println! ("x = {}, y = {}", x, y)\n}<\/pre><\/div>\n\n\n\n
A match-statement can do everything that a switch-statement can do and more.\nIt uses “patterns<\/a>”\nto check for specific combinations of types and values.\nPartial matches mean you can capture variables and then use those in the response code.\nIt works with literals, ranges, variables, slices, structs and can include arbitrary guard conditions.\nI think this could be a great alternative to some complicated compound if-statements.<\/p>\n\n\n\n
Pattern can be used elsewhere, accepting and potentially checking values.<\/p>\n\n\n\n
let Track { name, artist_id, .. } = song;\n...\nif let Some(artist) = artist_map.get(&artist_id) {\n    ...\n}<\/pre><\/div>\n\n\n\n
In simple assignment you can pick out some fields from a struct and ignore the rest.\nIn a function argument you can decompose a struct into it’s fields.\nTo me decomposing a struct into individual values can be overused.\nIt makes sense when you have an unnamed tuple as you are adding value.\nHowever a normal struct already has perfectly good names which can be referenced.<\/p>\n\n\n\n
In an if-statement you can check the value is in the expected form.\nThis is far more interesting and fits well with how Rust reports errors.\nFunctions that can fail either return std::option<\/code><\/a> or\nstd::result<\/code><\/a> both of which have a value if successful and\nthe latter the reason behind any failure.<\/p>\n\n\n\n
Generics and traits<\/h2>\n\n\n\n
There is the support for generic<\/a>\nclasses and functions you’d expect to see.\nThere is also support for “traits<\/a>”\nwhich are similar to C#’s interfaces.\nA single class can implement multiple traits allowing it to be used anywhere that trait is required.\nOn the other side you can implement a function and\nrequire a specific set of traits be available on the input parameters.<\/p>\n\n\n\n
Looping and iterators<\/h2>\n\n\n\n
Only while-loops and for-loops are available.\nThe first combining neatly with patterns.\nThe second made easy to use with direct support for numeric ranges and\na range of collections and iterator adapters:<\/p>\n\n\n\n