booyaa · September 20, 2017 12:52
diff --git a/1_meetup_schedule.md b/1_meetup_schedule.md
diff --git a/2_script.md b/2_script.md
diff --git a/hello.sh b/hello.sh
 $ cat hello.rs
 fn main() {
    println!("Hello, World");
 }
 $ rustc hello.rs
 $ ./hello
 Hello, World
 $
diff --git a/io.rs b/io.rs
 let path = "lines.txt";

 let mut output = File::create(path)?;
 write!(output, "Rust\n💖\nFun")?;

 let input = File::open(path)?;
 let buffered = BufReader::new(input);

 for line in buffered.lines() {
    println!("{}", line?);
 }
diff --git a/iterator_example.rs b/iterator_example.rs
 let a = [1, 2, 3];

 let (even, odd): (Vec<i32>, Vec<i32>) = a.into_iter()
                          .partition(|&n| n % 2 == 0);

 assert_eq!(even, vec![2]);
 assert_eq!(odd, vec![1, 3]);
diff --git a/iterator_trait.rs b/iterator_trait.rs
 /// Consumes an iterator, creating two collections from it.
 ///
 /// The predicate passed to `partition()` can return `true`, or `false`.
 /// `partition()` returns a pair, all of the elements for which it returned
 /// `true`, and all of the elements for which it returned `false`.
 ///
 /// # Examples
 ///
 /// Basic usage:
 ///
 /// ```
 /// let a = [1, 2, 3];
 ///
 /// let (even, odd): (Vec<i32>, Vec<i32>) = a.into_iter()
 ///                                          .partition(|&n| n % 2 == 0);
 ///
 /// assert_eq!(even, vec![2]);
 /// assert_eq!(odd, vec![1, 3]);
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
 fn partition<B, F>(self, mut f: F) -> (B, B) where
    Self: Sized,
    B: Default + Extend<Self::Item>,
    F: FnMut(&Self::Item) -> bool
 {
    let mut left: B = Default::default();
    let mut right: B = Default::default();

    for x in self {
        if f(&x) {
            left.extend(Some(x))
        } else {
            right.extend(Some(x))
        }
    }
diff --git a/nightly_only.rs b/nightly_only.rs
 #![feature(inclusive_range_syntax)]

 fn main() {
    for i in 1...10 { 
        print!("{} ", i);
    }
    // output: 1 2 3 4 5 6 7 8 9 10
 }

 // source: https://play.integer32.com/?gist=14a2cb4006efcd7a9819241c2304df7c&version=nightly
diff --git a/resources.md b/resources.md
diff --git a/serde.rs b/serde.rs
 #[derive(Serialize, Deserialize, Debug)]
 struct Point {
    x: i32,
    y: i32,
 }

 fn main() {
    let s = r#"{
                "x":1,
                "y":2
            }"#;

    let d: Point = 
        serde_json::from_str(&s).unwrap();

    println!("deserialized = {:?}", d);
 }

 // source: https://play.integer32.com/?gist=d3c45f05287a1b9254b7ba228f0598a7&version=stable
diff --git a/stable_or_nightly.rs b/stable_or_nightly.rs
 fn main() {
    for i in 1..11 { 
        print!("{} ", i);
    }
    // output: 1 2 3 4 5 6 7 8 9 10
 }

 // source: https://play.integer32.com/?gist=764d794209dc00c50c70a6593643fb5b&version=stable
	$ cat hello.rs
	fn main() {
	println!("Hello, World");
	}
	$ rustc hello.rs
	$ ./hello
	Hello, World
	$
	let path = "lines.txt";

	let mut output = File::create(path)?;
	write!(output, "Rust\n💖\nFun")?;

	let input = File::open(path)?;
	let buffered = BufReader::new(input);

	for line in buffered.lines() {
	println!("{}", line?);
	}
	let a = [1, 2, 3];

	let (even, odd): (Vec<i32>, Vec<i32>) = a.into_iter()
	.partition(\|&n\| n % 2 == 0);

	assert_eq!(even, vec![2]);
	assert_eq!(odd, vec![1, 3]);
	/// Consumes an iterator, creating two collections from it.
	///
	/// The predicate passed to `partition()` can return `true`, or `false`.
	/// `partition()` returns a pair, all of the elements for which it returned
	/// `true`, and all of the elements for which it returned `false`.
	///
	/// # Examples
	///
	/// Basic usage:
	///
	/// ```
	/// let a = [1, 2, 3];
	///
	/// let (even, odd): (Vec<i32>, Vec<i32>) = a.into_iter()
	/// .partition(\|&n\| n % 2 == 0);
	///
	/// assert_eq!(even, vec![2]);
	/// assert_eq!(odd, vec![1, 3]);
	/// ```
	#[stable(feature = "rust1", since = "1.0.0")]
	fn partition<B, F>(self, mut f: F) -> (B, B) where
	Self: Sized,
	B: Default + Extend<Self::Item>,
	F: FnMut(&Self::Item) -> bool
	{
	let mut left: B = Default::default();
	let mut right: B = Default::default();

	for x in self {
	if f(&x) {
	left.extend(Some(x))
	} else {
	right.extend(Some(x))
	}
	}
	#![feature(inclusive_range_syntax)]

	fn main() {
	for i in 1...10 {
	print!("{} ", i);
	}
	// output: 1 2 3 4 5 6 7 8 9 10
	}

	// source: https://play.integer32.com/?gist=14a2cb4006efcd7a9819241c2304df7c&version=nightly
	#[derive(Serialize, Deserialize, Debug)]
	struct Point {
	x: i32,
	y: i32,
	}

	fn main() {
	let s = r#"{
	"x":1,
	"y":2
	}"#;

	let d: Point =
	serde_json::from_str(&s).unwrap();

	println!("deserialized = {:?}", d);
	}

	// source: https://play.integer32.com/?gist=d3c45f05287a1b9254b7ba228f0598a7&version=stable
	fn main() {
	for i in 1..11 {
	print!("{} ", i);
	}
	// output: 1 2 3 4 5 6 7 8 9 10
	}

	// source: https://play.integer32.com/?gist=764d794209dc00c50c70a6593643fb5b&version=stable