diff --git a/chorus_lib/examples/multicast.rs b/chorus_lib/examples/multicast.rs
index a376f7b..4c24913 100644
--- a/chorus_lib/examples/multicast.rs
+++ b/chorus_lib/examples/multicast.rs
@@ -2,9 +2,7 @@ extern crate chorus_lib;
 
 use std::thread;
 
-use chorus_lib::core::{
-    ChoreoOp, Choreography, ChoreographyLocation, LocationSet, Projector,
-};
+use chorus_lib::core::{ChoreoOp, Choreography, ChoreographyLocation, LocationSet, Projector};
 use chorus_lib::transport::local::{LocalTransport, LocalTransportChannelBuilder};
 
 // --- Define two locations (Alice and Bob) ---
diff --git a/chorus_lib/tests/booksellers.rs b/chorus_lib/tests/booksellers.rs
index 7754b81..c5d3aaa 100644
--- a/chorus_lib/tests/booksellers.rs
+++ b/chorus_lib/tests/booksellers.rs
@@ -6,14 +6,10 @@ use std::sync::Arc;
 use std::thread;
 
 use chorus_lib::{
-    core::{ChoreoOp, Choreography, ChoreographyLocation, Faceted,
-           FanInChoreography,
-           HCons,
-           Here, Located, LocationSet,
-           LocationSetFoldable,
-           Member,
-           Projector,
-           Quire, Runner, Subset, There},
+    core::{
+        ChoreoOp, Choreography, ChoreographyLocation, Faceted, FanInChoreography, HCons, Here,
+        Located, LocationSet, LocationSetFoldable, Member, Projector, Quire, Runner, Subset, There,
+    },
     transport::local::{LocalTransport, LocalTransportChannelBuilder},
 };
 use chrono::NaiveDate;
@@ -32,28 +28,35 @@ type Title = String;
 
 type Inventory = HashMap<Title, (Money, NaiveDate)>;
 
-
 trait Decider {
     type Budgets;
     fn new(price: Located<Option<Money>, Buyer1>, budgets: Self::Budgets) -> Self;
 }
 
-struct Booksellers<D: Choreography<Located<bool, Buyer1>> + Decider<Budgets=Budgets>, Budgets, Buyers, B1Index, BSIndex> {
+struct Booksellers<
+    D: Choreography<Located<bool, Buyer1>> + Decider<Budgets = Budgets>,
+    Budgets,
+    Buyers,
+    B1Index,
+    BSIndex,
+> {
     inventory: Located<Inventory, Seller>,
     title: Located<Title, Buyer1>,
     budgets: Budgets,
     _phantoms: PhantomData<(D, Buyers, B1Index, BSIndex)>,
 }
 
-impl<Buyers: LocationSet
-    ,D: Choreography<Located<bool, Buyer1>, L = Buyers> + Decider<Budgets=Budgets>
-    ,Budgets
-    ,B1Index
-    ,BSIndex
+impl<
+        Buyers: LocationSet,
+        D: Choreography<Located<bool, Buyer1>, L = Buyers> + Decider<Budgets = Budgets>,
+        Budgets,
+        B1Index,
+        BSIndex,
     > Choreography<Option<NaiveDate>> for Booksellers<D, Budgets, Buyers, B1Index, BSIndex>
-    where Buyer1: Member<Buyers, B1Index>
-        , Buyer1: Member<HCons<Seller, Buyers>, There<B1Index>>
-        , Buyers: Subset<HCons<Seller, Buyers>, BSIndex>
+where
+    Buyer1: Member<Buyers, B1Index>,
+    Buyer1: Member<HCons<Seller, Buyers>, There<B1Index>>,
+    Buyers: Subset<HCons<Seller, Buyers>, BSIndex>,
 {
     type L = HCons<Seller, Buyers>;
     fn run(self, op: &impl ChoreoOp<Self::L>) -> Option<NaiveDate> {
@@ -61,7 +64,8 @@ impl<Buyers: LocationSet
         let price_at_seller = op.locally(Seller, |un| {
             let inventory = un.unwrap(&self.inventory);
             let title = un.unwrap(&title_at_seller);
-            inventory.get(title).map(|(price, _)|{*price})        });
+            inventory.get(title).map(|(price, _)| *price)
+        });
         let price_at_buyer1 = op.comm(Seller, Buyer1, &price_at_seller);
         let decider = D::new(price_at_buyer1, self.budgets);
         let decision_at_buyer1 = op.enclave(decider).flatten();
@@ -79,7 +83,9 @@ impl<Buyers: LocationSet
                     let delivery_date_at_seller = op.locally(Seller, |un| {
                         let title = un.unwrap(&self.title_at_seller);
                         let inventory = un.unwrap(&self.inventory);
-                        inventory.get(title).map(|(_, delivery_date)| {*delivery_date})
+                        inventory
+                            .get(title)
+                            .map(|(_, delivery_date)| *delivery_date)
                     });
                     let delivery_date_at_buyer1 = op.comm(Seller, Buyer1, &delivery_date_at_seller);
                     return delivery_date_at_buyer1;
@@ -89,12 +95,15 @@ impl<Buyers: LocationSet
             }
         }
 
