Functional syntax highlighting for rust

projects/Markdown/RustPosting.md

@@ -0,0 +1,206 @@
+# Rustposting
+
+Some example code with some potential problem characters:
+
+```rust
+let newline_string = "hello \n world";
+let thing = *newline_string;
+```
+
+Here is some example rust code:
+
+```rust
+fn main() {
+    // Statements here are executed when the compiled binary is called.
+
+    // Print text to the console
+    println!("Hello World!");
+}
+```
+
+And a slightly less trivial example:
+
+```rust
+fn main() {
+    // Variables can be type annotated.
+    let logical: bool = true;
+
+    let a_float: f64 = 1.0;  // Regular annotation
+    let an_integer   = 5i32; // Suffix annotation
+
+    // Or a default will be used.
+    let default_float   = 3.0; // 
+    let default_integer = 7;   // 
+
+    // A type can also be inferred from context.
+    let mut inferred_type = 12; // Type i64 is inferred from another line.
+    inferred_type = 4294967296i64;
+
+    // A mutable variable's value can be changed.
+    let mut mutable = 12; // Mutable 
+    mutable = 21;
+
+    // Error! The type of a variable can't be changed.
+    mutable = true;
+
+    // Variables can be overwritten with shadowing.
+    let mutable = true;
+
+    /* Compound types - Array and Tuple */
+
+    // Array signature consists of Type T and length as [T; length].
+    let my_array: [i32; 5] = [1, 2, 3, 4, 5];
+
+    // Tuple is a collection of values of different types 
+    // and is constructed using parentheses ().
+    let my_tuple = (5u32, 1u8, true, -5.04f32);
+}
+```
+
+Toss in some type definitions to
+
+```rust
+#[derive(Debug)]
+struct Person {
+    name: String,
+    age: u8,
+}
+
+// A unit struct
+struct Unit;
+
+// A tuple struct
+struct Pair(i32, f32);
+
+enum WebEvent {
+    // An  variant may either be 
+    PageLoad,
+    PageUnload,
+    // like tuple structs,
+    KeyPress(char),
+    Paste(String),
+    // or c-like structures.
+    Click { x: i64, y: i64 },
+}
+
+struct Point {
+    x: f64,
+    y: f64,
+}
+
+// Implementation block, all  associated functions & methods go in here
+impl Point {
+    // This is an "associated function" because this function is associated with
+    // a particular type, that is, Point.
+    //
+    // Associated functions don't need to be called with an instance.
+    // These functions are generally used like constructors.
+    fn origin() -> Point {
+        Point { x: 0.0, y: 0.0 }
+    }
+
+    // Another associated function, taking two arguments:
+    fn new(x: f64, y: f64) -> Point {
+        Point { x: x, y: y }
+    }
+}
+
+```
+
+
+Modules and imports
+
+```rust
+#![allow(unused_variables)]
+
+use deeply::nested::function as other_function;
+use std::fs::File;
+
+fn function() {
+    println!("called function()");
+}
+
+mod deeply {
+    pub mod nested {
+        pub fn function() {
+            println!("called deeply::nested::function()");
+        }
+    }
+}
+
+struct Val {
+    val: f64,
+}
+
+struct GenVal<T> {
+    gen_val: T,
+}
+
+// impl of Val
+impl Val {
+    fn value(&self) -> &f64 {
+        &self.val
+    }
+}
+
+impl<T> GenVal<T> {
+    fn value(&self) -> &T {
+        &self.gen_val
+    }
+}
+
+let a = Box::new(5i32);
+
+macro_rules! say_hello {
+    () => {
+        // The macro will expand into the contents of this block.
+        println!("Hello!")
+    };
+}
+
+macro_rules! calculate {
+    (eval $e:expr) => {
+        {
+            let val: usize = $e; // Force types to be unsigned integers
+            println!("{} = {}", stringify!{$e}, val);
+        }
+    };
+}
+
+fn give_adult(drink: Option<&str>) {
+    // Specify a course of action for each case.
+    match drink {
+        Some("lemonade") => println!("Yuck! Too sugary."),
+        Some(inner)   => println!("{}? How nice.", inner),
+        None          => println!("No drink? Oh well."),
+    }
+}
+
+impl Person {
+
+    // Gets the area code of the phone number of the person's job, if it exists.
+    fn work_phone_area_code(&self) -> Option<u8> {
+        // It would take a lot more code - try writing it yourself and see which
+        // is easier.
+        self.job?.phone_number?.area_code
+    }
+}
+
+#[cfg(target_family = "unix")]
+#[link(name = "m")]
+extern {
+    // this is a foreign function
+    // that computes the square root of a single precision complex number
+    fn csqrtf(z: Complex) -> Complex;
+
+    fn ccosf(z: Complex) -> Complex;
+}
+
+fn main() {
+    let raw_p: *const u32 = &10;
+
+    unsafe {
+        assert!(*raw_p == 10);
+    }
+}
+```