Alex ZhangHanDong

Follow-up to Method on Emulating Higher-Kinded Types (HKTs) in Rust

First off, thanks for all the comments and kind words on the original writeup; I've been meaning to follow up on some of the suggestions and write about the different ways to represent monads (and functors, HKTs, etc) that now exist, but a month of being busy has kind of gotten in the way (mainly with three new kittens!).

And for sure, I do not expect (nor do I want) this to become the norm for production-level Rust: rather, I hope that this can contribute to the foundations of programming with higher-level abstractions in Rust, somewhat like how early template metaprogramming in C++ and typeclass-constraint-unification metaprogramming in Haskell have contributed, perhaps indirectly, to later innovations in their respective languages and ecosystems that were much more reasoned, sound and usable.

Changes, Edits, Refinements

One of the things suggested in the com

Rust in Large Organizations

Initially taken by Niko Matsakis and lightly edited by Ryan Levick

Agenda

Introductions
Cargo inside large build systems
FFI
Foundations and financial support

	#![feature(core_intrinsics)]

	// This requires unstable features to compile so we can print out the type names. The type
	// arithmetic itself works fine on stable.

	use std::marker::PhantomData;

	enum Zero {}
	enum Succ<T> {
	Succ(PhantomData<T>), // only required to satisfy the compiler

	use std::str;

	fn main() {
	// -- FROM: vec of chars --
	let src1: Vec<char> = vec!['j','{','"','i','m','m','y','"','}'];
	// to String
	let string1: String = src1.iter().collect::<String>();
	// to str
	let str1: &str = &src1.iter().collect::<String>();
	// to vec of byte

	impl<
	'four>For for
	& 'four for<
	'fore>For where
	for<'fore>For:For
	{fn four( self:&&
	'four for <'fore>
	For){ print!(
	"four" )}} fn
	main(){ four(&(

	#![feature(generators)]
	#![feature(generator_trait)]

	use std::ops::{Generator, GeneratorState};

	fn fizzbuzz_println(upto: u64) {
	for i in 0..upto {
	if i % 3 == 0 && i % 5 == 0 {
	println!("FizzBuzz");
	} else if i % 3 == 0 {

	#![warn(rust_2018_idioms)]

	#[derive(Debug)]
	pub struct StrSplit<'haystack, D> {
	remainder: Option<&'haystack str>,
	delimiter: D,
	}

	impl<'haystack, D> StrSplit<'haystack, D> {
	pub fn new(haystack: &'haystack str, delimiter: D) -> Self {

	pub struct Monster {
	hp: u8, // health points
	sp: u8, // spell points

	friends: Vec<Friend>,
	}

	pub struct Friend {
	loyalty: u8,
	}

	trait A{
	fn a(&self);
	}

	trait B{
	fn b(&self);

	}

	impl B for A{