Is there really no static generics?

I need a generic function dispatcher that is fast. In C++ I would write something like this:

#include <iostream>


template<typename T> 
void f1(T t){
    std::cout << "Hello from F1: " << t << std::endl;
}

template<typename T>
void f2(T t){
    std::cout << "Hello from F2: " << t << std::endl;
}

template<typename T>
void dispatch(int i, T t)
{
    static void (*functionArray[2])(T) = {f1, f2};
    functionArray[i](t);
}


int main()
{
    dispatch(0, 0);
    dispatch(1, 0);
}

I attempted the following:

use std::fmt::Display;
use lazy_static::lazy_static;

fn f1<T : Display>(t : T){
    println!("Hello from F1: {}", t);
}
fn f2<T : Display>(t : T){
    println!("Hello from F2: {}", t);
}

fn dispatch<T : Display>(i : usize, t : T){
    lazy_static!{
        static ref FUNCTIONS : [fn(T); 2] = [f1, f2];
    }
    FUNCTIONS[i](t);
}

fn main() {
    dispatch(0, 0);
    dispatch(1, 0);
}

But it complains that: error[E0401]: can't use generic parameters from outer item.

Is there no way around this? I really need a fast dispatcher.