src/Pure/Concurrent/future.ML

   val join: 'a future -> 'a
   val value_result: 'a Exn.result -> 'a future
   val value: 'a -> 'a future
   val cond_forks: params -> (unit -> 'a) list -> 'a future list
   val map: ('a -> 'b) -> 'a future -> 'b future
-  val flat: 'a list future list -> 'a list future
   val promise_group: group -> (unit -> unit) -> 'a future
   val promise: (unit -> unit) -> 'a future
   val fulfill_result: 'a future -> 'a Exn.result -> unit
   val fulfill: 'a future -> 'a -> unit
   val terminate: group -> unit

         (singleton o cond_forks)
           {name = "map_future", group = SOME group, deps = [task],
             pri = Task_Queue.pri_of_task task, interrupts = true}
           (fn () => f (join x))
     end;
-
-fun flat_future futures =
-  (case filter_out is_finished futures of
-    [] => value_result (Exn.interruptible_capture (flat o joins) futures)
-  | [x] => map_future (fn _ => flat (joins (futures))) x
-  | xs =>
-      let
-        val tasks = map task_of xs;
-        val pri = foldl1 Int.min (map Task_Queue.pri_of_task tasks);
-      in
-        (singleton o cond_forks)
-          {name = "flat_future", group = NONE, deps = tasks, pri = pri, interrupts = true}
-          (fn () => flat (joins (futures)))
-      end);
 
 
 (* promised futures -- fulfilled by external means *)
 
 fun promise_group group abort : 'a future =

         wait scheduler_event));
 
 
 (*final declarations of this structure!*)
 val map = map_future;
-val flat = flat_future;
 
 end;
 
 type 'a future = 'a Future.future;