Change vocab Add methods to Append and Prepend

This allows the reverse chronological order to be set as items are
easily prepended to non-functional activity stream properties.

pub/fed.go

@@ -422,11 +422,11 @@ func (f *federator) handleClientCreate(ctx context.Context, deliverable *bool, t
 			for i, attributedToMap := range objectAttributedToIds {
 				if _, ok := attributedToMap[k]; !ok {
 					if vObj, ok := v.(vocab.ObjectType); ok {
-						obj[i].AddAttributedToObject(vObj)
+						obj[i].AppendAttributedToObject(vObj)
 					} else if vLink, ok := v.(vocab.LinkType); ok {
-						obj[i].AddAttributedToLink(vLink)
+						obj[i].AppendAttributedToLink(vLink)
 					} else if vIRI, ok := v.(url.URL); ok {
-						obj[i].AddAttributedToIRI(vIRI)
+						obj[i].AppendAttributedToIRI(vIRI)
 					}
 				}
 			}
@@ -435,11 +435,11 @@ func (f *federator) handleClientCreate(ctx context.Context, deliverable *bool, t
 			for k, v := range attributedToMap {
 				if _, ok := createActorIds[k]; !ok {
 					if vObj, ok := v.(vocab.ObjectType); ok {
-						c.AddActorObject(vObj)
+						c.AppendActorObject(vObj)
 					} else if vLink, ok := v.(vocab.LinkType); ok {
-						c.AddActorLink(vLink)
+						c.AppendActorLink(vLink)
 					} else if vIRI, ok := v.(url.URL); ok {
-						c.AddActorIRI(vIRI)
+						c.AppendActorIRI(vIRI)
 					}
 				}
 			}
@@ -623,9 +623,9 @@ func (f *federator) handleClientAdd(c context.Context, deliverable *bool) func(s
 					continue
 				}
 				if ct, ok := target.(vocab.CollectionType); ok {
-					ct.AddItemsObject(obj)
+					ct.AppendItemsObject(obj)
 				} else if oct, ok := target.(vocab.OrderedCollectionType); ok {
-					oct.AddOrderedItemsObject(obj)
+					oct.AppendOrderedItemsObject(obj)
 				}
 				if err := f.App.Set(c, target); err != nil {
 					return err
@@ -867,14 +867,14 @@ func (f *federator) handleFollow(c context.Context, inboxURL url.URL) func(s *st
 				activity = &vocab.Reject{}
 			}
 			raw := s.Raw()
-			activity.AddObject(raw)
+			activity.AppendObject(raw)
 			for i := 0; i < raw.ActorLen(); i++ {
 				if raw.IsActorObject(i) {
-					activity.AddToObject(raw.GetActorObject(i))
+					activity.AppendToObject(raw.GetActorObject(i))
 				} else if raw.IsActorLink(i) {
-					activity.AddToLink(raw.GetActorLink(i))
+					activity.AppendToLink(raw.GetActorLink(i))
 				} else if raw.IsActorIRI(i) {
-					activity.AddToIRI(raw.GetActorIRI(i))
+					activity.AppendToIRI(raw.GetActorIRI(i))
 				}
 			}
 			ownsAny := false
@@ -1027,9 +1027,9 @@ func (f *federator) handleAdd(c context.Context) func(s *streams.Add) error {
 					continue
 				}
 				if ct, ok := target.(vocab.CollectionType); ok {
-					ct.AddItemsObject(obj)
+					ct.AppendItemsObject(obj)
 				} else if oct, ok := target.(vocab.OrderedCollectionType); ok {
-					oct.AddOrderedItemsObject(obj)
+					oct.AppendOrderedItemsObject(obj)
 				}
 				if err := f.App.Set(c, target); err != nil {
 					return err

pub/handlers_test.go

@@ -31,8 +31,8 @@ func TestServeActivityPubObject(t *testing.T) {
 					}
 					testNote = &vocab.Note{}
 					testNote.SetId(*noteIRI)
-					testNote.AddNameString(noteName)
+					testNote.AppendNameString(noteName)
-					testNote.AddContentString("This is a simple note")
+					testNote.AppendContentString("This is a simple note")
 					return testNote, nil
 				},
 				owns: func(c context.Context, id url.URL) bool {
@@ -48,8 +48,8 @@ func TestServeActivityPubObject(t *testing.T) {
 			expectedObjFn: func() vocab.Serializer {
 				testNote = &vocab.Note{}
 				testNote.SetId(*noteIRI)
-				testNote.AddNameString(noteName)
+				testNote.AppendNameString(noteName)
-				testNote.AddContentString("This is a simple note")
+				testNote.AppendContentString("This is a simple note")
 				return testNote
 			},
 			expectHandled: true,
@@ -73,8 +73,8 @@ func TestServeActivityPubObject(t *testing.T) {
 					}
 					testNote = &vocab.Note{}
 					testNote.SetId(*noteIRI)
-					testNote.AddNameString(noteName)
+					testNote.AppendNameString(noteName)
-					testNote.AddContentString("This is a simple note")
+					testNote.AppendContentString("This is a simple note")
 					return testNote, nil
 				},
 				owns: func(c context.Context, id url.URL) bool {
@@ -89,8 +89,8 @@ func TestServeActivityPubObject(t *testing.T) {
 			expectedObjFn: func() vocab.Serializer {
 				testNote = &vocab.Note{}
 				testNote.SetId(*noteIRI)
-				testNote.AddNameString(noteName)
+				testNote.AppendNameString(noteName)
-				testNote.AddContentString("This is a simple note")
+				testNote.AppendContentString("This is a simple note")
 				return testNote
 			},
 			expectHandled: true,
@@ -178,8 +178,8 @@ func TestServeActivityPubObjectWithVerificationMethod(t *testing.T) {
 					}
 					testNote = &vocab.Note{}
 					testNote.SetId(*noteIRI)
-					testNote.AddNameString(noteName)
+					testNote.AppendNameString(noteName)
-					testNote.AddContentString("This is a simple note")
+					testNote.AppendContentString("This is a simple note")
 					return testNote, nil
 				},
 				owns: func(c context.Context, id url.URL) bool {
@@ -195,8 +195,8 @@ func TestServeActivityPubObjectWithVerificationMethod(t *testing.T) {
 			expectedObjFn: func() vocab.Serializer {
 				testNote = &vocab.Note{}
 				testNote.SetId(*noteIRI)
-				testNote.AddNameString(noteName)
+				testNote.AppendNameString(noteName)
-				testNote.AddContentString("This is a simple note")
+				testNote.AppendContentString("This is a simple note")
 				return testNote
 			},
 			expectHandled: true,
@@ -220,8 +220,8 @@ func TestServeActivityPubObjectWithVerificationMethod(t *testing.T) {
 					}
 					testNote = &vocab.Note{}
 					testNote.SetId(*noteIRI)
-					testNote.AddNameString(noteName)
+					testNote.AppendNameString(noteName)
-					testNote.AddContentString("This is a simple note")
+					testNote.AppendContentString("This is a simple note")
 					return testNote, nil
 				},
 				owns: func(c context.Context, id url.URL) bool {
@@ -236,8 +236,8 @@ func TestServeActivityPubObjectWithVerificationMethod(t *testing.T) {
 			expectedObjFn: func() vocab.Serializer {
 				testNote = &vocab.Note{}
 				testNote.SetId(*noteIRI)
-				testNote.AddNameString(noteName)
+				testNote.AppendNameString(noteName)
-				testNote.AddContentString("This is a simple note")
+				testNote.AppendContentString("This is a simple note")
 				return testNote
 			},
 			expectHandled: true,
@@ -295,8 +295,8 @@ func TestServeActivityPubObjectWithVerificationMethod(t *testing.T) {
 					}
 					testNote = &vocab.Note{}
 					testNote.SetId(*noteIRI)
-					testNote.AddNameString(noteName)
+					testNote.AppendNameString(noteName)
-					testNote.AddContentString("This is a simple note")
+					testNote.AppendContentString("This is a simple note")
 					return testNote, nil
 				},
 				owns: func(c context.Context, id url.URL) bool {
@@ -318,8 +318,8 @@ func TestServeActivityPubObjectWithVerificationMethod(t *testing.T) {
 			expectedObjFn: func() vocab.Serializer {
 				testNote = &vocab.Note{}
 				testNote.SetId(*noteIRI)
-				testNote.AddNameString(noteName)
+				testNote.AppendNameString(noteName)
-				testNote.AddContentString("This is a simple note")
+				testNote.AppendContentString("This is a simple note")
 				return testNote
 			},
 			expectHandled: true,
@@ -337,8 +337,8 @@ func TestServeActivityPubObjectWithVerificationMethod(t *testing.T) {
 					}
 					testNote = &vocab.Note{}
 					testNote.SetId(*noteIRI)
-					testNote.AddNameString(noteName)
+					testNote.AppendNameString(noteName)
-					testNote.AddContentString("This is a simple note")
+					testNote.AppendContentString("This is a simple note")
 					return testNote, nil
 				},
 				owns: func(c context.Context, id url.URL) bool {
@@ -359,8 +359,8 @@ func TestServeActivityPubObjectWithVerificationMethod(t *testing.T) {
 			expectedObjFn: func() vocab.Serializer {
 				testNote = &vocab.Note{}
 				testNote.SetId(*noteIRI)
-				testNote.AddNameString(noteName)
+				testNote.AppendNameString(noteName)
-				testNote.AddContentString("This is a simple note")
+				testNote.AppendContentString("This is a simple note")
 				return testNote
 			},
 			expectHandled: true,
@@ -450,8 +450,8 @@ func TestServeActivityPubObjectWithVerificationMethod(t *testing.T) {
 					}
 					testNote = &vocab.Note{}
 					testNote.SetId(*noteIRI)
-					testNote.AddNameString(noteName)
+					testNote.AppendNameString(noteName)
-					testNote.AddContentString("This is a simple note")
+					testNote.AppendContentString("This is a simple note")
 					return testNote, nil
 				},
 				owns: func(c context.Context, id url.URL) bool {
@@ -472,8 +472,8 @@ func TestServeActivityPubObjectWithVerificationMethod(t *testing.T) {
 			expectedObjFn: func() vocab.Serializer {
 				testNote = &vocab.Note{}
 				testNote.SetId(*noteIRI)
-				testNote.AddNameString(noteName)
+				testNote.AppendNameString(noteName)
-				testNote.AddContentString("This is a simple note")
+				testNote.AppendContentString("This is a simple note")
 				return testNote
 			},
 			expectHandled: true,

pub/interfaces.go

@@ -274,7 +274,7 @@ type PubObject interface {
 	GetId() url.URL
 	SetId(url.URL)
 	HasId() bool
-	AddType(interface{})
+	AppendType(interface{})
 	RemoveType(int)
 }
 

pub/internal.go

@@ -165,54 +165,54 @@ func postToOutbox(c HttpClient, b []byte, to url.URL, agent string, creds *creds
 // properties. It will also copy over the published time if present.
 func (f *federator) wrapInCreate(o vocab.ObjectType, actor url.URL) *vocab.Create {
 	c := &vocab.Create{}
-	c.AddObject(o)
+	c.AppendObject(o)
-	c.AddActorIRI(actor)
+	c.AppendActorIRI(actor)
 	if o.IsPublished() {
 		c.SetPublished(o.GetPublished())
 	}
 	for i := 0; i < o.ToLen(); i++ {
 		if o.IsToObject(i) {
-			c.AddToObject(o.GetToObject(i))
+			c.AppendToObject(o.GetToObject(i))
 		} else if o.IsToLink(i) {
-			c.AddToLink(o.GetToLink(i))
+			c.AppendToLink(o.GetToLink(i))
 		} else if o.IsToIRI(i) {
-			c.AddToIRI(o.GetToIRI(i))
+			c.AppendToIRI(o.GetToIRI(i))
 		}
 	}
 	for i := 0; i < o.BtoLen(); i++ {
 		if o.IsBtoObject(i) {
-			c.AddBtoObject(o.GetBtoObject(i))
+			c.AppendBtoObject(o.GetBtoObject(i))
 		} else if o.IsBtoLink(i) {
-			c.AddBtoLink(o.GetBtoLink(i))
+			c.AppendBtoLink(o.GetBtoLink(i))
 		} else if o.IsBtoIRI(i) {
-			c.AddBtoIRI(o.GetBtoIRI(i))
+			c.AppendBtoIRI(o.GetBtoIRI(i))
 		}
 	}
 	for i := 0; i < o.CcLen(); i++ {
 		if o.IsCcObject(i) {
-			c.AddCcObject(o.GetCcObject(i))
+			c.AppendCcObject(o.GetCcObject(i))
 		} else if o.IsCcLink(i) {
-			c.AddCcLink(o.GetCcLink(i))
+			c.AppendCcLink(o.GetCcLink(i))
 		} else if o.IsCcIRI(i) {
-			c.AddCcIRI(o.GetCcIRI(i))
+			c.AppendCcIRI(o.GetCcIRI(i))
 		}
 	}
 	for i := 0; i < o.BccLen(); i++ {
 		if o.IsBccObject(i) {
-			c.AddBccObject(o.GetBccObject(i))
+			c.AppendBccObject(o.GetBccObject(i))
 		} else if o.IsBccLink(i) {
-			c.AddBccLink(o.GetBccLink(i))
+			c.AppendBccLink(o.GetBccLink(i))
 		} else if o.IsBccIRI(i) {
-			c.AddBccIRI(o.GetBccIRI(i))
+			c.AppendBccIRI(o.GetBccIRI(i))
 		}
 	}
 	for i := 0; i < o.AudienceLen(); i++ {
 		if o.IsAudienceObject(i) {
-			c.AddAudienceObject(o.GetAudienceObject(i))
+			c.AppendAudienceObject(o.GetAudienceObject(i))
 		} else if o.IsAudienceLink(i) {
-			c.AddAudienceLink(o.GetAudienceLink(i))
+			c.AppendAudienceLink(o.GetAudienceLink(i))
 		} else if o.IsAudienceIRI(i) {
-			c.AddAudienceIRI(o.GetAudienceIRI(i))
+			c.AppendAudienceIRI(o.GetAudienceIRI(i))
 		}
 	}
 	return c
@@ -396,11 +396,11 @@ func (f *federator) sameRecipients(a vocab.ActivityType) error {
 		for i := 0; i < a.ObjectLen(); i++ {
 			if _, ok := to[i][k]; !ok {
 				if vObj, ok := v.(vocab.ObjectType); ok {
-					a.GetObject(i).AddToObject(vObj)
+					a.GetObject(i).AppendToObject(vObj)
 				} else if vLink, ok := v.(vocab.LinkType); ok {
-					a.GetObject(i).AddToLink(vLink)
+					a.GetObject(i).AppendToLink(vLink)
 				} else if vIRI, ok := v.(url.URL); ok {
-					a.GetObject(i).AddToIRI(vIRI)
+					a.GetObject(i).AppendToIRI(vIRI)
 				}
 			}
 		}
@@ -409,11 +409,11 @@ func (f *federator) sameRecipients(a vocab.ActivityType) error {
 		for i := 0; i < a.ObjectLen(); i++ {
 			if _, ok := bto[i][k]; !ok {
 				if vObj, ok := v.(vocab.ObjectType); ok {
-					a.GetObject(i).AddBtoObject(vObj)
+					a.GetObject(i).AppendBtoObject(vObj)
 				} else if vLink, ok := v.(vocab.LinkType); ok {
-					a.GetObject(i).AddBtoLink(vLink)
+					a.GetObject(i).AppendBtoLink(vLink)
 				} else if vIRI, ok := v.(url.URL); ok {
-					a.GetObject(i).AddBtoIRI(vIRI)
+					a.GetObject(i).AppendBtoIRI(vIRI)
 				}
 			}
 		}
@@ -422,11 +422,11 @@ func (f *federator) sameRecipients(a vocab.ActivityType) error {
 		for i := 0; i < a.ObjectLen(); i++ {
 			if _, ok := cc[i][k]; !ok {
 				if vObj, ok := v.(vocab.ObjectType); ok {
-					a.GetObject(i).AddCcObject(vObj)
+					a.GetObject(i).AppendCcObject(vObj)
 				} else if vLink, ok := v.(vocab.LinkType); ok {
-					a.GetObject(i).AddCcLink(vLink)
+					a.GetObject(i).AppendCcLink(vLink)
 				} else if vIRI, ok := v.(url.URL); ok {
-					a.GetObject(i).AddCcIRI(vIRI)
+					a.GetObject(i).AppendCcIRI(vIRI)
 				}
 			}
 		}
@@ -435,11 +435,11 @@ func (f *federator) sameRecipients(a vocab.ActivityType) error {
 		for i := 0; i < a.ObjectLen(); i++ {
 			if _, ok := bcc[i][k]; !ok {
 				if vObj, ok := v.(vocab.ObjectType); ok {
-					a.GetObject(i).AddBccObject(vObj)
+					a.GetObject(i).AppendBccObject(vObj)
 				} else if vLink, ok := v.(vocab.LinkType); ok {
-					a.GetObject(i).AddBccLink(vLink)
+					a.GetObject(i).AppendBccLink(vLink)
 				} else if vIRI, ok := v.(url.URL); ok {
-					a.GetObject(i).AddBccIRI(vIRI)
+					a.GetObject(i).AppendBccIRI(vIRI)
 				}
 			}
 		}
@@ -448,11 +448,11 @@ func (f *federator) sameRecipients(a vocab.ActivityType) error {
 		for i := 0; i < a.ObjectLen(); i++ {
 			if _, ok := audience[i][k]; !ok {
 				if vObj, ok := v.(vocab.ObjectType); ok {
-					a.GetObject(i).AddAudienceObject(vObj)
+					a.GetObject(i).AppendAudienceObject(vObj)
 				} else if vLink, ok := v.(vocab.LinkType); ok {
-					a.GetObject(i).AddAudienceLink(vLink)
+					a.GetObject(i).AppendAudienceLink(vLink)
 				} else if vIRI, ok := v.(url.URL); ok {
-					a.GetObject(i).AddAudienceIRI(vIRI)
+					a.GetObject(i).AppendAudienceIRI(vIRI)
 				}
 			}
 		}
@@ -463,55 +463,55 @@ func (f *federator) sameRecipients(a vocab.ActivityType) error {
 		for k, v := range to[i] {
 			if _, ok := toActivity[k]; !ok {
 				if vObj, ok := v.(vocab.ObjectType); ok {
-					a.AddToObject(vObj)
+					a.AppendToObject(vObj)
 				} else if vLink, ok := v.(vocab.LinkType); ok {
-					a.AddToLink(vLink)
+					a.AppendToLink(vLink)
 				} else if vIRI, ok := v.(url.URL); ok {
-					a.AddToIRI(vIRI)
+					a.AppendToIRI(vIRI)
 				}
 			}
 		}
 		for k, v := range bto[i] {
 			if _, ok := btoActivity[k]; !ok {
 				if vObj, ok := v.(vocab.ObjectType); ok {
-					a.AddBtoObject(vObj)
+					a.AppendBtoObject(vObj)
 				} else if vLink, ok := v.(vocab.LinkType); ok {
-					a.AddBtoLink(vLink)
+					a.AppendBtoLink(vLink)
 				} else if vIRI, ok := v.(url.URL); ok {
-					a.AddBtoIRI(vIRI)
+					a.AppendBtoIRI(vIRI)
 				}
 			}
 		}
 		for k, v := range cc[i] {
 			if _, ok := ccActivity[k]; !ok {
 				if vObj, ok := v.(vocab.ObjectType); ok {
-					a.AddCcObject(vObj)
+					a.AppendCcObject(vObj)
 				} else if vLink, ok := v.(vocab.LinkType); ok {
-					a.AddCcLink(vLink)
+					a.AppendCcLink(vLink)
 				} else if vIRI, ok := v.(url.URL); ok {
-					a.AddCcIRI(vIRI)
+					a.AppendCcIRI(vIRI)
 				}
 			}
 		}
 		for k, v := range bcc[i] {
 			if _, ok := bccActivity[k]; !ok {
 				if vObj, ok := v.(vocab.ObjectType); ok {
-					a.AddBccObject(vObj)
+					a.AppendBccObject(vObj)
 				} else if vLink, ok := v.(vocab.LinkType); ok {
-					a.AddBccLink(vLink)
+					a.AppendBccLink(vLink)
 				} else if vIRI, ok := v.(url.URL); ok {
-					a.AddBccIRI(vIRI)
+					a.AppendBccIRI(vIRI)
 				}
 			}
 		}
 		for k, v := range audience[i] {
 			if _, ok := audienceActivity[k]; !ok {
 				if vObj, ok := v.(vocab.ObjectType); ok {
-					a.AddAudienceObject(vObj)
+					a.AppendAudienceObject(vObj)
 				} else if vLink, ok := v.(vocab.LinkType); ok {
-					a.AddAudienceLink(vLink)
+					a.AppendAudienceLink(vLink)
 				} else if vIRI, ok := v.(url.URL); ok {
-					a.AddAudienceIRI(vIRI)
+					a.AppendAudienceIRI(vIRI)
 				}
 			}
 		}
@@ -1246,9 +1246,9 @@ func toTombstone(obj vocab.ObjectType, id url.URL, now time.Time) vocab.Tombston
 	tomb.SetId(id)
 	for i := 0; i < obj.TypeLen(); i++ {
 		if s, ok := obj.GetType(i).(string); ok {
-			tomb.AddFormerTypeString(s)
+			tomb.AppendFormerTypeString(s)
 		} else if fObj, ok := obj.GetType(i).(vocab.ObjectType); ok {
-			tomb.AddFormerTypeObject(fObj)
+			tomb.AppendFormerTypeObject(fObj)
 		}
 	}
 	if obj.IsPublished() {
@@ -1323,9 +1323,9 @@ func (f *federator) addAllObjectsToActorCollection(ctx context.Context, getter g
 					continue
 				}
 				if lc != nil {
-					lc.AddItemsIRI(iri)
+					lc.AppendItemsIRI(iri)
 				} else if loc != nil {
-					loc.AddOrderedItemsIRI(iri)
+					loc.AppendOrderedItemsIRI(iri)
 				}
 			} else if c.IsObject(i) {
 				obj := c.GetObject(i)
@@ -1337,9 +1337,9 @@ func (f *federator) addAllObjectsToActorCollection(ctx context.Context, getter g
 					continue
 				}
 				if lc != nil {
-					lc.AddItemsObject(obj)
+					lc.AppendItemsObject(obj)
 				} else if loc != nil {
-					loc.AddOrderedItemsObject(obj)
+					loc.AppendOrderedItemsObject(obj)
 				}
 			}
 		}
@@ -1413,9 +1413,9 @@ func (f *federator) addAllActorsToObjectCollection(ctx context.Context, getter g
 					continue
 				}
 				if lc != nil {
-					lc.AddItemsIRI(iri)
+					lc.AppendItemsIRI(iri)
 				} else if loc != nil {
-					loc.AddOrderedItemsIRI(iri)
+					loc.AppendOrderedItemsIRI(iri)
 				}
 			} else if c.IsActorObject(i) {
 				obj := c.GetActorObject(i)
@@ -1427,9 +1427,9 @@ func (f *federator) addAllActorsToObjectCollection(ctx context.Context, getter g
 					continue
 				}
 				if lc != nil {
-					lc.AddItemsObject(obj)
+					lc.AppendItemsObject(obj)
 				} else if loc != nil {
-					loc.AddOrderedItemsObject(obj)
+					loc.AppendOrderedItemsObject(obj)
 				}
 			} else if c.IsActorLink(i) {
 				l := c.GetActorLink(i)
@@ -1441,9 +1441,9 @@ func (f *federator) addAllActorsToObjectCollection(ctx context.Context, getter g
 					continue
 				}
 				if lc != nil {
-					lc.AddItemsLink(l)
+					lc.AppendItemsLink(l)
 				} else if loc != nil {
-					loc.AddOrderedItemsLink(l)
+					loc.AppendOrderedItemsLink(l)
 				}
 			}
 		}
@@ -1488,7 +1488,7 @@ func (f *federator) addToOutbox(c context.Context, r *http.Request, m map[string
 	if err != nil {
 		return err
 	}
-	outbox.AddOrderedItemsObject(activity)
+	outbox.AppendOrderedItemsObject(activity)
 	return f.App.Set(c, outbox)
 }
 
@@ -1506,7 +1506,7 @@ func (f *federator) addToInbox(c context.Context, r *http.Request, m map[string]
 		return err
 	}
 	if !iriSet[activity.GetId()] {
-		inbox.AddOrderedItemsObject(activity)
+		inbox.AppendOrderedItemsObject(activity)
 		return f.App.Set(c, inbox)
 	}
 	return nil

streams/streams_test.go

@@ -246,14 +246,14 @@ func TestNulls(t *testing.T) {
 	expectedSamActor.SetId(*samIRI)
 	expectedNote := &vocab.Note{}
 	expectedNote.SetId(*noteIRI)
-	expectedNote.AddNameString("A Note")
+	expectedNote.AppendNameString("A Note")
-	expectedNote.AddContentString("This is a simple note")
+	expectedNote.AppendContentString("This is a simple note")
-	expectedNote.AddToObject(expectedSamActor)
+	expectedNote.AppendToObject(expectedSamActor)
 	expectedUpdate := &vocab.Update{}
-	expectedUpdate.AddActorIRI(*sallyIRI)
+	expectedUpdate.AppendActorIRI(*sallyIRI)
-	expectedUpdate.AddSummaryString("Sally updated her note")
+	expectedUpdate.AppendSummaryString("Sally updated her note")
 	expectedUpdate.SetId(*activityIRI)
-	expectedUpdate.AddObject(expectedNote)
+	expectedUpdate.AppendObject(expectedNote)
 	tables := []struct {
 		name     string
 		expected vocab.Serializer

tools/streams/gen/as.go

@@ -758,16 +758,31 @@ func generateNonFunctionalIRI(p *defs.PropertyType, this *defs.StructDef) {
 			},
 		},
 		{
-			Name:    fmt.Sprintf("Add%s", titleName),
+			Name:    fmt.Sprintf("Append%s", titleName),
-			Comment: fmt.Sprintf("Add%s appends the value for property '%s'.", titleName, p.Name),
+			Comment: fmt.Sprintf("Append%s appends the value for property '%s'.", titleName, p.Name),
 			P:       this,
 			Args:    []*defs.FunctionVarDef{{"k", kind}},
 			Body: func() string {
 				var b bytes.Buffer
 				if onlyType {
-					b.WriteString(fmt.Sprintf("t.%s.Add%s%s(k)\n", rawMemberName, titleName, iri))
+					b.WriteString(fmt.Sprintf("t.%s.Append%s%s(k)\n", rawMemberName, titleName, iri))
 				} else {
-					b.WriteString(fmt.Sprintf("t.%s.Add%s%s(k)\n", rawMemberName, titleName, iri))
+					b.WriteString(fmt.Sprintf("t.%s.Append%s%s(k)\n", rawMemberName, titleName, iri))
+				}
+				return b.String()
+			},
+		},
+		{
+			Name:    fmt.Sprintf("Prepend%s", titleName),
+			Comment: fmt.Sprintf("Prepend%s prepends the value for property '%s'.", titleName, p.Name),
+			P:       this,
+			Args:    []*defs.FunctionVarDef{{"k", kind}},
+			Body: func() string {
+				var b bytes.Buffer
+				if onlyType {
+					b.WriteString(fmt.Sprintf("t.%s.Prepend%s%s(k)\n", rawMemberName, titleName, iri))
+				} else {
+					b.WriteString(fmt.Sprintf("t.%s.Prepend%s%s(k)\n", rawMemberName, titleName, iri))
 				}
 				return b.String()
 			},
@@ -904,24 +919,46 @@ func generateNonFunctionalObjectLink(p *defs.PropertyType, this *defs.StructDef,
 			},
 		},
 		{
-			Name:    fmt.Sprintf("Add%s", titleName),
+			Name:    fmt.Sprintf("Append%s", titleName),
-			Comment: fmt.Sprintf("Add%s adds an 'Object' typed value.", titleName),
+			Comment: fmt.Sprintf("Append%s appends an 'Object' typed value.", titleName),
 			P:       this,
 			Args:    []*defs.FunctionVarDef{{"i", "vocab.ObjectType"}},
 			Body: func() string {
 				var b bytes.Buffer
-				b.WriteString(fmt.Sprintf("t.%s.Add%sObject(i)\n", rawMemberName, titleName))
+				b.WriteString(fmt.Sprintf("t.%s.Append%sObject(i)\n", rawMemberName, titleName))
 				return b.String()
 			},
 		},
 		{
-			Name:    fmt.Sprintf("Set%sLink", titleName),
+			Name:    fmt.Sprintf("Prepend%s", titleName),
-			Comment: fmt.Sprintf("Set%sLink adds a 'Link' typed value.", titleName),
+			Comment: fmt.Sprintf("Prepend%s prepends an 'Object' typed value.", titleName),
+			P:       this,
+			Args:    []*defs.FunctionVarDef{{"i", "vocab.ObjectType"}},
+			Body: func() string {
+				var b bytes.Buffer
+				b.WriteString(fmt.Sprintf("t.%s.Prepend%sObject(i)\n", rawMemberName, titleName))
+				return b.String()
+			},
+		},
+		{
+			Name:    fmt.Sprintf("Append%sLink", titleName),
+			Comment: fmt.Sprintf("Append%sLink appends a 'Link' typed value.", titleName),
 			P:       this,
 			Args:    []*defs.FunctionVarDef{{"i", "vocab.LinkType"}},
 			Body: func() string {
 				var b bytes.Buffer
-				b.WriteString(fmt.Sprintf("t.%s.Add%sLink(i)\n", rawMemberName, titleName))
+				b.WriteString(fmt.Sprintf("t.%s.Append%sLink(i)\n", rawMemberName, titleName))
+				return b.String()
+			},
+		},
+		{
+			Name:    fmt.Sprintf("Prepend%sLink", titleName),
+			Comment: fmt.Sprintf("Prepend%sLink prepends a 'Link' typed value.", titleName),
+			P:       this,
+			Args:    []*defs.FunctionVarDef{{"i", "vocab.LinkType"}},
+			Body: func() string {
+				var b bytes.Buffer
+				b.WriteString(fmt.Sprintf("t.%s.Prepend%sLink(i)\n", rawMemberName, titleName))
 				return b.String()
 			},
 		},
@@ -980,16 +1017,31 @@ func generateNonFunctionalPropertyType(p *defs.PropertyType, this *defs.StructDe
 			},
 		},
 		{
-			Name:    fmt.Sprintf("Add%s", titleName),
+			Name:    fmt.Sprintf("Append%s", titleName),
-			Comment: fmt.Sprintf("Add%s appends the value for property '%s'.", titleName, p.Name),
+			Comment: fmt.Sprintf("Append%s appends the value for property '%s'.", titleName, p.Name),
 			P:       this,
 			Args:    []*defs.FunctionVarDef{{"i", "vocab." + gen.InterfaceName(ref)}},
 			Body: func() string {
 				var b bytes.Buffer
 				if onlyType {
-					b.WriteString(fmt.Sprintf("t.%s.Add%s(i)\n", rawMemberName, titleName))
+					b.WriteString(fmt.Sprintf("t.%s.Append%s(i)\n", rawMemberName, titleName))
 				} else {
-					b.WriteString(fmt.Sprintf("t.%s.Add%s%s(i)\n", rawMemberName, titleName, additionalTitleName))
+					b.WriteString(fmt.Sprintf("t.%s.Append%s%s(i)\n", rawMemberName, titleName, additionalTitleName))
+				}
+				return b.String()
+			},
+		},
+		{
+			Name:    fmt.Sprintf("Prepend%s", titleName),
+			Comment: fmt.Sprintf("Prepend%s prepends the value for property '%s'.", titleName, p.Name),
+			P:       this,
+			Args:    []*defs.FunctionVarDef{{"i", "vocab." + gen.InterfaceName(ref)}},
+			Body: func() string {
+				var b bytes.Buffer
+				if onlyType {
+					b.WriteString(fmt.Sprintf("t.%s.Prepend%s(i)\n", rawMemberName, titleName))
+				} else {
+					b.WriteString(fmt.Sprintf("t.%s.Prepend%s%s(i)\n", rawMemberName, titleName, additionalTitleName))
 				}
 				return b.String()
 			},
@@ -1093,16 +1145,31 @@ func generateNonFunctionalPropertyValue(p *defs.PropertyType, this *defs.StructD
 			},
 		},
 		{
-			Name:    fmt.Sprintf("Add%s", titleName),
+			Name:    fmt.Sprintf("Append%s", titleName),
-			Comment: fmt.Sprintf("Add%s appends the value for property '%s'.", titleName, p.Name),
+			Comment: fmt.Sprintf("Append%s appends the value for property '%s'.", titleName, p.Name),
 			P:       this,
 			Args:    []*defs.FunctionVarDef{{"k", kind}},
 			Body: func() string {
 				var b bytes.Buffer
 				if onlyType {
-					b.WriteString(fmt.Sprintf("t.%s.Add%s(k)\n", rawMemberName, titleName))
+					b.WriteString(fmt.Sprintf("t.%s.Append%s(k)\n", rawMemberName, titleName))
 				} else {
-					b.WriteString(fmt.Sprintf("t.%s.Add%s%s(k)\n", rawMemberName, titleName, additionalTitleName))
+					b.WriteString(fmt.Sprintf("t.%s.Append%s%s(k)\n", rawMemberName, titleName, additionalTitleName))
+				}
+				return b.String()
+			},
+		},
+		{
+			Name:    fmt.Sprintf("Prepend%s", titleName),
+			Comment: fmt.Sprintf("Prepend%s prepends the value for property '%s'.", titleName, p.Name),
+			P:       this,
+			Args:    []*defs.FunctionVarDef{{"k", kind}},
+			Body: func() string {
+				var b bytes.Buffer
+				if onlyType {
+					b.WriteString(fmt.Sprintf("t.%s.Prepend%s(k)\n", rawMemberName, titleName))
+				} else {
+					b.WriteString(fmt.Sprintf("t.%s.Prepend%s%s(k)\n", rawMemberName, titleName, additionalTitleName))
 				}
 				return b.String()
 			},
@@ -1189,13 +1256,24 @@ func generateNonFunctionalPropertyAny(p *defs.PropertyType, this *defs.StructDef
 			},
 		},
 		{
-			Name:    fmt.Sprintf("Add%s", titleName),
+			Name:    fmt.Sprintf("Append%s", titleName),
-			Comment: fmt.Sprintf("Add%s appends the value for property '%s'.", titleName, p.Name),
+			Comment: fmt.Sprintf("Append%s appends the value for property '%s'.", titleName, p.Name),
 			P:       this,
 			Args:    []*defs.FunctionVarDef{{"i", "interface{}"}},
 			Body: func() string {
 				var b bytes.Buffer
-				b.WriteString(fmt.Sprintf("t.%s.Add%s(i)\n", rawMemberName, titleName))
+				b.WriteString(fmt.Sprintf("t.%s.Append%s(i)\n", rawMemberName, titleName))
+				return b.String()
+			},
+		},
+		{
+			Name:    fmt.Sprintf("Prepend%s", titleName),
+			Comment: fmt.Sprintf("Prepend%s prepends the value for property '%s'.", titleName, p.Name),
+			P:       this,
+			Args:    []*defs.FunctionVarDef{{"i", "interface{}"}},
+			Body: func() string {
+				var b bytes.Buffer
+				b.WriteString(fmt.Sprintf("t.%s.Prepend%s(i)\n", rawMemberName, titleName))
 				return b.String()
 			},
 		},

tools/vocab/gen/generate_property_definitions.go

@@ -224,8 +224,8 @@ func generateNonFunctionalAnyDefinition(t *defs.PropertyType, this *defs.StructD
 			return b.String()
 		},
 	}, &defs.MemberFunctionDef{
-		Name:    fmt.Sprintf("Add%s", titleName),
+		Name:    fmt.Sprintf("Append%s", titleName),
-		Comment: fmt.Sprintf("Add%s adds another value of %s", titleName, t.Name),
+		Comment: fmt.Sprintf("Append%s adds a value to the back of %s", titleName, t.Name),
 		P:       this,
 		Args:    []*defs.FunctionVarDef{{"v", deSlice(anyMember.Type)}},
 		Body: func() string {
@@ -233,6 +233,16 @@ func generateNonFunctionalAnyDefinition(t *defs.PropertyType, this *defs.StructD
 			b.WriteString(fmt.Sprintf("t.%s = append(t.%s, v)\n", anyMember.Name, anyMember.Name))
 			return b.String()
 		},
+	}, &defs.MemberFunctionDef{
+		Name:    fmt.Sprintf("Prepend%s", titleName),
+		Comment: fmt.Sprintf("Prepend%s adds a value to the front of %s", titleName, t.Name),
+		P:       this,
+		Args:    []*defs.FunctionVarDef{{"v", deSlice(anyMember.Type)}},
+		Body: func() string {
+			var b bytes.Buffer
+			b.WriteString(fmt.Sprintf("t.%s = append(%s{v}, t.%s...)\n", anyMember.Name, anyMember.Type, anyMember.Name))
+			return b.String()
+		},
 	}, &defs.MemberFunctionDef{
 		Name:    fmt.Sprintf("Remove%s", titleName),
 		Comment: fmt.Sprintf("Remove%s deletes the value from the specified index", titleName),
@@ -260,8 +270,13 @@ func generateNonFunctionalAnyDefinition(t *defs.PropertyType, this *defs.StructD
 			Return:  []*defs.FunctionVarDef{{"v", deSlice(anyMember.Type)}},
 		},
 		{
-			Name:    fmt.Sprintf("Add%s", titleName),
+			Name:    fmt.Sprintf("Append%s", titleName),
-			Comment: fmt.Sprintf("Add%s adds another value of %s", titleName, t.Name),
+			Comment: fmt.Sprintf("Append%s adds a value to the back of %s", titleName, t.Name),
+			Args:    []*defs.FunctionVarDef{{"v", deSlice(anyMember.Type)}},
+		},
+		{
+			Name:    fmt.Sprintf("Prepend%s", titleName),
+			Comment: fmt.Sprintf("Prepend%s adds a value to the front of %s", titleName, t.Name),
 			Args:    []*defs.FunctionVarDef{{"v", deSlice(anyMember.Type)}},
 		},
 		{
@@ -449,8 +464,8 @@ func generateNonFunctionalSingleTypeDefinition(t *defs.PropertyType, this *defs.
 			return b.String()
 		},
 	}, &defs.MemberFunctionDef{
-		Name:    fmt.Sprintf("Add%s", titleName),
+		Name:    fmt.Sprintf("Append%s", titleName),
-		Comment: fmt.Sprintf("Add%s adds another value of %s", titleName, t.Name),
+		Comment: fmt.Sprintf("Append%s adds a value to the back of %s", titleName, t.Name),
 		P:       this,
 		Args:    []*defs.FunctionVarDef{{"v", deSlice(member.Type)}},
 		Body: func() string {
@@ -458,6 +473,16 @@ func generateNonFunctionalSingleTypeDefinition(t *defs.PropertyType, this *defs.
 			b.WriteString(fmt.Sprintf("t.%s = append(t.%s, v)\n", member.Name, member.Name))
 			return b.String()
 		},
+	}, &defs.MemberFunctionDef{
+		Name:    fmt.Sprintf("Prepend%s", titleName),
+		Comment: fmt.Sprintf("Prepend%s adds a value to the front of %s", titleName, t.Name),
+		P:       this,
+		Args:    []*defs.FunctionVarDef{{"v", deSlice(member.Type)}},
+		Body: func() string {
+			var b bytes.Buffer
+			b.WriteString(fmt.Sprintf("t.%s = append(%s{v}, t.%s...)\n", member.Name, member.Type, member.Name))
+			return b.String()
+		},
 	}, &defs.MemberFunctionDef{
 		Name:    fmt.Sprintf("Remove%s", titleName),
 		Comment: fmt.Sprintf("Remove%s deletes the value from the specified index", titleName),
@@ -518,8 +543,13 @@ func generateNonFunctionalSingleTypeDefinition(t *defs.PropertyType, this *defs.
 			Return:  []*defs.FunctionVarDef{{"v", deSlice(member.Type)}},
 		},
 		{
-			Name:    fmt.Sprintf("Add%s", titleName),
+			Name:    fmt.Sprintf("Append%s", titleName),
-			Comment: fmt.Sprintf("Add%s adds another value of %s", titleName, t.Name),
+			Comment: fmt.Sprintf("Append%s adds a value to the back of %s", titleName, t.Name),
+			Args:    []*defs.FunctionVarDef{{"v", deSlice(member.Type)}},
+		},
+		{
+			Name:    fmt.Sprintf("Prepend%s", titleName),
+			Comment: fmt.Sprintf("Prepend%s adds a value to the front of %s", titleName, t.Name),
 			Args:    []*defs.FunctionVarDef{{"v", deSlice(member.Type)}},
 		},
 		{
@@ -731,8 +761,8 @@ func generateNonFunctionalMultiTypeDefinition(t *defs.PropertyType, this *defs.S
 				},
 			},
 			{
-				Name:    fmt.Sprintf("Add%s%s", titleName, typeExtensionName),
+				Name:    fmt.Sprintf("Append%s%s", titleName, typeExtensionName),
-				Comment: fmt.Sprintf("Add%s%s adds another value of %s to be of %s type", titleName, typeExtensionName, cleanName(t.Name), retKind),
+				Comment: fmt.Sprintf("Append%s%s adds to the back of %s a %s type", titleName, typeExtensionName, cleanName(t.Name), retKind),
 				P:       this,
 				Args:    []*defs.FunctionVarDef{{"v", retKind}},
 				Body: func() string {
@@ -745,6 +775,21 @@ func generateNonFunctionalMultiTypeDefinition(t *defs.PropertyType, this *defs.S
 					return b.String()
 				},
 			},
+			{
+				Name:    fmt.Sprintf("Prepend%s%s", titleName, typeExtensionName),
+				Comment: fmt.Sprintf("Prepend%s%s adds to the front of %s a %s type", titleName, typeExtensionName, cleanName(t.Name), retKind),
+				P:       this,
+				Args:    []*defs.FunctionVarDef{{"v", retKind}},
+				Body: func() string {
+					var b bytes.Buffer
+					b.WriteString(fmt.Sprintf("t.%s = append([]*%s{&%s{%s:", thisIntermed.Name, intermed.Typename, intermed.Typename, member.Name))
+					if isPtrType(Type(r)) {
+						b.WriteString("&")
+					}
+					b.WriteString(fmt.Sprintf("v}}, t.%s...)\n", thisIntermed.Name))
+					return b.String()
+				},
+			},
 			{
 				Name:    fmt.Sprintf("Remove%s%s", titleName, typeExtensionName),
 				Comment: fmt.Sprintf("Remove%s%s deletes the value from the specified index", titleName, typeExtensionName),
@@ -774,8 +819,13 @@ func generateNonFunctionalMultiTypeDefinition(t *defs.PropertyType, this *defs.S
 				Return:  []*defs.FunctionVarDef{{"v", retKind}},
 			},
 			{
-				Name:    fmt.Sprintf("Add%s%s", titleName, typeExtensionName),
+				Name:    fmt.Sprintf("Append%s%s", titleName, typeExtensionName),
-				Comment: fmt.Sprintf("Add%s%s adds another value of %s to be of %s type", titleName, typeExtensionName, cleanName(t.Name), retKind),
+				Comment: fmt.Sprintf("Append%s%s adds to the back of %s a %s type", titleName, typeExtensionName, cleanName(t.Name), retKind),
+				Args:    []*defs.FunctionVarDef{{"v", retKind}},
+			},
+			{
+				Name:    fmt.Sprintf("Prepend%s%s", titleName, typeExtensionName),
+				Comment: fmt.Sprintf("Prepend%s%s adds to the front of %s a %s type", titleName, typeExtensionName, cleanName(t.Name), retKind),
 				Args:    []*defs.FunctionVarDef{{"v", retKind}},
 			},
 			{

vocab/vocab_test.go

@@ -1041,16 +1041,16 @@ func TestSerialization(t *testing.T) {
 func TestSerializationWithoutTypeSet(t *testing.T) {
 	obj := &Object{}
 	obj.SetId(MustParseURL("http://www.test.example/object/1"))
-	obj.AddNameString("A Simple, non-specific object")
+	obj.AppendNameString("A Simple, non-specific object")
 
 	person := &Person{}
-	person.AddNameString("Sally")
+	person.AppendNameString("Sally")
 	place := &Place{}
-	place.AddNameString("Work")
+	place.AppendNameString("Work")
 	obj4 := &Travel{}
-	obj4.AddSummaryString("Sally went to work")
+	obj4.AppendSummaryString("Sally went to work")
-	obj4.AddActorObject(person)
+	obj4.AppendActorObject(person)
-	obj4.AddTargetObject(place)
+	obj4.AppendTargetObject(place)
 
 	tables := []struct {
 		name         string
@@ -1121,14 +1121,14 @@ func TestReserializationAbility(t *testing.T) {
 	expectedSamActor.SetId(*samIRI)
 	expectedNote := &Note{}
 	expectedNote.SetId(*noteIRI)
-	expectedNote.AddNameString("A Note")
+	expectedNote.AppendNameString("A Note")
-	expectedNote.AddContentString("This is a simple note")
+	expectedNote.AppendContentString("This is a simple note")
-	expectedNote.AddToObject(expectedSamActor)
+	expectedNote.AppendToObject(expectedSamActor)
 	expectedUpdate := &Update{}
-	expectedUpdate.AddActorIRI(*sallyIRI)
+	expectedUpdate.AppendActorIRI(*sallyIRI)
-	expectedUpdate.AddSummaryString("Sally updated her note")
+	expectedUpdate.AppendSummaryString("Sally updated her note")
 	expectedUpdate.SetId(*activityIRI)
-	expectedUpdate.AddObject(expectedNote)
+	expectedUpdate.AppendObject(expectedNote)
 	tables := []struct {
 		name         string
 		expected     Serializer