diff --git a/fizzbuzz/types/main.rs b/fizzbuzz/types/main.rs
new file mode 100644
index 0000000..a71bb46
--- /dev/null
+++ b/fizzbuzz/types/main.rs
@@ -0,0 +1,284 @@
+#![recursion_limit = "1024"]
+#![feature(specialization)]
+use std::marker::PhantomData;
+
+trait Num { fn render() -> u64; }
+struct Zero;
+impl Num for Zero { fn render() -> u64 { 0 } }
+struct Succ<I: Num>(PhantomData<I>);
+impl<I: Num> Num for Succ<I> { fn render() -> u64 { <I>::render() + 1 } }
+
+
+trait Char { fn render() -> char; }
+struct S0 {} impl Char for S0 { fn render() -> char { '0' } }
+struct S1 {} impl Char for S1 { fn render() -> char { '1' } }
+struct S2 {} impl Char for S2 { fn render() -> char { '2' } }
+struct S3 {} impl Char for S3 { fn render() -> char { '3' } }
+struct S4 {} impl Char for S4 { fn render() -> char { '4' } }
+struct S5 {} impl Char for S5 { fn render() -> char { '5' } }
+struct S6 {} impl Char for S6 { fn render() -> char { '6' } }
+struct S7 {} impl Char for S7 { fn render() -> char { '7' } }
+struct S8 {} impl Char for S8 { fn render() -> char { '8' } }
+struct S9 {} impl Char for S9 { fn render() -> char { '9' } }
+
+struct SF {} impl Char for SF { fn render() -> char { 'F' } }
+struct Si {} impl Char for Si { fn render() -> char { 'i' } }
+struct Sz {} impl Char for Sz { fn render() -> char { 'z' } }
+struct SB {} impl Char for SB { fn render() -> char { 'B' } }
+struct Su {} impl Char for Su { fn render() -> char { 'u' } }
+struct Snl {} impl Char for Snl { fn render() -> char { '\n' } }
+
+
+trait String { fn render(); }
+struct SEmpty {} impl String for SEmpty { fn render() {} }
+struct SCons<F: Char, R: String>(PhantomData<F>, PhantomData<R>);
+impl<F: Char, R: String> String for SCons<F, R> {
+    fn render() {
+        print!("{}", <F>::render());
+        <R>::render();
+    }
+}
+struct SBadEval {}
+impl String for SBadEval { fn render() { print!("BAD EVAL"); } }
+
+trait StringifiedImpl: Num {
+    type Result: String;
+}
+
+impl<N: Num> StringifiedImpl for N {
+    default type Result = SBadEval;
+}
+
+impl StringifiedImpl for Zero {
+    type Result = SCons<S0, SEmpty>;
+}
+
+impl<N: Num> StringifiedImpl for Succ<N> {
+    type Result = <<N as StringifiedImpl>::Result as StringIncrement>::Result;
+}
+
+trait Stringified: Num {
+    type Result: String;
+}
+
+impl<N: Num> Stringified for N {
+    type Result = <<N as StringifiedImpl>::Result as Rev>::Result;
+}
+
+trait StringIncrement: String {
+    type Result: String;
+}
+
+impl StringIncrement for SEmpty {
+    type Result = SCons<S1, SEmpty>;
+}
+
+impl<S: String> StringIncrement for S {
+    default type Result = SBadEval;
+}
+
+impl<S: String> StringIncrement for SCons<S0, S> {
+    type Result = SCons<S1, S>;
+}
+impl<S: String> StringIncrement for SCons<S1, S> {
+    type Result = SCons<S2, S>;
+}
+impl<S: String> StringIncrement for SCons<S2, S> {
+    type Result = SCons<S3, S>;
+}
+impl<S: String> StringIncrement for SCons<S3, S> {
+    type Result = SCons<S4, S>;
+}
+impl<S: String> StringIncrement for SCons<S4, S> {
+    type Result = SCons<S5, S>;
+}
+impl<S: String> StringIncrement for SCons<S5, S> {
+    type Result = SCons<S6, S>;
+}
+impl<S: String> StringIncrement for SCons<S6, S> {
+    type Result = SCons<S7, S>;
+}
+impl<S: String> StringIncrement for SCons<S7, S> {
+    type Result = SCons<S8, S>;
+}
+impl<S: String> StringIncrement for SCons<S8, S> {
+    type Result = SCons<S9, S>;
+}
+impl<S: String + StringIncrement> StringIncrement for SCons<S9, S> {
+    type Result = SCons<S0, <S as StringIncrement>::Result>;
+}
+
+trait App<S: String>: String {
+    type Result: String;
+}
+
+impl<S: String, T: String> App<S> for T {
+    default type Result = SBadEval;
+}
+
+impl<S: String> App<S> for SEmpty {
+    type Result = S;
+}
+
+impl<S: String, F: Char, R: String> App<S> for SCons<F, R> {
+    type Result = SCons<F, <R as App<S>>::Result>;
+}
+
+trait Rev: String {
+    type Result: String;
+}
+
+impl<S: String> Rev for S {
+    default type Result = SBadEval;
+}
+
+impl Rev for SEmpty {
+    type Result = SEmpty;
+}
+
+impl<F: Char, R: String> Rev for SCons<F, R> {
+    type Result = <R as App<SCons<F, SEmpty>>>::Result;
+}
+
+trait ModResult { fn render(); }
+struct ModBadEval {} impl ModResult for ModBadEval { fn render() { println!("mod bad eval"); } }
+struct Mod {} impl ModResult for Mod { fn render() { println!("mod"); } }
+struct Modnt {} impl ModResult for Modnt { fn render() { println!("not mod"); } }
+
+trait NumMod3: Num {
+    type Result: ModResult;
+}
+
+impl<T: Num> NumMod3 for T {
+    default type Result = ModBadEval;
+}
+
+impl NumMod3 for Zero {
+    type Result = Mod;
+}
+
+impl NumMod3 for Succ<Zero> {
+    type Result = Modnt;
+}
+
+impl NumMod3 for Succ<Succ<Zero>> {
+    type Result = Modnt;
+}
+
+impl<T: Num> NumMod3 for Succ<Succ<Succ<T>>> {
+    type Result = <T as NumMod3>::Result;
+}
+
+trait NumMod5: Num {
+    type Result: ModResult;
+}
+
+impl<T: Num> NumMod5 for T {
+    default type Result = ModBadEval;
+}
+
+impl NumMod5 for Zero {
+    type Result = Mod;
+}
+
+impl NumMod5 for Succ<Zero> {
+    type Result = Modnt;
+}
+
+impl NumMod5 for Succ<Succ<Zero>> {
+    type Result = Modnt;
+}
+
+impl NumMod5 for Succ<Succ<Succ<Zero>>> {
+    type Result = Modnt;
+}
+
+impl NumMod5 for Succ<Succ<Succ<Succ<Zero>>>> {
+    type Result = Modnt;
+}
+
+impl<T: Num> NumMod5 for Succ<Succ<Succ<Succ<Succ<T>>>>> {
+    type Result = <T as NumMod5>::Result;
+}
+
+
+trait FizzbuzzStringified: Num {
+    type Result: String;
+}
+
+trait FbstrHelper<Mod3: ModResult, Mod5: ModResult>: Num {
+    type Result: String;
+}
+
+impl<T: Num, Mod3: ModResult, Mod5: ModResult> FbstrHelper<Mod3, Mod5> for T {
+    default type Result = SBadEval;
+}
+
+impl<T: Num> FbstrHelper<Modnt, Modnt> for T {
+    type Result = <T as Stringified>::Result;
+}
+
+impl<T: Num> FbstrHelper<Mod, Modnt> for T {
+    type Result = SCons<SF, SCons<Si, SCons<Sz, SCons<Sz, SEmpty>>>>;
+}
+
+impl<T: Num> FbstrHelper<Modnt, Mod> for T {
+    type Result = SCons<SB, SCons<Su, SCons<Sz, SCons<Sz, SEmpty>>>>;
+}
+
+impl<T: Num> FbstrHelper<Mod, Mod> for T {
+    type Result = SCons<SF, SCons<Si, SCons<Sz, SCons<Sz, SCons<SB, SCons<Su, SCons<Sz, SCons<Sz, SEmpty>>>>>>>>;
+}
+
+impl<T: Num> FizzbuzzStringified for T {
+    type Result = <T as FbstrHelper<<T as NumMod3>::Result, <T as NumMod5>::Result>>::Result;
+}
+
+trait Added<S: Num>: Num {
+    type Result: Num;
+}
+
+impl<T: Num, S: Num> Added<S> for T {
+    default type Result = S;
+}
+
+impl<S: Num> Added<S> for Zero {
+    type Result = S;
+}
+
+impl<T: Num, S: Num> Added<S> for Succ<T> {
+    type Result = Succ<<T as Added<S>>::Result>;
+}
+
+
+trait FizzbuzzProgram: Num {
+    type Result: String;
+}
+
+impl<T: Num> FizzbuzzProgram for T {
+    default type Result = SBadEval;
+}
+
+impl FizzbuzzProgram for Zero {
+    type Result = SEmpty;
+}
+
+impl<T: Num> FizzbuzzProgram for Succ<T> {
+    type Result = <<<T as FizzbuzzProgram>::Result as App<<Succ<T> as FizzbuzzStringified>::Result>>::Result as App<SCons<Snl, SEmpty>>>::Result;
+}
+
+
+fn main() {
+    type One = Succ<Zero>;
+    type Two = Succ<One>;
+    type Four = <Two as Added<Two>>::Result;
+    type Eight = <Four as Added<Four>>::Result;
+    type Sixteen = <Eight as Added<Eight>>::Result;
+
+    type Five = <Four as Added<One>>::Result;
+    type Ten = <Five as Added<Five>>::Result;
+    type Thirty = <<<Sixteen as Added<Eight>>::Result as Added<Four>>::Result as Added<Two>>::Result;
+    type OneHundred = <<<Thirty as Added<Thirty>>::Result as Added<Thirty>>::Result as Added<Ten>>::Result;
+
+    <OneHundred as FizzbuzzProgram>::Result::render();
+}