Refactor Kind out of trait signatures

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "activitystreams"
 description = "A set of core types and traits for activitystreams data"
-version = "0.7.0-alpha.20"
+version = "0.7.0-alpha.21"
 license = "GPL-3.0"
 authors = ["asonix <asonix@asonix.dog>"]
 repository = "https://git.asonix.dog/asonix/activitystreams"

activitystreams-ext/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "activitystreams-ext"
 description = "Extension types for the ActivityStreams crate"
-version = "0.1.0-alpha.2"
+version = "0.1.0-alpha.3"
 license = "GPL-3.0"
 authors = ["asonix <asonix@asonix.dog>"]
 repository = "https://git.asonix.dog/Aardwolf/activitystreams"
@@ -13,7 +13,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-activitystreams = { version = "0.7.0-alpha.3", path = ".." }
+activitystreams = { version = "0.7.0-alpha.21", path = ".." }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 

activitystreams-ext/examples/public_key.rs

@@ -1,10 +1,10 @@
 use activitystreams::{
     actor::{ApActor, Person},
     context,
+    iri_string::types::IriString,
     prelude::*,
     security,
     unparsed::UnparsedMutExt,
-    url::Url,
 };
 use activitystreams_ext::{Ext1, UnparsedExtension};
 
@@ -17,8 +17,8 @@ pub struct PublicKey {
 #[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct PublicKeyInner {
-    id: Url,
-    owner: Url,
+    id: IriString,
+    owner: IriString,
     public_key_pem: String,
 }
 

activitystreams-ext/src/ext1.rs

@@ -1,15 +1,15 @@
 use crate::Ext1;
 use activitystreams::{
     activity::{
-        Activity, ActorAndObjectRef, AsActivity, AsQuestion, OptOriginRef, OptTargetRef, OriginRef,
-        Question, TargetRef,
+        Activity, ActivityActor, ActivityObject, AsActivity, AsActivityActor, AsActivityObject,
+        AsOptOrigin, AsOptTarget, AsOrigin, AsQuestion, AsTarget, OptOrigin, OptTarget, Origin,
+        Question, Target,
     },
     actor::{ApActor, AsApActor},
-    base::{AnyBase, AsBase, Base},
+    base::{AsBase, Base},
     collection::{AsCollection, AsCollectionPage, Collection, CollectionPage},
     markers,
     object::{ApObject, AsApObject, AsObject, Object},
-    primitives::OneOrMany,
 };
 
 impl<Inner, A> markers::Base for Ext1<Inner, A> where Inner: markers::Base {}
@@ -23,28 +23,32 @@ impl<Inner, A> markers::IntransitiveActivity for Ext1<Inner, A> where
 {
 }
 
-impl<Inner, A, Kind> AsBase<Kind> for Ext1<Inner, A>
+impl<Inner, A> AsBase for Ext1<Inner, A>
 where
