// #![recursion_limit="128"]
// #[macro_use]
// extern crate fungi_lang;

// // XXX stack overflow issue ??
// //#[test]

// pub fn quickhull () {
//   use std::thread;
//   let child =
//     thread::Builder::new().stack_size(64 * 1024 * 1024).spawn(move || { 
//       quickhull2()
//     });
//   let _ = child.unwrap().join();
// }
// pub fn quickhull2() {
//     use std::rc::Rc;
//     use fungi_lang::ast::*;
//     use fungi_lang::bitype::*;
//     use fungi_lang::vis::*;
//     //use fungi_lang::eval::*;

// // From Paper
// // ----------
// //
// // qh1 ln pts h = 
// //  let p =[ln@1] max_pt ln pts
// //  let l =[ln@2] filter (ln.0,p) pts
// //  let r =[ln@3] filter (p,ln.1) pts
// //  let h = memo[ln@1](qh1 (p,ln.1) r h)
// //  let h = push[ln@2](p,h)
// //  let h = memo[ln@3](qh1 (ln.0,p) l h)
// //  h

// // qh2 ln pts h = 
// //  let p =[3@1] max_pt ln pts
// //  let l =[3@2] filter (ln.0,p) pts
// //  let r =[3@3] filter (p,ln.1) pts
// //  let h = memo[1]([1](qh2 (p,ln.1) r h))
// //  let h = push[2](p,h)
// //  let h = memo[3]([2](qh2 (ln.0,p) l h))
// //  h

//     let bundle : Bundle = fgi_bundle![
//     //let qh_ast = fgi_exp![
//         decls {
//             type Hull = ( foralli (X,Y):NmSet.user(Hull) )
//             type Pt = ( user(Pt) )
//             type Pts = ( foralli (X,Y):NmSet.user(Pts) )
//             type Line = ( foralli (X,Y):NmSet.(x Pt x Pt) )

//             /// Structural recursion over a binary tree (output names and pointers):
//             idxtm    Bin   = (#x:Nm.         {x,@1} % {x,@2}  )
//             idxtm WS_Bin   = (#x:NmSet.{@!}( (Bin) x         ))
//             /// Structural recursion over a trinary tree (output names and pointers):
//             idxtm    Tri   = (#x:Nm. {x,@1} % {x,@2} % {x,@3} )
//             idxtm WS_Tri   = (#x:NmSet.{@!}( (Tri) x         ))
//         }
//         let max_pt : (Thk[0] foralli (X0,X1,Y1):NmSet.
//             0 Line[X0] -> 0 Pts[X1][Y1] ->
//             {{WS_Bin}X1;({WS_Bin}X1)%Y1} F Pt
//         ) = { unimplemented }
//         let filter_line : (Thk[0] foralli (X0,X,Y):NmSet.
//             0 Line[X0] -> 0 Pts[X][Y] ->
//             {{WS_Bin}X;({WS_Bin}X)%Y} F Pts[X][Y%{WS_Bin}X]
//         ) = { unimplemented }
//         let push : (Thk[0] foralli (X1,X2,X3,Y):NmSet.
//             0 Nm[X0] -> 0 Line[X1] -> 0 Pt -> 0 Hull[X2][Y] ->
//             {{@!}X0;0} F Hull[X1%X2][({!@}X0)%Y]
//         ) = { unimplemented }

//         let qh2 : (Thk[0] foralli (X,Y,Z):NmSet.
//             0 Line[X0] -> 0 Pts[X1][Y1] -> 0 Hull[X2][Y2] ->
//             { 0 ; 0 } F Hull[X0%X2][Y2]
//         ) = {
//             ret thunk fix qh1. #ln. #pts. #h.
//             let (ll,lr) = { ret ln }
//             let p = { {force max_pt} ln pts}
//             let l = { {force filter_line} (ll,p) pts}
//             let r = { {force filter_line} (p,lr) pts}
//             let (rh,h) = { memo(@1){ {force qh1} (p,ll) r h } }
//             let h = { {force push} p h }
//             let (lh,h) = { memo(@3){ {force qh1} (lr,p) l h } }
//             ret h
//         }
//         ret 0
//     ];

//     // println!("quickhull AST");
//     // println!("-------------");
//     // println!("{:?}", qh_ast);
//     // let typed = synth_exp(None, &Ctx::Empty, &qh_ast);
//     // println!("quickhull typing derivation");
//     // println!("---------------------------");
//     // println!("{:?}", typed);

//     write_bundle("target/quickhull.fgb", &bundle);
// }