-        return op.broadcast(Buyer1,
-                            op.enclave(GetDeliveryDateChoreography {
-                                        inventory: self.inventory.clone(),
-                                        title_at_seller: title_at_seller.clone(),
-                                        decision_at_buyer1,
-                                       }).flatten());
+        return op.broadcast(
+            Buyer1,
+            op.enclave(GetDeliveryDateChoreography {
+                inventory: self.inventory.clone(),
+                title_at_seller: title_at_seller.clone(),
+                decision_at_buyer1,
+            })
+            .flatten(),
+        );
     }
 }
 
@@ -104,99 +113,118 @@ struct Unilateral {
 }
 impl Decider for Unilateral {
     type Budgets = Located<Money, Buyer1>;
-    fn new(price: Located<Option<Money>, Buyer1>, budgets: Located<Money, Buyer1>) -> Self{
-        return Self{price: price, budget: budgets}
+    fn new(price: Located<Option<Money>, Buyer1>, budgets: Located<Money, Buyer1>) -> Self {
+        return Self {
+            price: price,
+            budget: budgets,
+        };
     }
 }
 impl Choreography<Located<bool, Buyer1>> for Unilateral {
     type L = LocationSet!(Buyer1);
     fn run(self, op: &impl ChoreoOp<Self::L>) -> Located<bool, Buyer1> {
-        op.locally(Buyer1, |un| {
-            match un.unwrap(&self.price) {
-                Some(price) => price <= un.unwrap(&self.budget),
-                None => false
-            }
+        op.locally(Buyer1, |un| match un.unwrap(&self.price) {
+            Some(price) => price <= un.unwrap(&self.budget),
+            None => false,
         })
     }
 }
 
-
 ////////////////////////////////////////////////////////////////////////
 struct Colaborative<Buyers: LocationSet, B1Index, BSRefl, BSFld> {
     price: Located<Option<Money>, Buyer1>,
     budgets: Faceted<Money, Buyers>,
     _phantoms: PhantomData<(B1Index, BSRefl, BSFld)>,
 }
-impl<Buyers: LocationSet, B1Index, BSRefl, BSFld> Decider for Colaborative<Buyers, B1Index, BSRefl, BSFld>
-where Buyer1: Member<Buyers, B1Index>,
-      Buyers: Subset<Buyers, BSRefl>
+impl<Buyers: LocationSet, B1Index, BSRefl, BSFld> Decider
+    for Colaborative<Buyers, B1Index, BSRefl, BSFld>
+where
+    Buyer1: Member<Buyers, B1Index>,
+    Buyers: Subset<Buyers, BSRefl>,
 {
     type Budgets = Faceted<Money, Buyers>;
-    fn new(price: Located<Option<Money>, Buyer1>, budgets: Faceted<Money, Buyers>) -> Self{
-        return Self{price: price, budgets: budgets, _phantoms: PhantomData}
+    fn new(price: Located<Option<Money>, Buyer1>, budgets: Faceted<Money, Buyers>) -> Self {
+        return Self {
+            price: price,
+            budgets: budgets,
+            _phantoms: PhantomData,
+        };
     }
 }
-impl<Buyers: LocationSet, B1Index, BSRefl, BSFld>
-    Choreography<Located<bool, Buyer1>> for Colaborative<Buyers, B1Index, BSRefl, BSFld>
-where Buyer1: Member<Buyers, B1Index>,
-      Buyers: Subset<Buyers, BSRefl>,
-      Buyers: LocationSetFoldable<Buyers, Buyers, BSFld>
+impl<Buyers: LocationSet, B1Index, BSRefl, BSFld> Choreography<Located<bool, Buyer1>>
+    for Colaborative<Buyers, B1Index, BSRefl, BSFld>
+where
+    Buyer1: Member<Buyers, B1Index>,
+    Buyers: Subset<Buyers, BSRefl>,
+    Buyers: LocationSetFoldable<Buyers, Buyers, BSFld>,
 {
     type L = Buyers;
     fn run(self, op: &impl ChoreoOp<Self::L>) -> Located<bool, Buyer1> {
         match op.broadcast(Buyer1, self.price) {
             Some(price) => {
-
-                    struct Gather<'a, Buyers: LocationSet, B1Index> {
-                        budgets: &'a Faceted<Money, Buyers>,
-                        _phantoms: PhantomData<B1Index>,
-                    }
-                    impl<'a, Buyers: LocationSet, B1Index> FanInChoreography<Money> for Gather<'a, Buyers, B1Index>
-                    where Buyer1: Member<Buyers, B1Index>
+                struct Gather<'a, Buyers: LocationSet, B1Index> {
+                    budgets: &'a Faceted<Money, Buyers>,
+                    _phantoms: PhantomData<B1Index>,
+                }
+                impl<'a, Buyers: LocationSet, B1Index> FanInChoreography<Money> for Gather<'a, Buyers, B1Index>
+                where
+                    Buyer1: Member<Buyers, B1Index>,
+                {
+                    type L = Buyers;
+                    type QS = Buyers;
+                    type RS = LocationSet!(Buyer1);
+                    fn run<Q: ChoreographyLocation, QSSubsetL, RSSubsetL, QMemberL, QMemberQS>(
+                        &self,
+                        op: &impl ChoreoOp<Self::L>,
+                    ) -> Located<Money, Buyer1>
+                    where
+                        Self::QS: Subset<Self::L, QSSubsetL>,
+                        Self::RS: Subset<Self::L, RSSubsetL>,
+                        Q: Member<Self::L, QMemberL>,
+                        Q: Member<Self::QS, QMemberQS>,
                     {
-                        type L = Buyers;
-                        type QS = Buyers;
-                        type RS = LocationSet!(Buyer1);
-                        fn run<Q: ChoreographyLocation, QSSubsetL, RSSubsetL, QMemberL, QMemberQS>(
-                            &self,
-                            op: &impl ChoreoOp<Self::L>,
-                        ) -> Located<Money, Buyer1>
-                        where
-                            Self::QS: Subset<Self::L, QSSubsetL>,
-                            Self::RS: Subset<Self::L, RSSubsetL>,
-                            Q: Member<Self::L, QMemberL>,
-                            Q: Member<Self::QS, QMemberQS>,
-                        {
-                            op.comm::<_, Q, Buyer1, Money, (QMemberL, _), QMemberL, B1Index>(
-                                Q::new(),
-                                Buyer1,
-                                &op.locally::<Money, Q, QMemberL>(Q::new(),
-                                                                  |un| *un.unwrap3::<Money, Buyers, QMemberQS>(&self.budgets))
-                            )
-                        }
+                        op.comm::<_, Q, Buyer1, Money, (QMemberL, _), QMemberL, B1Index>(
+                            Q::new(),
+                            Buyer1,
+                            &op.locally::<Money, Q, QMemberL>(Q::new(), |un| {
+                                *un.unwrap3::<Money, Buyers, QMemberQS>(&self.budgets)
+                            }),
+                        )
                     }
-                    let budgets = op.fanin(
-                        Buyers::new(),
-                        Gather {
-                            budgets: &self.budgets,
-                            _phantoms: PhantomData,
-                        },
-                    );
+                }
+                let budgets = op.fanin(
+                    Buyers::new(),
+                    Gather {
+                        budgets: &self.budgets,
+                        _phantoms: PhantomData,
+                    },
+                );
 
-                    op.locally(Buyer1, |un| {
-                        let budget = un.unwrap::<Quire<Money, Buyers>, _, Here>(&budgets).get_map().into_values().sum();
-                        return price <= budget
-                    })
-                },
-            None => op.locally(Buyer1, |_| {false})
+                op.locally(Buyer1, |un| {
+                    let budget = un
+                        .unwrap::<Quire<Money, Buyers>, _, Here>(&budgets)
+                        .get_map()
+                        .into_values()
+                        .sum();
+                    return price <= budget;
+                })
+            }
+            None => op.locally(Buyer1, |_| false),
         }
     }
 }
 
-
-fn run_test(inventory: Inventory, title: Title, budget1: Money, budget2: Option<Money>, answer: Option<NaiveDate>) {
+fn run_test(
+    inventory: Inventory,
+    title: Title,
+    budget1: Money,
+    budget2: Option<Money>,
+    answer: Option<NaiveDate>,
+) {
     let transport_channel = LocalTransportChannelBuilder::new()
-        .with(Seller).with(Buyer1).with(Buyer2)
+        .with(Seller)
+        .with(Buyer1)
+        .with(Buyer2)
         .build();
     let seller_projector = Arc::new(Projector::new(
         Seller,
@@ -215,17 +243,22 @@ fn run_test(inventory: Inventory, title: Title, budget1: Money, budget2: Option<
     if let Some(budget2) = budget2 {
         {
             let central_runner = Runner::new();
-            let choreo : Booksellers<Colaborative<LocationSet!(Buyer1, Buyer2), _, _, _>,
-                                     Faceted<Money, LocationSet!(Buyer1, Buyer2)>,
-                                     LocationSet!(Buyer1, Buyer2),
-                                     _, _> = Booksellers{
+            let choreo: Booksellers<
+                Colaborative<LocationSet!(Buyer1, Buyer2), _, _, _>,
+                Faceted<Money, LocationSet!(Buyer1, Buyer2)>,
+                LocationSet!(Buyer1, Buyer2),
+                _,
+                _,
+            > = Booksellers {
                 inventory: central_runner.local(inventory.clone()),
                 title: central_runner.local(title.clone()),
                 budgets: central_runner.unsafe_faceted(
-                    [(String::from(Buyer1::name()), budget1),
-                     (String::from(Buyer2::name()), budget2),
+                    [
+                        (String::from(Buyer1::name()), budget1),
+                        (String::from(Buyer2::name()), budget2),
                     ],
-                    <LocationSet!(Buyer1, Buyer2)>::new()),
+                    <LocationSet!(Buyer1, Buyer2)>::new(),
+                ),
                 _phantoms: PhantomData,
             };
             let central_result = central_runner.run(choreo);
@@ -233,10 +266,13 @@ fn run_test(inventory: Inventory, title: Title, budget1: Money, budget2: Option<
         }
         {
             handles.push(thread::spawn(move || {
-                let choreo : Booksellers<Colaborative<LocationSet!(Buyer1, Buyer2), _, _, _>,
-                                         Faceted<Money, LocationSet!(Buyer1, Buyer2)>,
-                                         LocationSet!(Buyer1, Buyer2),
-                                         _, _> = Booksellers{
+                let choreo: Booksellers<
+                    Colaborative<LocationSet!(Buyer1, Buyer2), _, _, _>,
+                    Faceted<Money, LocationSet!(Buyer1, Buyer2)>,
+                    LocationSet!(Buyer1, Buyer2),
+                    _,
+                    _,
+                > = Booksellers {
                     inventory: seller_projector.local(inventory.clone()),
                     title: seller_projector.remote(Buyer1),
                     budgets: seller_projector.remote_faceted(<LocationSet!(Buyer1, Buyer2)>::new()),
@@ -247,13 +283,17 @@ fn run_test(inventory: Inventory, title: Title, budget1: Money, budget2: Option<
         }
         {
             handles.push(thread::spawn(move || {
-                let choreo : Booksellers<Colaborative<LocationSet!(Buyer1, Buyer2), _, _, _>,
-                                         Faceted<Money, LocationSet!(Buyer1, Buyer2)>,
-                                         LocationSet!(Buyer1, Buyer2),
-                                         _, _> = Booksellers{
+                let choreo: Booksellers<
+                    Colaborative<LocationSet!(Buyer1, Buyer2), _, _, _>,
+                    Faceted<Money, LocationSet!(Buyer1, Buyer2)>,
+                    LocationSet!(Buyer1, Buyer2),
+                    _,
+                    _,
+                > = Booksellers {
                     inventory: buyer1_projector.remote(Seller),
                     title: buyer1_projector.local(title).clone(),
-                    budgets: buyer1_projector.local_faceted(budget1, <LocationSet!(Buyer1, Buyer2)>::new()),
+                    budgets: buyer1_projector
+                        .local_faceted(budget1, <LocationSet!(Buyer1, Buyer2)>::new()),
                     _phantoms: PhantomData,
                 };
                 buyer1_projector.epp_and_run(choreo)
@@ -261,13 +301,17 @@ fn run_test(inventory: Inventory, title: Title, budget1: Money, budget2: Option<
         }
         {
             handles.push(thread::spawn(move || {
-                let choreo : Booksellers<Colaborative<LocationSet!(Buyer1, Buyer2), _, _, _>,
-                                         Faceted<Money, LocationSet!(Buyer1, Buyer2)>,
-                                         LocationSet!(Buyer1, Buyer2),
-                                         _, _> = Booksellers{
+                let choreo: Booksellers<
+                    Colaborative<LocationSet!(Buyer1, Buyer2), _, _, _>,
+                    Faceted<Money, LocationSet!(Buyer1, Buyer2)>,
+                    LocationSet!(Buyer1, Buyer2),
+                    _,
+                    _,
+                > = Booksellers {
                     inventory: buyer2_projector.remote(Seller),
                     title: buyer2_projector.remote(Buyer1),
-                    budgets: buyer2_projector.local_faceted(budget2, <LocationSet!(Buyer1, Buyer2)>::new()),
+                    budgets: buyer2_projector
+                        .local_faceted(budget2, <LocationSet!(Buyer1, Buyer2)>::new()),
                     _phantoms: PhantomData,
                 };
                 buyer2_projector.epp_and_run(choreo)
@@ -276,10 +320,13 @@ fn run_test(inventory: Inventory, title: Title, budget1: Money, budget2: Option<
     } else {
         {
             let central_runner = Runner::new();
-            let choreo : Booksellers<Unilateral,
-                                     Located<Money, Buyer1>,
-                                     LocationSet!(Buyer1),
-                                     _, _> = Booksellers{
+            let choreo: Booksellers<
+                Unilateral,
+                Located<Money, Buyer1>,
+                LocationSet!(Buyer1),
+                _,
+                _,
+            > = Booksellers {
                 inventory: central_runner.local(inventory.clone()),
                 title: central_runner.local(title.clone()),
                 budgets: central_runner.local(budget1),
@@ -290,10 +337,13 @@ fn run_test(inventory: Inventory, title: Title, budget1: Money, budget2: Option<
         }
         {
             handles.push(thread::spawn(move || {
-                let choreo : Booksellers<Unilateral,
-                                         Located<Money, Buyer1>,
-                                         LocationSet!(Buyer1),
-                                         _, _> = Booksellers{
+                let choreo: Booksellers<
+                    Unilateral,
+                    Located<Money, Buyer1>,
+                    LocationSet!(Buyer1),
+                    _,
+                    _,
+                > = Booksellers {
                     inventory: seller_projector.local(inventory.clone()),
                     title: seller_projector.remote(Buyer1),
                     budgets: seller_projector.remote(Buyer1),
@@ -304,10 +354,13 @@ fn run_test(inventory: Inventory, title: Title, budget1: Money, budget2: Option<
         }
         {
             handles.push(thread::spawn(move || {
-                let choreo : Booksellers<Unilateral,
-                                         Located<Money, Buyer1>,
-                                         LocationSet!(Buyer1),
-                                         _, _> = Booksellers{
+                let choreo: Booksellers<
+                    Unilateral,
+                    Located<Money, Buyer1>,
+                    LocationSet!(Buyer1),
+                    _,
+                    _,
+                > = Booksellers {
                     inventory: buyer1_projector.remote(Seller),
                     title: buyer1_projector.local(title).clone(),
                     budgets: buyer1_projector.local(budget1),
@@ -318,10 +371,13 @@ fn run_test(inventory: Inventory, title: Title, budget1: Money, budget2: Option<
         }
         {
             handles.push(thread::spawn(move || {
-                let choreo : Booksellers<Unilateral,
-                                         Located<Money, Buyer1>,
-                                         LocationSet!(Buyer1),
-                                         _, _> = Booksellers{
+                let choreo: Booksellers<
+                    Unilateral,
+                    Located<Money, Buyer1>,
+                    LocationSet!(Buyer1),
+                    _,
+                    _,
+                > = Booksellers {
                     inventory: buyer2_projector.remote(Seller),
                     title: buyer2_projector.remote(Buyer1),
                     budgets: buyer2_projector.remote(Buyer1),
@@ -353,10 +409,28 @@ fn main() {
     };
     let tapl = "TAPL".to_string();
     let hott = "HoTT".to_string();
-    run_test(inventory.clone(), tapl.clone(), 100, None, Some(NaiveDate::from_ymd_opt(2023, 8, 3).unwrap()));
+    run_test(
+        inventory.clone(),
+        tapl.clone(),
+        100,
+        None,
+        Some(NaiveDate::from_ymd_opt(2023, 8, 3).unwrap()),
+    );
     run_test(inventory.clone(), hott.clone(), 25, None, None);
-    run_test(inventory.clone(), tapl.clone(), 30, Some(30), Some(NaiveDate::from_ymd_opt(2023, 8, 3).unwrap()));
+    run_test(
+        inventory.clone(),
+        tapl.clone(),
+        30,
+        Some(30),
+        Some(NaiveDate::from_ymd_opt(2023, 8, 3).unwrap()),
+    );
     run_test(inventory.clone(), hott.clone(), 30, Some(30), None);
     run_test(inventory.clone(), "nonesuch".to_string(), 25, None, None);
-    run_test(inventory.clone(), "nonesuch".to_string(), 30, Some(30), None);
+    run_test(
+        inventory.clone(),
+        "nonesuch".to_string(),
+        30,
+        Some(30),
+        None,
+    );
 }
diff --git a/chorus_lib/tests/kvs.rs b/chorus_lib/tests/kvs.rs
index 22a13bc..5d68e48 100644
--- a/chorus_lib/tests/kvs.rs
+++ b/chorus_lib/tests/kvs.rs
@@ -4,20 +4,9 @@ use std::marker::PhantomData;
 use std::thread;
 
 use chorus_lib::core::{
-    ChoreoOp, Choreography, ChoreographyLocation,
-    Deserialize,
-    Faceted,
-    FanInChoreography,
-    HCons, HNil,
-    Located, LocationSet,
-    LocationSetFoldable,
-    Member,
-    MultiplyLocated,
-    Projector,
-    Portable,
-    Quire,
-    Serialize,
-    Subset,
+    ChoreoOp, Choreography, ChoreographyLocation, Deserialize, Faceted, FanInChoreography, HCons,
+    HNil, Located, LocationSet, LocationSetFoldable, Member, MultiplyLocated, Portable, Projector,
+    Quire, Serialize, Subset,
 };
 use chorus_lib::transport::local::{LocalTransport, LocalTransportChannelBuilder};
 
@@ -38,7 +27,6 @@ fn handle_put(key: Key, val: i32) -> Response {
     (val != handle_get(key)) as Response
 }
 
-
 #[derive(ChoreographyLocation, Debug)]
 struct Client;
 
@@ -52,30 +40,39 @@ struct Backup1;
 struct Backup2;
 
 // This should perhaps be in core?
-struct Gather<'a,
-              V,
-              Senders: LocationSet + Subset<Census, SendersPresent>,
-              Recievers: LocationSet + Subset<Census, RecieversPresent>,
-              Census: LocationSet,
-              SendersPresent,
-              RecieversPresent>
-{
+struct Gather<
+    'a,
+    V,
+    Senders: LocationSet + Subset<Census, SendersPresent>,
+    Recievers: LocationSet + Subset<Census, RecieversPresent>,
+    Census: LocationSet,
+    SendersPresent,
+    RecieversPresent,
+> {
     values: &'a Faceted<V, Senders>,
     phantom: PhantomData<(Census, SendersPresent, Recievers, RecieversPresent)>,
 }
-impl<'a,
-     V: Portable + Copy,
-     Senders: LocationSet + Subset<Census, SendersPresent>,
-     Recievers: LocationSet + Subset<Census, RecieversPresent>,
-     Census: LocationSet,
-     SendersPresent,
-     RecieversPresent>
-  FanInChoreography<V> for Gather<'a, V, Senders, Recievers, Census, SendersPresent, RecieversPresent>
+impl<
+        'a,
+        V: Portable + Copy,
+        Senders: LocationSet + Subset<Census, SendersPresent>,
+        Recievers: LocationSet + Subset<Census, RecieversPresent>,
+        Census: LocationSet,
+        SendersPresent,
+        RecieversPresent,
+    > FanInChoreography<V>
+    for Gather<'a, V, Senders, Recievers, Census, SendersPresent, RecieversPresent>
 {
     type L = Census;
     type QS = Senders;
     type RS = Recievers;
-    fn run<Sender: ChoreographyLocation, _SendersPresent, _RecieversPresent, SenderPresent, SenderInSenders>(
+    fn run<
+        Sender: ChoreographyLocation,
+        _SendersPresent,
+        _RecieversPresent,
+        SenderPresent,
+        SenderInSenders,
+    >(
         &self,
         op: &impl ChoreoOp<Self::L>,
     ) -> MultiplyLocated<V, Self::RS>
@@ -95,61 +92,67 @@ impl<'a,
     }
 }
 
-
-struct HandleRequest<Backups, BackupsPresent, BSpine>
-{
+struct HandleRequest<Backups, BackupsPresent, BSpine> {
     request: Located<Request, Server>,
     _phantoms: PhantomData<(Backups, BackupsPresent, BSpine)>,
 }
-impl<Backups: LocationSet, BackupsPresent, BSpine>
-  Choreography<Located<Response, Server>> for HandleRequest<Backups, BackupsPresent, BSpine>
-where Backups: Subset<HCons<Server, Backups>, BackupsPresent>,
-      Backups: LocationSetFoldable<HCons<Server, Backups>, Backups, BSpine>
+impl<Backups: LocationSet, BackupsPresent, BSpine> Choreography<Located<Response, Server>>
+    for HandleRequest<Backups, BackupsPresent, BSpine>
+where
+    Backups: Subset<HCons<Server, Backups>, BackupsPresent>,
+    Backups: LocationSetFoldable<HCons<Server, Backups>, Backups, BSpine>,
 {
     type L = HCons<Server, Backups>;
     fn run(self, op: &impl ChoreoOp<Self::L>) -> Located<Response, Server> {
         match op.broadcast(Server, self.request) {
             Request::Put(key, value) => {
-                let oks = op.parallel(Backups::new(), ||{ handle_put(key.clone(), value) });
+                let oks = op.parallel(Backups::new(), || handle_put(key.clone(), value));
                 let gathered = op.fanin::<Response, Backups, HCons<Server, HNil>, _, _, _, _>(
                     Backups::new(),
-                    Gather{values: &oks, phantom: PhantomData}
-                    );
+                    Gather {
+                        values: &oks,
+                        phantom: PhantomData,
+                    },
+                );
                 op.locally(Server, |un| {
-                  let ok = un.unwrap::<Quire<Response, Backups>, _, _>(&gathered).get_map().into_values().all(|response|{response == 0});
-                  if ok {
-                    return handle_put(key.clone(), value)
-                  } else {
-                    return -1
-                  }
+                    let ok = un
+                        .unwrap::<Quire<Response, Backups>, _, _>(&gathered)
+                        .get_map()
+                        .into_values()
+                        .all(|response| response == 0);
+                    if ok {
+                        return handle_put(key.clone(), value);
+                    } else {
+                        return -1;
+                    }
                 })
             }
-            Request::Get(key) => op.locally(Server, |_| { handle_get(key.clone()) })
+            Request::Get(key) => op.locally(Server, |_| handle_get(key.clone())),
         }
     }
 }
 
-struct KVS<Backups: LocationSet,
-           BackupsPresent,
-           BackupsAreServers,
-           BSpine>
-{
+struct KVS<Backups: LocationSet, BackupsPresent, BackupsAreServers, BSpine> {
     request: Located<Request, Client>,
     _phantoms: PhantomData<(Backups, BackupsPresent, BackupsAreServers, BSpine)>,
 }
 impl<Backups: LocationSet, BackupsPresent, BackupsAreServers, BSpine>
-  Choreography<Located<Response, Client>> for KVS<Backups, BackupsPresent, BackupsAreServers, BSpine>
-where Backups: Subset<HCons<Client, HCons<Server, Backups>>, BackupsPresent>,
-      Backups: Subset<HCons<Server, Backups>, BackupsAreServers>,
-      Backups: LocationSetFoldable<HCons<Server, Backups>, Backups, BSpine>
+    Choreography<Located<Response, Client>>
+    for KVS<Backups, BackupsPresent, BackupsAreServers, BSpine>
+where
+    Backups: Subset<HCons<Client, HCons<Server, Backups>>, BackupsPresent>,
+    Backups: Subset<HCons<Server, Backups>, BackupsAreServers>,
+    Backups: LocationSetFoldable<HCons<Server, Backups>, Backups, BSpine>,
 {
     type L = HCons<Client, HCons<Server, Backups>>;
     fn run(self, op: &impl ChoreoOp<Self::L>) -> Located<Response, Client> {
         let request = op.comm(Client, Server, &self.request);
-        let response = op.enclave(HandleRequest::<Backups, _, _>{
-            request: request,
-            _phantoms: PhantomData
-        }).flatten();
+        let response = op
+            .enclave(HandleRequest::<Backups, _, _> {
+                request: request,
+                _phantoms: PhantomData,
+            })
+            .flatten();
         op.comm(Server, Client, &response)
     }
 }
@@ -161,13 +164,13 @@ fn run_test(request: Request, answer: Response) {
         .with(Backup1)
         .with(Backup2)
         .build();
-    let transport_client  = LocalTransport::new(Client, transport_channel.clone());
-    let transport_server  = LocalTransport::new(Server, transport_channel.clone());
+    let transport_client = LocalTransport::new(Client, transport_channel.clone());
+    let transport_server = LocalTransport::new(Server, transport_channel.clone());
     let transport_backup1 = LocalTransport::new(Backup1, transport_channel.clone());
     let transport_backup2 = LocalTransport::new(Backup2, transport_channel.clone());
 
-    let client_projector  = Projector::new(Client, transport_client);
-    let server_projector  = Projector::new(Server, transport_server);
+    let client_projector = Projector::new(Client, transport_client);
+    let server_projector = Projector::new(Server, transport_server);
     let backup1_projector = Projector::new(Backup1, transport_backup1);
     let backup2_projector = Projector::new(Backup2, transport_backup2);
 
@@ -176,7 +179,7 @@ fn run_test(request: Request, answer: Response) {
         thread::Builder::new()
             .name("Server".to_string())
             .spawn(move || {
-                server_projector.epp_and_run(KVS::<HCons<Backup1, HCons<Backup2, HNil>>, _, _, _>{
+                server_projector.epp_and_run(KVS::<HCons<Backup1, HCons<Backup2, HNil>>, _, _, _> {
                     request: server_projector.remote(Client),
                     _phantoms: PhantomData,
                 })
@@ -187,10 +190,12 @@ fn run_test(request: Request, answer: Response) {
         thread::Builder::new()
             .name("Backup1".to_string())
             .spawn(move || {
-                backup1_projector.epp_and_run(KVS::<HCons<Backup1, HCons<Backup2, HNil>>, _, _, _>{
-                    request: backup1_projector.remote(Client),
-                    _phantoms: PhantomData,
-                })
+                backup1_projector.epp_and_run(
+                    KVS::<HCons<Backup1, HCons<Backup2, HNil>>, _, _, _> {
+                        request: backup1_projector.remote(Client),
+                        _phantoms: PhantomData,
+                    },
+                )
             })
             .unwrap(),
     );
@@ -198,17 +203,20 @@ fn run_test(request: Request, answer: Response) {
         thread::Builder::new()
             .name("Backup2".to_string())
             .spawn(move || {
-                backup2_projector.epp_and_run(KVS::<HCons<Backup1, HCons<Backup2, HNil>>, _, _, _>{
-                    request: backup2_projector.remote(Client),
-                    _phantoms: PhantomData,
-                })
+                backup2_projector.epp_and_run(
+                    KVS::<HCons<Backup1, HCons<Backup2, HNil>>, _, _, _> {
+                        request: backup2_projector.remote(Client),
+                        _phantoms: PhantomData,
+                    },
+                )
             })
             .unwrap(),
     );
-    let retval = client_projector.epp_and_run(KVS::<HCons<Backup1, HCons<Backup2, HNil>>, _, _, _>{
-        request: client_projector.local(request),
-        _phantoms: PhantomData,
-    });
+    let retval =
+        client_projector.epp_and_run(KVS::<HCons<Backup1, HCons<Backup2, HNil>>, _, _, _> {
+            request: client_projector.local(request),
+            _phantoms: PhantomData,
+        });
     for handle in handles {
         handle.join().unwrap();
     }