-    Inner: AsBase<Kind>,
+    Inner: AsBase,
 {
-    fn base_ref(&self) -> &Base<Kind> {
+    type Kind = Inner::Kind;
+
+    fn base_ref(&self) -> &Base<Self::Kind> {
         self.inner.base_ref()
     }
 
-    fn base_mut(&mut self) -> &mut Base<Kind> {
+    fn base_mut(&mut self) -> &mut Base<Self::Kind> {
         self.inner.base_mut()
     }
 }
 
-impl<Inner, A, Kind> AsObject<Kind> for Ext1<Inner, A>
+impl<Inner, A> AsObject for Ext1<Inner, A>
 where
-    Inner: AsObject<Kind>,
+    Inner: AsObject,
 {
-    fn object_ref(&self) -> &Object<Kind> {
+    type Kind = Inner::Kind;
+
+    fn object_ref(&self) -> &Object<Self::Kind> {
         self.inner.object_ref()
     }
 
-    fn object_mut(&mut self) -> &mut Object<Kind> {
+    fn object_mut(&mut self) -> &mut Object<Self::Kind> {
         self.inner.object_mut()
     }
 }
@@ -62,28 +66,32 @@ where
     }
 }
 
-impl<Inner, A, Kind> AsCollection<Kind> for Ext1<Inner, A>
+impl<Inner, A> AsCollection for Ext1<Inner, A>
 where
-    Inner: AsCollection<Kind>,
+    Inner: AsCollection,
 {
-    fn collection_ref(&self) -> &Collection<Kind> {
+    type Kind = Inner::Kind;
+
+    fn collection_ref(&self) -> &Collection<Self::Kind> {
         self.inner.collection_ref()
     }
 
-    fn collection_mut(&mut self) -> &mut Collection<Kind> {
+    fn collection_mut(&mut self) -> &mut Collection<Self::Kind> {
         self.inner.collection_mut()
     }
 }
 
-impl<Inner, A, Kind> AsCollectionPage<Kind> for Ext1<Inner, A>
+impl<Inner, A> AsCollectionPage for Ext1<Inner, A>
 where
-    Inner: AsCollectionPage<Kind>,
+    Inner: AsCollectionPage,
 {
-    fn collection_page_ref(&self) -> &CollectionPage<Kind> {
+    type Kind = Inner::Kind;
+
+    fn collection_page_ref(&self) -> &CollectionPage<Self::Kind> {
         self.inner.collection_page_ref()
     }
 
-    fn collection_page_mut(&mut self) -> &mut CollectionPage<Kind> {
+    fn collection_page_mut(&mut self) -> &mut CollectionPage<Self::Kind> {
         self.inner.collection_page_mut()
     }
 }
@@ -101,89 +109,108 @@ where
     }
 }
 
-impl<Inner, A, Kind> AsActivity<Kind> for Ext1<Inner, A>
+impl<Inner, A> AsActivity for Ext1<Inner, A>
 where
-    Inner: AsActivity<Kind>,
+    Inner: AsActivity,
 {
-    fn activity_ref(&self) -> &Activity<Kind> {
+    type Kind = Inner::Kind;
+
+    fn activity_ref(&self) -> &Activity<Self::Kind> {
         self.inner.activity_ref()
     }
 
-    fn activity_mut(&mut self) -> &mut Activity<Kind> {
+    fn activity_mut(&mut self) -> &mut Activity<Self::Kind> {
         self.inner.activity_mut()
     }
 }
 
-impl<Inner, A> ActorAndObjectRef for Ext1<Inner, A>
+impl<Inner, A> AsActivityActor for Ext1<Inner, A>
 where
-    Inner: ActorAndObjectRef,
+    Inner: AsActivityActor,
 {
-    fn actor_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.actor_field_ref()
+    type Inner = Inner::Inner;
+
+    fn activity_actor_ref(&self) -> &ActivityActor<Self::Inner> {
+        self.inner.activity_actor_ref()
     }
 
-    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.actor_field_mut()
-    }
-
-    fn object_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.object_field_ref()
-    }
-
-    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.object_field_mut()
+    fn activity_actor_mut(&mut self) -> &mut ActivityActor<Self::Inner> {
+        self.inner.activity_actor_mut()
     }
 }
 
-impl<Inner, A> TargetRef for Ext1<Inner, A>
+impl<Inner, A> AsActivityObject for Ext1<Inner, A>
 where
-    Inner: TargetRef,
+    Inner: AsActivityObject,
 {
-    fn target_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.target_field_ref()
+    type Inner = Inner::Inner;
+
+    fn activity_object_ref(&self) -> &ActivityObject<Self::Inner> {
+        self.inner.activity_object_ref()
     }
 
-    fn target_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.target_field_mut()
+    fn activity_object_mut(&mut self) -> &mut ActivityObject<Self::Inner> {
+        self.inner.activity_object_mut()
     }
 }
 
-impl<Inner, A> OriginRef for Ext1<Inner, A>
+impl<Inner, A> AsTarget for Ext1<Inner, A>
 where
-    Inner: OriginRef,
+    Inner: AsTarget,
 {
-    fn origin_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.origin_field_ref()
+    type Inner = Inner::Inner;
+
+    fn target_ref(&self) -> &Target<Self::Inner> {
+        self.inner.target_ref()
     }
 
-    fn origin_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.origin_field_mut()
+    fn target_mut(&mut self) -> &mut Target<Self::Inner> {
+        self.inner.target_mut()
     }
 }
 
-impl<Inner, A> OptTargetRef for Ext1<Inner, A>
+impl<Inner, A> AsOrigin for Ext1<Inner, A>
 where
-    Inner: OptTargetRef,
+    Inner: AsOrigin,
 {
-    fn target_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
-        self.inner.target_field_ref()
+    type Inner = Inner::Inner;
+
+    fn origin_ref(&self) -> &Origin<Self::Inner> {
+        self.inner.origin_ref()
     }
 
-    fn target_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
-        self.inner.target_field_mut()
+    fn origin_mut(&mut self) -> &mut Origin<Self::Inner> {
+        self.inner.origin_mut()
     }
 }
 
-impl<Inner, A> OptOriginRef for Ext1<Inner, A>
+impl<Inner, A> AsOptTarget for Ext1<Inner, A>
 where
-    Inner: OptOriginRef,
+    Inner: AsOptTarget,
 {
-    fn origin_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
-        self.inner.origin_field_ref()
+    type Inner = Inner::Inner;
+
+    fn opt_target_ref(&self) -> &OptTarget<Self::Inner> {
+        self.inner.opt_target_ref()
     }
 
-    fn origin_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
-        self.inner.origin_field_mut()
+    fn opt_target_mut(&mut self) -> &mut OptTarget<Self::Inner> {
+        self.inner.opt_target_mut()
+    }
+}
+
+impl<Inner, A> AsOptOrigin for Ext1<Inner, A>
+where
+    Inner: AsOptOrigin,
+{
+    type Inner = Inner::Inner;
+
+    fn opt_origin_ref(&self) -> &OptOrigin<Self::Inner> {
+        self.inner.opt_origin_ref()
+    }
+
+    fn opt_origin_mut(&mut self) -> &mut OptOrigin<Self::Inner> {
+        self.inner.opt_origin_mut()
     }
 }
 

activitystreams-ext/src/ext2.rs

@@ -1,15 +1,15 @@
 use crate::Ext2;
 use activitystreams::{
     activity::{
-        Activity, ActorAndObjectRef, AsActivity, AsQuestion, OptOriginRef, OptTargetRef, OriginRef,
-        Question, TargetRef,
+        Activity, ActivityActor, ActivityObject, AsActivity, AsActivityActor, AsActivityObject,
+        AsOptOrigin, AsOptTarget, AsOrigin, AsQuestion, AsTarget, OptOrigin, OptTarget, Origin,
+        Question, Target,
     },
     actor::{ApActor, AsApActor},
-    base::{AnyBase, AsBase, Base},
+    base::{AsBase, Base},
     collection::{AsCollection, AsCollectionPage, Collection, CollectionPage},
     markers,
     object::{ApObject, AsApObject, AsObject, Object},
-    primitives::OneOrMany,
 };
 
 impl<Inner, A, B> markers::Base for Ext2<Inner, A, B> where Inner: markers::Base {}
@@ -23,28 +23,32 @@ impl<Inner, A, B> markers::IntransitiveActivity for Ext2<Inner, A, B> where
 {
 }
 
-impl<Inner, A, B, Kind> AsBase<Kind> for Ext2<Inner, A, B>
+impl<Inner, A, B> AsBase for Ext2<Inner, A, B>
 where
-    Inner: AsBase<Kind>,
+    Inner: AsBase,
 {
-    fn base_ref(&self) -> &Base<Kind> {
+    type Kind = Inner::Kind;
+
+    fn base_ref(&self) -> &Base<Self::Kind> {
         self.inner.base_ref()
     }
 
-    fn base_mut(&mut self) -> &mut Base<Kind> {
+    fn base_mut(&mut self) -> &mut Base<Self::Kind> {
         self.inner.base_mut()
     }
 }
 
-impl<Inner, A, B, Kind> AsObject<Kind> for Ext2<Inner, A, B>
+impl<Inner, A, B> AsObject for Ext2<Inner, A, B>
 where
-    Inner: AsObject<Kind>,
+    Inner: AsObject,
 {
-    fn object_ref(&self) -> &Object<Kind> {
+    type Kind = Inner::Kind;
+
+    fn object_ref(&self) -> &Object<Self::Kind> {
         self.inner.object_ref()
     }
 
-    fn object_mut(&mut self) -> &mut Object<Kind> {
+    fn object_mut(&mut self) -> &mut Object<Self::Kind> {
         self.inner.object_mut()
     }
 }
@@ -62,28 +66,32 @@ where
     }
 }
 
-impl<Inner, A, B, Kind> AsCollection<Kind> for Ext2<Inner, A, B>
+impl<Inner, A, B> AsCollection for Ext2<Inner, A, B>
 where
-    Inner: AsCollection<Kind>,
+    Inner: AsCollection,
 {
-    fn collection_ref(&self) -> &Collection<Kind> {
+    type Kind = Inner::Kind;
+
+    fn collection_ref(&self) -> &Collection<Self::Kind> {
         self.inner.collection_ref()
     }
 
-    fn collection_mut(&mut self) -> &mut Collection<Kind> {
+    fn collection_mut(&mut self) -> &mut Collection<Self::Kind> {
         self.inner.collection_mut()
     }
 }
 
-impl<Inner, A, B, Kind> AsCollectionPage<Kind> for Ext2<Inner, A, B>
+impl<Inner, A, B> AsCollectionPage for Ext2<Inner, A, B>
 where
-    Inner: AsCollectionPage<Kind>,
+    Inner: AsCollectionPage,
 {
-    fn collection_page_ref(&self) -> &CollectionPage<Kind> {
+    type Kind = Inner::Kind;
+
+    fn collection_page_ref(&self) -> &CollectionPage<Self::Kind> {
         self.inner.collection_page_ref()
     }
 
-    fn collection_page_mut(&mut self) -> &mut CollectionPage<Kind> {
+    fn collection_page_mut(&mut self) -> &mut CollectionPage<Self::Kind> {
         self.inner.collection_page_mut()
     }
 }
@@ -101,89 +109,108 @@ where
     }
 }
 
-impl<Inner, A, B, Kind> AsActivity<Kind> for Ext2<Inner, A, B>
+impl<Inner, A, B> AsActivity for Ext2<Inner, A, B>
 where
-    Inner: AsActivity<Kind>,
+    Inner: AsActivity,
 {
-    fn activity_ref(&self) -> &Activity<Kind> {
+    type Kind = Inner::Kind;
+
+    fn activity_ref(&self) -> &Activity<Self::Kind> {
         self.inner.activity_ref()
     }
 
-    fn activity_mut(&mut self) -> &mut Activity<Kind> {
+    fn activity_mut(&mut self) -> &mut Activity<Self::Kind> {
         self.inner.activity_mut()
     }
 }
 
-impl<Inner, A, B> ActorAndObjectRef for Ext2<Inner, A, B>
+impl<Inner, A, B> AsActivityActor for Ext2<Inner, A, B>
 where
-    Inner: ActorAndObjectRef,
+    Inner: AsActivityActor,
 {
-    fn actor_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.actor_field_ref()
+    type Inner = Inner::Inner;
+
+    fn activity_actor_ref(&self) -> &ActivityActor<Self::Inner> {
+        self.inner.activity_actor_ref()
     }
 
-    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.actor_field_mut()
-    }
-
-    fn object_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.object_field_ref()
-    }
-
-    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.object_field_mut()
+    fn activity_actor_mut(&mut self) -> &mut ActivityActor<Self::Inner> {
+        self.inner.activity_actor_mut()
     }
 }
 
-impl<Inner, A, B> TargetRef for Ext2<Inner, A, B>
+impl<Inner, A, B> AsActivityObject for Ext2<Inner, A, B>
 where
-    Inner: TargetRef,
+    Inner: AsActivityObject,
 {
-    fn target_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.target_field_ref()
+    type Inner = Inner::Inner;
+
+    fn activity_object_ref(&self) -> &ActivityObject<Self::Inner> {
+        self.inner.activity_object_ref()
     }
 
-    fn target_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.target_field_mut()
+    fn activity_object_mut(&mut self) -> &mut ActivityObject<Self::Inner> {
+        self.inner.activity_object_mut()
     }
 }
 
-impl<Inner, A, B> OriginRef for Ext2<Inner, A, B>
+impl<Inner, A, B> AsTarget for Ext2<Inner, A, B>
 where
-    Inner: OriginRef,
+    Inner: AsTarget,
 {
-    fn origin_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.origin_field_ref()
+    type Inner = Inner::Inner;
+
+    fn target_ref(&self) -> &Target<Self::Inner> {
+        self.inner.target_ref()
     }
 
-    fn origin_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.origin_field_mut()
+    fn target_mut(&mut self) -> &mut Target<Self::Inner> {
+        self.inner.target_mut()
     }
 }
 
-impl<Inner, A, B> OptTargetRef for Ext2<Inner, A, B>
+impl<Inner, A, B> AsOrigin for Ext2<Inner, A, B>
 where
-    Inner: OptTargetRef,
+    Inner: AsOrigin,
 {
-    fn target_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
-        self.inner.target_field_ref()
+    type Inner = Inner::Inner;
+
+    fn origin_ref(&self) -> &Origin<Self::Inner> {
+        self.inner.origin_ref()
     }
 
-    fn target_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
-        self.inner.target_field_mut()
+    fn origin_mut(&mut self) -> &mut Origin<Self::Inner> {
+        self.inner.origin_mut()
     }
 }
 
-impl<Inner, A, B> OptOriginRef for Ext2<Inner, A, B>
+impl<Inner, A, B> AsOptTarget for Ext2<Inner, A, B>
 where
-    Inner: OptOriginRef,
+    Inner: AsOptTarget,
 {
-    fn origin_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
-        self.inner.origin_field_ref()
+    type Inner = Inner::Inner;
+
+    fn opt_target_ref(&self) -> &OptTarget<Self::Inner> {
+        self.inner.opt_target_ref()
     }
 
-    fn origin_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
-        self.inner.origin_field_mut()
+    fn opt_target_mut(&mut self) -> &mut OptTarget<Self::Inner> {
+        self.inner.opt_target_mut()
+    }
+}
+
+impl<Inner, A, B> AsOptOrigin for Ext2<Inner, A, B>
+where
+    Inner: AsOptOrigin,
+{
+    type Inner = Inner::Inner;
+
+    fn opt_origin_ref(&self) -> &OptOrigin<Self::Inner> {
+        self.inner.opt_origin_ref()
+    }
+
+    fn opt_origin_mut(&mut self) -> &mut OptOrigin<Self::Inner> {
+        self.inner.opt_origin_mut()
     }
 }
 

activitystreams-ext/src/ext3.rs

@@ -1,15 +1,15 @@
 use crate::Ext3;
 use activitystreams::{
     activity::{
-        Activity, ActorAndObjectRef, AsActivity, AsQuestion, OptOriginRef, OptTargetRef, OriginRef,
-        Question, TargetRef,
+        Activity, ActivityActor, ActivityObject, AsActivity, AsActivityActor, AsActivityObject,
+        AsOptOrigin, AsOptTarget, AsOrigin, AsQuestion, AsTarget, OptOrigin, OptTarget, Origin,
+        Question, Target,
     },
     actor::{ApActor, AsApActor},
-    base::{AnyBase, AsBase, Base},
+    base::{AsBase, Base},
     collection::{AsCollection, AsCollectionPage, Collection, CollectionPage},
     markers,
     object::{ApObject, AsApObject, AsObject, Object},
-    primitives::OneOrMany,
 };
 
 impl<Inner, A, B, C> markers::Base for Ext3<Inner, A, B, C> where Inner: markers::Base {}
@@ -26,28 +26,32 @@ impl<Inner, A, B, C> markers::IntransitiveActivity for Ext3<Inner, A, B, C> wher
 {
 }
 
-impl<Inner, A, B, C, Kind> AsBase<Kind> for Ext3<Inner, A, B, C>
+impl<Inner, A, B, C> AsBase for Ext3<Inner, A, B, C>
 where
-    Inner: AsBase<Kind>,
+    Inner: AsBase,
 {
-    fn base_ref(&self) -> &Base<Kind> {
+    type Kind = Inner::Kind;
+
+    fn base_ref(&self) -> &Base<Self::Kind> {
         self.inner.base_ref()
     }
 
-    fn base_mut(&mut self) -> &mut Base<Kind> {
+    fn base_mut(&mut self) -> &mut Base<Self::Kind> {
         self.inner.base_mut()
     }
 }
 
-impl<Inner, A, B, C, Kind> AsObject<Kind> for Ext3<Inner, A, B, C>
+impl<Inner, A, B, C> AsObject for Ext3<Inner, A, B, C>
 where
-    Inner: AsObject<Kind>,
+    Inner: AsObject,
 {
-    fn object_ref(&self) -> &Object<Kind> {
+    type Kind = Inner::Kind;
+
+    fn object_ref(&self) -> &Object<Self::Kind> {
         self.inner.object_ref()
     }
 
-    fn object_mut(&mut self) -> &mut Object<Kind> {
+    fn object_mut(&mut self) -> &mut Object<Self::Kind> {
         self.inner.object_mut()
     }
 }
@@ -65,28 +69,32 @@ where
     }
 }
 
-impl<Inner, A, B, C, Kind> AsCollection<Kind> for Ext3<Inner, A, B, C>
+impl<Inner, A, B, C> AsCollection for Ext3<Inner, A, B, C>
 where
-    Inner: AsCollection<Kind>,
+    Inner: AsCollection,
 {
-    fn collection_ref(&self) -> &Collection<Kind> {
+    type Kind = Inner::Kind;
+
+    fn collection_ref(&self) -> &Collection<Self::Kind> {
         self.inner.collection_ref()
     }
 
-    fn collection_mut(&mut self) -> &mut Collection<Kind> {
+    fn collection_mut(&mut self) -> &mut Collection<Self::Kind> {
         self.inner.collection_mut()
     }
 }
 
-impl<Inner, A, B, C, Kind> AsCollectionPage<Kind> for Ext3<Inner, A, B, C>
+impl<Inner, A, B, C> AsCollectionPage for Ext3<Inner, A, B, C>
 where
-    Inner: AsCollectionPage<Kind>,
+    Inner: AsCollectionPage,
 {
-    fn collection_page_ref(&self) -> &CollectionPage<Kind> {
+    type Kind = Inner::Kind;
+
+    fn collection_page_ref(&self) -> &CollectionPage<Self::Kind> {
         self.inner.collection_page_ref()
     }
 
-    fn collection_page_mut(&mut self) -> &mut CollectionPage<Kind> {
+    fn collection_page_mut(&mut self) -> &mut CollectionPage<Self::Kind> {
         self.inner.collection_page_mut()
     }
 }
@@ -104,89 +112,108 @@ where
     }
 }
 
-impl<Inner, A, B, C, Kind> AsActivity<Kind> for Ext3<Inner, A, B, C>
+impl<Inner, A, B, C> AsActivity for Ext3<Inner, A, B, C>
 where
-    Inner: AsActivity<Kind>,
+    Inner: AsActivity,
 {
-    fn activity_ref(&self) -> &Activity<Kind> {
+    type Kind = Inner::Kind;
+
+    fn activity_ref(&self) -> &Activity<Self::Kind> {
         self.inner.activity_ref()
     }
 
-    fn activity_mut(&mut self) -> &mut Activity<Kind> {
+    fn activity_mut(&mut self) -> &mut Activity<Self::Kind> {
         self.inner.activity_mut()
     }
 }
 
-impl<Inner, A, B, C> ActorAndObjectRef for Ext3<Inner, A, B, C>
+impl<Inner, A, B, C> AsActivityActor for Ext3<Inner, A, B, C>
 where
-    Inner: ActorAndObjectRef,
+    Inner: AsActivityActor,
 {
-    fn actor_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.actor_field_ref()
+    type Inner = Inner::Inner;
+
+    fn activity_actor_ref(&self) -> &ActivityActor<Self::Inner> {
+        self.inner.activity_actor_ref()
     }
 
-    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.actor_field_mut()
-    }
-
-    fn object_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.object_field_ref()
-    }
-
-    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.object_field_mut()
+    fn activity_actor_mut(&mut self) -> &mut ActivityActor<Self::Inner> {
+        self.inner.activity_actor_mut()
     }
 }
 
-impl<Inner, A, B, C> TargetRef for Ext3<Inner, A, B, C>
+impl<Inner, A, B, C> AsActivityObject for Ext3<Inner, A, B, C>
 where
-    Inner: TargetRef,
+    Inner: AsActivityObject,
 {
-    fn target_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.target_field_ref()
+    type Inner = Inner::Inner;
+
+    fn activity_object_ref(&self) -> &ActivityObject<Self::Inner> {
+        self.inner.activity_object_ref()
     }
 
-    fn target_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.target_field_mut()
+    fn activity_object_mut(&mut self) -> &mut ActivityObject<Self::Inner> {
+        self.inner.activity_object_mut()
     }
 }
 
-impl<Inner, A, B, C> OriginRef for Ext3<Inner, A, B, C>
+impl<Inner, A, B, C> AsTarget for Ext3<Inner, A, B, C>
 where
-    Inner: OriginRef,
+    Inner: AsTarget,
 {
-    fn origin_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.origin_field_ref()
+    type Inner = Inner::Inner;
+
+    fn target_ref(&self) -> &Target<Self::Inner> {
+        self.inner.target_ref()
     }
 
-    fn origin_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.origin_field_mut()
+    fn target_mut(&mut self) -> &mut Target<Self::Inner> {
+        self.inner.target_mut()
     }
 }
 
-impl<Inner, A, B, C> OptTargetRef for Ext3<Inner, A, B, C>
+impl<Inner, A, B, C> AsOrigin for Ext3<Inner, A, B, C>
 where
-    Inner: OptTargetRef,
+    Inner: AsOrigin,
 {
-    fn target_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
-        self.inner.target_field_ref()
+    type Inner = Inner::Inner;
+
+    fn origin_ref(&self) -> &Origin<Self::Inner> {
+        self.inner.origin_ref()
     }
 
-    fn target_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
-        self.inner.target_field_mut()
+    fn origin_mut(&mut self) -> &mut Origin<Self::Inner> {
+        self.inner.origin_mut()
     }
 }
 
-impl<Inner, A, B, C> OptOriginRef for Ext3<Inner, A, B, C>
+impl<Inner, A, B, C> AsOptTarget for Ext3<Inner, A, B, C>
 where
-    Inner: OptOriginRef,
+    Inner: AsOptTarget,
 {
-    fn origin_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
-        self.inner.origin_field_ref()
+    type Inner = Inner::Inner;
+
+    fn opt_target_ref(&self) -> &OptTarget<Self::Inner> {
+        self.inner.opt_target_ref()
     }
 
-    fn origin_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
-        self.inner.origin_field_mut()
+    fn opt_target_mut(&mut self) -> &mut OptTarget<Self::Inner> {
+        self.inner.opt_target_mut()
+    }
+}
+
+impl<Inner, A, B, C> AsOptOrigin for Ext3<Inner, A, B, C>
+where
+    Inner: AsOptOrigin,
+{
+    type Inner = Inner::Inner;
+
+    fn opt_origin_ref(&self) -> &OptOrigin<Self::Inner> {
+        self.inner.opt_origin_ref()
+    }
+
+    fn opt_origin_mut(&mut self) -> &mut OptOrigin<Self::Inner> {
+        self.inner.opt_origin_mut()
     }
 }
 

activitystreams-ext/src/ext4.rs

@@ -1,15 +1,15 @@
 use crate::Ext4;
 use activitystreams::{
     activity::{
-        Activity, ActorAndObjectRef, AsActivity, AsQuestion, OptOriginRef, OptTargetRef, OriginRef,
-        Question, TargetRef,
+        Activity, ActivityActor, ActivityObject, AsActivity, AsActivityActor, AsActivityObject,
+        AsOptOrigin, AsOptTarget, AsOrigin, AsQuestion, AsTarget, OptOrigin, OptTarget, Origin,
+        Question, Target,
     },
     actor::{ApActor, AsApActor},
-    base::{AnyBase, AsBase, Base},
+    base::{AsBase, Base},
     collection::{AsCollection, AsCollectionPage, Collection, CollectionPage},
     markers,
     object::{ApObject, AsApObject, AsObject, Object},
-    primitives::OneOrMany,
 };
 
 impl<Inner, A, B, C, D> markers::Base for Ext4<Inner, A, B, C, D> where Inner: markers::Base {}
@@ -29,28 +29,32 @@ impl<Inner, A, B, C, D> markers::IntransitiveActivity for Ext4<Inner, A, B, C, D
 {
 }
 
-impl<Inner, A, B, C, D, Kind> AsBase<Kind> for Ext4<Inner, A, B, C, D>
+impl<Inner, A, B, C, D> AsBase for Ext4<Inner, A, B, C, D>
 where
-    Inner: AsBase<Kind>,
+    Inner: AsBase,
 {
-    fn base_ref(&self) -> &Base<Kind> {
+    type Kind = Inner::Kind;
+
+    fn base_ref(&self) -> &Base<Self::Kind> {
         self.inner.base_ref()
     }
 
-    fn base_mut(&mut self) -> &mut Base<Kind> {
+    fn base_mut(&mut self) -> &mut Base<Self::Kind> {
         self.inner.base_mut()
     }
 }
 
-impl<Inner, A, B, C, D, Kind> AsObject<Kind> for Ext4<Inner, A, B, C, D>
+impl<Inner, A, B, C, D> AsObject for Ext4<Inner, A, B, C, D>
 where
-    Inner: AsObject<Kind>,
+    Inner: AsObject,
 {
-    fn object_ref(&self) -> &Object<Kind> {
+    type Kind = Inner::Kind;
+
+    fn object_ref(&self) -> &Object<Self::Kind> {
         self.inner.object_ref()
     }
 
-    fn object_mut(&mut self) -> &mut Object<Kind> {
+    fn object_mut(&mut self) -> &mut Object<Self::Kind> {
         self.inner.object_mut()
     }
 }
@@ -68,28 +72,32 @@ where
     }
 }
 
-impl<Inner, A, B, C, D, Kind> AsCollection<Kind> for Ext4<Inner, A, B, C, D>
+impl<Inner, A, B, C, D> AsCollection for Ext4<Inner, A, B, C, D>
 where
-    Inner: AsCollection<Kind>,
+    Inner: AsCollection,
 {
-    fn collection_ref(&self) -> &Collection<Kind> {
+    type Kind = Inner::Kind;
+
+    fn collection_ref(&self) -> &Collection<Self::Kind> {
         self.inner.collection_ref()
     }
 
-    fn collection_mut(&mut self) -> &mut Collection<Kind> {
+    fn collection_mut(&mut self) -> &mut Collection<Self::Kind> {
         self.inner.collection_mut()
     }
 }
 
-impl<Inner, A, B, C, D, Kind> AsCollectionPage<Kind> for Ext4<Inner, A, B, C, D>
+impl<Inner, A, B, C, D> AsCollectionPage for Ext4<Inner, A, B, C, D>
 where
-    Inner: AsCollectionPage<Kind>,
+    Inner: AsCollectionPage,
 {
-    fn collection_page_ref(&self) -> &CollectionPage<Kind> {
+    type Kind = Inner::Kind;
+
+    fn collection_page_ref(&self) -> &CollectionPage<Self::Kind> {
         self.inner.collection_page_ref()
     }
 
-    fn collection_page_mut(&mut self) -> &mut CollectionPage<Kind> {
+    fn collection_page_mut(&mut self) -> &mut CollectionPage<Self::Kind> {
         self.inner.collection_page_mut()
     }
 }
@@ -107,89 +115,108 @@ where
     }
 }
 
-impl<Inner, A, B, C, D, Kind> AsActivity<Kind> for Ext4<Inner, A, B, C, D>
+impl<Inner, A, B, C, D> AsActivity for Ext4<Inner, A, B, C, D>
 where
-    Inner: AsActivity<Kind>,
+    Inner: AsActivity,
 {
-    fn activity_ref(&self) -> &Activity<Kind> {
+    type Kind = Inner::Kind;
+
+    fn activity_ref(&self) -> &Activity<Self::Kind> {
         self.inner.activity_ref()
     }
 
-    fn activity_mut(&mut self) -> &mut Activity<Kind> {
+    fn activity_mut(&mut self) -> &mut Activity<Self::Kind> {
         self.inner.activity_mut()
     }
 }
 
-impl<Inner, A, B, C, D> ActorAndObjectRef for Ext4<Inner, A, B, C, D>
+impl<Inner, A, B, C, D> AsActivityActor for Ext4<Inner, A, B, C, D>
 where
-    Inner: ActorAndObjectRef,
+    Inner: AsActivityActor,
 {
-    fn actor_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.actor_field_ref()
+    type Inner = Inner::Inner;
+
+    fn activity_actor_ref(&self) -> &ActivityActor<Self::Inner> {
+        self.inner.activity_actor_ref()
     }
 
-    fn actor_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.actor_field_mut()
-    }
-
-    fn object_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.object_field_ref()
-    }
-
-    fn object_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.object_field_mut()
+    fn activity_actor_mut(&mut self) -> &mut ActivityActor<Self::Inner> {
+        self.inner.activity_actor_mut()
     }
 }
 
-impl<Inner, A, B, C, D> TargetRef for Ext4<Inner, A, B, C, D>
+impl<Inner, A, B, C, D> AsActivityObject for Ext4<Inner, A, B, C, D>
 where
-    Inner: TargetRef,
+    Inner: AsActivityObject,
 {
-    fn target_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.target_field_ref()
+    type Inner = Inner::Inner;
+
+    fn activity_object_ref(&self) -> &ActivityObject<Self::Inner> {
+        self.inner.activity_object_ref()
     }
 
-    fn target_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.target_field_mut()
+    fn activity_object_mut(&mut self) -> &mut ActivityObject<Self::Inner> {
+        self.inner.activity_object_mut()
     }
 }
 
-impl<Inner, A, B, C, D> OriginRef for Ext4<Inner, A, B, C, D>
+impl<Inner, A, B, C, D> AsTarget for Ext4<Inner, A, B, C, D>
 where
-    Inner: OriginRef,
+    Inner: AsTarget,
 {
-    fn origin_field_ref(&self) -> &OneOrMany<AnyBase> {
-        self.inner.origin_field_ref()
+    type Inner = Inner::Inner;
+
+    fn target_ref(&self) -> &Target<Self::Inner> {
+        self.inner.target_ref()
     }
 
-    fn origin_field_mut(&mut self) -> &mut OneOrMany<AnyBase> {
-        self.inner.origin_field_mut()
+    fn target_mut(&mut self) -> &mut Target<Self::Inner> {
+        self.inner.target_mut()
     }
 }
 
-impl<Inner, A, B, C, D> OptTargetRef for Ext4<Inner, A, B, C, D>
+impl<Inner, A, B, C, D> AsOrigin for Ext4<Inner, A, B, C, D>
 where
-    Inner: OptTargetRef,
+    Inner: AsOrigin,
 {
-    fn target_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
-        self.inner.target_field_ref()
+    type Inner = Inner::Inner;
+
+    fn origin_ref(&self) -> &Origin<Self::Inner> {
+        self.inner.origin_ref()
     }
 
-    fn target_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
-        self.inner.target_field_mut()
+    fn origin_mut(&mut self) -> &mut Origin<Self::Inner> {
+        self.inner.origin_mut()
     }
 }
 
-impl<Inner, A, B, C, D> OptOriginRef for Ext4<Inner, A, B, C, D>
+impl<Inner, A, B, C, D> AsOptTarget for Ext4<Inner, A, B, C, D>
 where
-    Inner: OptOriginRef,
+    Inner: AsOptTarget,
 {
-    fn origin_field_ref(&self) -> &Option<OneOrMany<AnyBase>> {
-        self.inner.origin_field_ref()
+    type Inner = Inner::Inner;
+
+    fn opt_target_ref(&self) -> &OptTarget<Self::Inner> {
+        self.inner.opt_target_ref()
     }
 
-    fn origin_field_mut(&mut self) -> &mut Option<OneOrMany<AnyBase>> {
-        self.inner.origin_field_mut()
+    fn opt_target_mut(&mut self) -> &mut OptTarget<Self::Inner> {
+        self.inner.opt_target_mut()
+    }
+}
+
+impl<Inner, A, B, C, D> AsOptOrigin for Ext4<Inner, A, B, C, D>
+where
+    Inner: AsOptOrigin,
+{
+    type Inner = Inner::Inner;
+
+    fn opt_origin_ref(&self) -> &OptOrigin<Self::Inner> {
+        self.inner.opt_origin_ref()
+    }
+
+    fn opt_origin_mut(&mut self) -> &mut OptOrigin<Self::Inner> {
+        self.inner.opt_origin_mut()
     }
 }
 

activitystreams-ext/src/lib.rs

@@ -1,10 +1,10 @@
 //! # An extension API for activitystreams
 //! _This crate provides Ext1, Ext2, Ext3, and Ext4 for adding extensions to ActivityStreams types_
 //!
-//! - Find the code on [git.asonix.dog](https://git.asonix.dog/Aardwolf/activitystreams)
+//! - Find the code on [git.asonix.dog](https://git.asonix.dog/asonix/activitystreams)
 //! - Read the docs on [docs.rs](https://docs.rs/activitystreams-ext)
 //! - Join the matrix channel at [#activitypub:asonix.dog](https://matrix.to/#/!fAEcHyTUdAaKCzIKCt:asonix.dog?via=asonix.dog&via=matrix.org&via=t2bot.io)
-//! - Hit me up on [mastodon](https://asonix.dog/@asonix)
+//! - Hit me up on [mastodon](https://masto.asonix.dog/@asonix)
 //!
 //! ## Usage
 //!
@@ -23,7 +23,7 @@
 //!     prelude::*,
 //!     security,
 //!     unparsed::UnparsedMutExt,
-//!     url::Url,
+//!     iri_string::types::IriString,
 //! };
 //! use activitystreams_ext::{Ext1, UnparsedExtension};
 //!
@@ -36,8 +36,8 @@
 //! #[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
 //! #[serde(rename_all = "camelCase")]
 //! pub struct PublicKeyInner {
-//!     id: Url,
-//!     owner: Url,
+//!     id: IriString,
+//!     owner: IriString,
 //!     public_key_pem: String,
 //! }
 //!
@@ -264,22 +264,24 @@ impl<Inner, A, B, C, D> Ext4<Inner, A, B, C, D> {
     }
 }
 
-impl<Inner, A, Kind, Error> Extends<Kind> for Ext1<Inner, A>
+impl<Inner, A, Error> Extends for Ext1<Inner, A>
 where
-    Inner: Extends<Kind, Error = Error> + UnparsedMut,
+    Inner: Extends<Error = Error> + UnparsedMut,
     A: UnparsedExtension<Inner, Error = Error>,
     Error: From<serde_json::Error> + std::error::Error,
 {
+    type Kind = Inner::Kind;
+
     type Error = Error;
 
-    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+    fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
         let mut inner = Inner::extends(base)?;
         let ext_one = A::try_from_unparsed(&mut inner)?;
 
         Ok(Ext1 { inner, ext_one })
     }
 
-    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+    fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
         let Ext1 { mut inner, ext_one } = self;
 
         ext_one.try_into_unparsed(&mut inner)?;
@@ -287,16 +289,18 @@ where
     }
 }
 
-impl<Inner, A, B, Kind, Error> Extends<Kind> for Ext2<Inner, A, B>
+impl<Inner, A, B, Error> Extends for Ext2<Inner, A, B>
 where
-    Inner: Extends<Kind, Error = Error> + UnparsedMut,
+    Inner: Extends<Error = Error> + UnparsedMut,
     A: UnparsedExtension<Inner, Error = Error>,
     B: UnparsedExtension<Inner, Error = Error>,
     Error: From<serde_json::Error> + std::error::Error,
 {
+    type Kind = Inner::Kind;
+
     type Error = Error;
 
-    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+    fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
         let mut inner = Inner::extends(base)?;
         let ext_one = A::try_from_unparsed(&mut inner)?;
         let ext_two = B::try_from_unparsed(&mut inner)?;
@@ -308,7 +312,7 @@ where
         })
     }
 
-    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+    fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
         let Ext2 {
             mut inner,
             ext_one,
@@ -321,17 +325,19 @@ where
     }
 }
 
-impl<Inner, A, B, C, Kind, Error> Extends<Kind> for Ext3<Inner, A, B, C>
+impl<Inner, A, B, C, Error> Extends for Ext3<Inner, A, B, C>
 where
-    Inner: Extends<Kind, Error = Error> + UnparsedMut,
+    Inner: Extends<Error = Error> + UnparsedMut,
     A: UnparsedExtension<Inner, Error = Error>,
     B: UnparsedExtension<Inner, Error = Error>,
     C: UnparsedExtension<Inner, Error = Error>,
     Error: From<serde_json::Error> + std::error::Error,
 {
+    type Kind = Inner::Kind;
+
     type Error = Error;
 
-    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+    fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
         let mut inner = Inner::extends(base)?;
         let ext_one = A::try_from_unparsed(&mut inner)?;
         let ext_two = B::try_from_unparsed(&mut inner)?;
@@ -345,7 +351,7 @@ where
         })
     }
 
-    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+    fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
         let Ext3 {
             mut inner,
             ext_one,
@@ -360,18 +366,20 @@ where
     }
 }
 
-impl<Inner, A, B, C, D, Kind, Error> Extends<Kind> for Ext4<Inner, A, B, C, D>
+impl<Inner, A, B, C, D, Error> Extends for Ext4<Inner, A, B, C, D>
 where
-    Inner: Extends<Kind, Error = Error> + UnparsedMut,
+    Inner: Extends<Error = Error> + UnparsedMut,
     A: UnparsedExtension<Inner, Error = Error>,
     B: UnparsedExtension<Inner, Error = Error>,
     C: UnparsedExtension<Inner, Error = Error>,
     D: UnparsedExtension<Inner, Error = Error>,
     Error: From<serde_json::Error> + std::error::Error,
 {
+    type Kind = Inner::Kind;
+
     type Error = Error;
 
-    fn extends(base: Base<Kind>) -> Result<Self, Self::Error> {
+    fn extends(base: Base<Self::Kind>) -> Result<Self, Self::Error> {
         let mut inner = Inner::extends(base)?;
         let ext_one = A::try_from_unparsed(&mut inner)?;
         let ext_two = B::try_from_unparsed(&mut inner)?;
@@ -387,7 +395,7 @@ where
         })
     }
 
-    fn retracts(self) -> Result<Base<Kind>, Self::Error> {
+    fn retracts(self) -> Result<Base<Self::Kind>, Self::Error> {
         let Ext4 {
             mut inner,
             ext_one,

examples/handle_incoming.rs

@@ -33,7 +33,7 @@ pub fn handle_activity(activity: AcceptedActivity) -> Result<(), anyhow::Error>
     Ok(())
 }
 
-static EXAMPLE_JSON: &str = r#"{"actor":"https://asonix.dog/users/asonix","object":"https://asonix.dog/users/asonix/posts/1","type":"Announce"}"#;
+static EXAMPLE_JSON: &str = r#"{"id":"https://asonix.dog/activities/1","actor":"https://asonix.dog/users/asonix","object":"https://asonix.dog/users/asonix/posts/1","type":"Announce"}"#;
 
 fn main() -> Result<(), anyhow::Error> {
     handle_activity(serde_json::from_str(EXAMPLE_JSON)?)

src/actor.rs

@@ -62,10 +62,10 @@ pub trait ApActorExt<Inner>: AsApActor<Inner> {
     ///
     /// let inbox_ref = person.inbox();
     /// ```
-    fn inbox<'a, Kind>(&'a self) -> Result<&'a IriString, CheckError>
+    fn inbox<'a>(&'a self) -> Result<&'a IriString, CheckError>
     where
         Inner: 'a,
-        Self: BaseExt<Kind>,
+        Self: BaseExt,
     {
         let inbox = self.inbox_unchecked();
         self.check_authority(inbox)
@@ -129,10 +129,10 @@ pub trait ApActorExt<Inner>: AsApActor<Inner> {
     ///
     /// let outbox_ref = person.outbox();
     /// ```
-    fn outbox<'a, Kind>(&'a self) -> Result<Option<&'a IriString>, CheckError>
+    fn outbox<'a>(&'a self) -> Result<Option<&'a IriString>, CheckError>