use std::net::*;
fn sub_merge(source:*mut[i32], memory:*mut[i32]){
    let s:&mut[i32] = unsafe{ std::mem::transmute::<_, &mut[i32]>(source) };
    let m:&mut[i32] = unsafe{ std::mem::transmute::<_, &mut[i32]>(memory) };
    if s.len() > 1{
        let len = s.len();
        let (s1,s2,m1,m2);
        unsafe{
            s1 = std::mem::transmute::<_, &mut[i32]>(&mut s[0..len/2]);
            s2 = std::mem::transmute::<_, &mut[i32]>(&mut s[len/2..len]);
            m1 = std::mem::transmute::<_, *mut[i32]>(&m[0..len/2]);
            m2 = std::mem::transmute::<_, *mut[i32]>(&m[len/2..len]);
        }
        sub_merge(s1, m1);
        sub_merge(s2, m2);
        let mem:&mut[i32] = unsafe{ std::mem::transmute::<_, &mut[i32]>(memory) };
        let mut s1_it = s1.iter();
        let mut s2_it = s2.iter();
        let mut mem_it = mem.iter_mut();
        let mut sv1;
        let mut sv2;
        sv1 = s1_it.next();
        sv2 = s2_it.next();
        loop{
            let m = match mem_it.next(){
                Some(v)=>v,
                None=>break
            };
            
            match (sv1, sv2){
                (None, Some(v))=>{
                    *m = *v;
                    sv2 = s2_it.next();
                }
                (Some(v), None)=>{
                    *m = *v;
                    sv1 = s1_it.next();
                },
                (Some(v1), Some(v2))=>{
                    if v1 > v2{
                        *m = *v2;
                        sv2 = s2_it.next();
                    }
                    else{
                        *m = *v1;
                        sv1 = s1_it.next();
                    }
                }
                _=>{}
            }
        }

        let mut mi = m.iter();
        let mut si = s.iter_mut();
        while let Some(sv) = si.next(){
            let mv = mi.next().unwrap();
            *sv = *mv;
        }
    }
}
fn sort_by_merge(source:&mut[i32]){
    let mut vec:Vec<i32> = vec![ 0i32;source.len()];
    sub_merge(source as *mut[i32], vec.as_mut_slice() as *mut[i32]);
}
fn sub_merge_sort<T>(source: *mut[T], memory:*mut[T])where T:PartialEq + PartialOrd{
    let s:&mut[T] = unsafe{ std::mem::transmute::<_, &mut[T]>(source) };
    let m:&mut[T] = unsafe{ std::mem::transmute::<_, &mut[T]>(memory) };
    if s.len() > 1{
        let len = s.len();
        let (s1,s2,m1,m2);
        unsafe{
            s1 = std::mem::transmute::<_, &mut[T]>(&mut s[0..len/2]);
            s2 = std::mem::transmute::<_, &mut[T]>(&mut s[len/2..len]);
            m1 = std::mem::transmute::<_, *mut[T]>(&m[0..len/2]);
            m2 = std::mem::transmute::<_, *mut[T]>(&m[len/2..len]);
        }
        sub_merge_sort(s1, m1);
        sub_merge_sort(s2, m2);
        let mem:&mut[T] = unsafe{ std::mem::transmute::<_, &mut[T]>(memory) };
        let mut s1_it = s1.iter_mut();
        let mut s2_it = s2.iter_mut();
        let mut mem_it = mem.iter_mut();
        let mut sv1= s1_it.next();
        let mut sv2= s2_it.next();
        loop{
            let m = match mem_it.next(){
                Some(v)=>v,
                None=>break
            };
            
            let switch =
            match (&sv1,&sv2){
                (&None,& Some(_))=>2,
                (&Some(_),& None)=>1,
                (&Some(ref v1),&Some(ref v2))if v1 > v2=>2,
                (&Some(ref v1),&Some(ref v2))if v1 <= v2=>1,
                _=>{break;}
            };

            match switch{
                2=>{
                    //let sv = &mut sv2;
                    let v = sv2.unwrap();
                    std::mem::swap(m,v);
                    sv2 = s2_it.next()
                },
                1=>{
                    let v = sv1.unwrap();
                    std::mem::swap(m,v);
                    sv1 = s1_it.next()
                }
                _=>{}
            }
        }

        let mut mi = m.iter_mut();
        let mut si = s.iter_mut();
        while let Some(sv) = si.next(){
            let mv = mi.next().unwrap();
            std::mem::swap(sv,mv);
        }
    }
}
fn merge_sort<T>(source:&mut[T])where T:PartialEq + PartialOrd{
    let mut tempMemory:Vec<T> = Vec::with_capacity(source.len());
    for _ in 0..source.len(){
        unsafe{tempMemory.push(std::mem::uninitialized());}
    }
    sub_merge_sort(source as *mut[T], tempMemory.as_mut_slice());
    for it in tempMemory{
        std::mem::forget(it);
    }
}
fn main() {
    let mut v = Vec::new();
    for i in 0..100{
        v.push(format!("{:03}",100 - i));
    }
    println!("{:?}", v);
    merge_sort(v.as_mut_slice());
    //sort_by_merge(v.as_mut_slice());
    println!("{:?}", v);
}


실행결과