From 57db4178d04eeac3150774866ca06f5ec0f89f59 Mon Sep 17 00:00:00 2001
From: Jason Streifling <jason@streifling.com>
Date: Sat, 19 Oct 2024 14:12:51 +0200
Subject: [PATCH] Get rid of checks when creating constructs. Check should
 handle this.

---
 atom.go               | 33 +++++++++++++++++++
 category.go           | 43 ++++--------------------
 commonAttributes.go   | 26 +++++++++------
 content.go            | 12 +++----
 entry.go              | 67 +++++++++----------------------------
 extensionElement.go   | 19 ++++-------
 feed.go               | 77 ++++++++++---------------------------------
 generator.go          | 20 ++---------
 icon.go               | 10 ++----
 id.go                 | 10 ++----
 inlineOtherContent.go |  8 ++---
 inlineTextContent.go  | 15 ++-------
 inlineXHTMLContent.go | 15 ++-------
 link.go               | 28 ++--------------
 logo.go               | 10 ++----
 outOfLineContent.go   | 19 ++---------
 person.go             | 30 +++--------------
 plainText.go          | 11 ++-----
 text.go               | 11 +++----
 xhtmlDiv.go           | 11 ++-----
 xhtmlText.go          | 13 +++-----
 21 files changed, 143 insertions(+), 345 deletions(-)

diff --git a/atom.go b/atom.go
index a6a9fe1..b2dab84 100644
--- a/atom.go
+++ b/atom.go
@@ -2,6 +2,7 @@ package atom
 
 import (
 	"fmt"
+	"html"
 	"mime"
 	"regexp"
 	"strings"
@@ -10,6 +11,10 @@ import (
 	"golang.org/x/text/language"
 )
 
+func Unescape(s string) string {
+	return html.UnescapeString(s)
+}
+
 // isValidIRI checks whether an IRI is valid or not. It returns a bool.
 // https://www.w3.org/2011/04/XMLSchema/TypeLibrary-IRI-RFC3987.xsd
 func isValidIRI(iri string) bool {
@@ -17,6 +22,15 @@ func isValidIRI(iri string) bool {
 	return regexp.MustCompile(pattern).MatchString(iri)
 }
 
+// NewIRI creates a new IRI. It returns a string and an error.
+func NewIRI(iri string) (string, error) {
+	if !isValidIRI(iri) {
+		return "", fmt.Errorf("iri %v not correctly formatted", iri)
+	}
+
+	return iri, nil
+}
+
 // isCorrectlyEscaped checks whether a string is correctly escaped as per
 // RFC4287. It returns a bool.
 func isCorrectlyEscaped(text string) bool {
@@ -69,12 +83,31 @@ func isValidMediaType(m string) bool {
 	return true
 }
 
+// NewMediaType creates a new MediaType. It returns a string and an error.
+func NewMediaType(m string) (string, error) {
+	if !isValidMediaType(m) {
+		return "", fmt.Errorf("media type %v invalid", m)
+	}
+
+	mediaType, _, _ := mime.ParseMediaType(m)
+	return mediaType, nil
+}
+
 // isValidLanguageTag checks whether a LanguageTag is valid. It returns a bool.
 func isValidLanguageTag(languageTag string) bool {
 	_, err := language.Parse(languageTag)
 	return err == nil
 }
 
+// NewLanguageTag creates a new LanguageTag. It returns a string and an error.
+func NewLanguageTag(l string) (string, error) {
+	if !isValidLanguageTag(l) {
+		return "", fmt.Errorf("language tag %v invalid", l)
+	}
+
+	return l, nil
+}
+
 // isValidAttribute checks whether an Attribute is valid. It returns a bool.
 func isValidAttribute(attribute string) bool {
 	regex := regexp.MustCompile(`^[a-zA-Z0-9_]+="[^"]*"$`)
diff --git a/category.go b/category.go
index c4a1909..fb0006a 100644
--- a/category.go
+++ b/category.go
@@ -2,9 +2,7 @@ package atom
 
 import (
 	"encoding/xml"
-	"errors"
 	"fmt"
-	"html"
 )
 
 type Category struct {
@@ -15,43 +13,14 @@ type Category struct {
 	Label  string `xml:"label,attr,omitempty"`
 }
 
-// NewCategory creates a new Category. It returns a *Category and an error.
-func NewCategory(term string) (*Category, error) {
-	if term == "" {
-		return nil, errors.New("error creating new category: term string empty")
-	}
-
-	return &Category{Term: term}, nil
+// NewCategory creates a new Category. It returns a *Category.
+func NewCategory(term string) *Category {
+	return &Category{Term: term}
 }
 
-// SetTerm sets the Term attribute of the Category. It returns an error.
-func (c *Category) SetTerm(t string) error {
-	if t == "" {
-		return errors.New("error setting term of category: t string empty")
-	}
-
-	c.Term = t
-	return nil
-}
-
-// SetScheme sets the Scheme attribute of the Category. It returns an error.
-func (c *Category) SetScheme(s string) error {
-	if !isValidIRI(s) {
-		return fmt.Errorf("scheme %v not correctly formatted", s)
-	}
-
-	c.Scheme = s
-	return nil
-}
-
-// SetLabel sets the Label attribute of the Category. It returns an error.
-func (c *Category) SetLabel(label string) error {
-	if label == "" {
-		return errors.New("error setting label of category: label string empty")
-	}
-
-	c.Label = html.UnescapeString(label)
-	return nil
+// SetLabel sets the Label attribute of the Category.
+func (c *Category) SetLabel(label string) {
+	c.Label = Unescape(label)
 }
 
 // Check checks the Category for incompatibilities with RFC4287. It returns an
diff --git a/commonAttributes.go b/commonAttributes.go
index 093d834..613983a 100644
--- a/commonAttributes.go
+++ b/commonAttributes.go
@@ -2,7 +2,7 @@ package atom
 
 import (
 	"encoding/xml"
-	"errors"
+	"fmt"
 )
 
 type CommonAttributes struct {
@@ -17,21 +17,27 @@ func NewCommonAttributes() *CommonAttributes {
 	return new(CommonAttributes)
 }
 
-// AddAttribute adds the Attribute to the CommonAttributes. It returns an error.
-func (c *CommonAttributes) AddAttribute(name, value string) error {
-	if name == "" {
-		return errors.New("error adding attribute: name string empty")
-	}
-	if value == "" {
-		return errors.New("error adding attribute: value string empty")
-	}
-
+// AddAttribute adds the Attribute to the CommonAttributes.
+func (c *CommonAttributes) AddAttribute(name, value string) {
 	if c.UndefinedAttributes == nil {
 		c.UndefinedAttributes = make([]*xml.Attr, 1)
 		c.UndefinedAttributes[0] = &xml.Attr{Name: xml.Name{Local: name}, Value: value}
 	} else {
 		c.UndefinedAttributes = append(c.UndefinedAttributes, &xml.Attr{Name: xml.Name{Local: name}, Value: value})
 	}
+}
+
+// Check checks the CommonAttributes for incompatibilities with RFC4287. It
+// returns an error.
+func (c *CommonAttributes) Check() error {
+	for i, u := range c.UndefinedAttributes {
+		if u.Name.Local == "" {
+			return fmt.Errorf("xml name of undefined attribute %v empty", i)
+		}
+		if u.Value == "" {
+			return fmt.Errorf("value of undefined attribute %v empty", i)
+		}
+	}
 
 	return nil
 }
diff --git a/content.go b/content.go
index ae934f7..ba316db 100644
--- a/content.go
+++ b/content.go
@@ -1,7 +1,5 @@
 package atom
 
-import "fmt"
-
 const (
 	InlineText = iota
 	InlineXHTML
@@ -17,17 +15,17 @@ type Content interface {
 }
 
 // NewContent creates a new Content. It returns a Content and an error.
-func NewContent(contentType int, mediaType string, content any) (Content, error) {
+func NewContent(contentType int, mediaType string, content any) Content {
 	switch contentType {
 	case 0:
-		return newInlineTextContent(mediaType, content)
+		return newInlineTextContent(mediaType, content.(string))
 	case 1:
-		return newInlineXHTMLContent(mediaType, content)
+		return newInlineXHTMLContent(mediaType, content.(*XHTMLDiv))
 	case 2:
 		return newInlineOtherContent(mediaType, content)
 	case 3:
-		return newOutOfLineContent(mediaType, content)
+		return newOutOfLineContent(mediaType, content.(string))
 	default:
-		return nil, fmt.Errorf("error creating new content: %v is not a valid text type", contentType)
+		return nil
 	}
 }
diff --git a/entry.go b/entry.go
index 510e68d..db7b4a4 100644
--- a/entry.go
+++ b/entry.go
@@ -2,7 +2,6 @@ package atom
 
 import (
 	"encoding/xml"
-	"errors"
 	"fmt"
 	"strings"
 	"time"
@@ -57,31 +56,17 @@ func (e *Entry) checkAuthors(authorInFeed bool) error {
 	return nil
 }
 
-// NewEntry creates a new Entry. It returns a *Entry and an error.
-func NewEntry(title string) (*Entry, error) {
-	text, err := NewText("text", title)
-	if err != nil {
-		return nil, fmt.Errorf("error creating new entry: %v", err)
-	}
-
-	id, err := NewID(NewURN())
-	if err != nil {
-		return nil, fmt.Errorf("error creating new entry: %v", err)
-	}
-
+// NewEntry creates a new Entry. It returns a *Entry.
+func NewEntry(title string) *Entry {
 	return &Entry{
-		ID:      id,
-		Title:   text,
+		ID:      NewID(NewURN()),
+		Title:   NewText("text", title),
 		Updated: NewDate(time.Now()),
-	}, nil
+	}
 }
 
-// AddAuthor adds the Person as an author to the Entry. It returns an error.
-func (e *Entry) AddAuthor(p *Person) error {
-	if p == nil {
-		return errors.New("error adding author element to entry: *Person is nil")
-	}
-
+// AddAuthor adds the Person as an author to the Entry.
+func (e *Entry) AddAuthor(p *Person) {
 	if e.Authors == nil {
 		e.Authors = make([]*Person, 1)
 		e.Authors[0] = p
@@ -90,15 +75,10 @@ func (e *Entry) AddAuthor(p *Person) error {
 	}
 
 	e.Updated.DateTime = DateTime(time.Now())
-	return nil
 }
 
-// AddCategory adds the Category to the Entry. It returns an error.
-func (e *Entry) AddCategory(c *Category) error {
-	if c == nil {
-		return errors.New("error adding category element to entry: *Category is nil")
-	}
-
+// AddCategory adds the Category to the Entry.
+func (e *Entry) AddCategory(c *Category) {
 	if e.Categories == nil {
 		e.Categories = make([]*Category, 1)
 		e.Categories[0] = c
@@ -107,16 +87,10 @@ func (e *Entry) AddCategory(c *Category) error {
 	}
 
 	e.Updated.DateTime = DateTime(time.Now())
-	return nil
 }
 
-// AddContributor adds the Person as a contributor to the Entry. It returns an
-// error.
-func (e *Entry) AddContributor(c *Person) error {
-	if c == nil {
-		return errors.New("error adding contributor element to entry: *Person is nil")
-	}
-
+// AddContributor adds the Person as a contributor to the Entry.
+func (e *Entry) AddContributor(c *Person) {
 	if e.Contributors == nil {
 		e.Contributors = make([]*Person, 1)
 		e.Contributors[0] = c
@@ -125,15 +99,10 @@ func (e *Entry) AddContributor(c *Person) error {
 	}
 
 	e.Updated.DateTime = DateTime(time.Now())
-	return nil
 }
 
-// AddLink adds the Link to the Entry. It returns an error.
-func (e *Entry) AddLink(l *Link) error {
-	if l == nil {
-		return errors.New("error adding link element to entry: *Link is nil")
-	}
-
+// AddLink adds the Link to the Entry.
+func (e *Entry) AddLink(l *Link) {
 	if e.Links == nil {
 		e.Links = make([]*Link, 1)
 		e.Links[0] = l
@@ -142,15 +111,10 @@ func (e *Entry) AddLink(l *Link) error {
 	}
 
 	e.Updated.DateTime = DateTime(time.Now())
-	return nil
 }
 
-// AddExtension adds the ExtensionElement to the Entry. It returns an error.
-func (e *Entry) AddExtension(x *ExtensionElement) error {
-	if x == nil {
-		return errors.New("error adding extension element to entry: *ExtensionElement is nil")
-	}
-
+// AddExtension adds the ExtensionElement to the Entry.
+func (e *Entry) AddExtension(x *ExtensionElement) {
 	if e.Extensions == nil {
 		e.Extensions = make([]*ExtensionElement, 1)
 		e.Extensions[0] = x
@@ -159,7 +123,6 @@ func (e *Entry) AddExtension(x *ExtensionElement) error {
 	}
 
 	e.Updated.DateTime = DateTime(time.Now())
-	return nil
 }
 
 // Check checks the Entry for incompatibilities with RFC4287. It returns an
diff --git a/extensionElement.go b/extensionElement.go
index dd8dcc7..c42cd14 100644
--- a/extensionElement.go
+++ b/extensionElement.go
@@ -2,7 +2,7 @@ package atom
 
 import (
 	"encoding/xml"
-	"errors"
+	"fmt"
 )
 
 type ExtensionElement struct {
@@ -11,27 +11,20 @@ type ExtensionElement struct {
 }
 
 // NewExtensionElement creates a new ExtensionElement. It returns a
-// *ExtensionElement and an error.
-func NewExtensionElement(name string, value any) (*ExtensionElement, error) {
-	if name == "" {
-		return nil, errors.New("error adding extension attribute: name string empty")
-	}
-	if value == "" {
-		return nil, errors.New("error adding extension attribute: value string empty")
-	}
-
-	return &ExtensionElement{XMLName: xml.Name{Local: name}, Value: value}, nil
+// *ExtensionElement.
+func NewExtensionElement(name string, value any) *ExtensionElement {
+	return &ExtensionElement{XMLName: xml.Name{Local: name}, Value: value}
 }
 
 // Check checks the ExtensionElement for incompatibilities with RFC4287. It
 // returns an error.
 func (e *ExtensionElement) Check() error {
 	if e.XMLName.Local == "" {
-		return errors.New("xml name of extension empty")
+		return fmt.Errorf("xml name of extension %v empty", e)
 	}
 
 	if e.Value == nil {
-		return errors.New("value element of extension empty")
+		return fmt.Errorf("value of extension %v empty", e)
 	}
 
 	return nil
diff --git a/feed.go b/feed.go
index 795d5a5..7b66005 100644
--- a/feed.go
+++ b/feed.go
@@ -2,7 +2,6 @@ package atom
 
 import (
 	"encoding/xml"
-	"errors"
 	"fmt"
 	"time"
 )
@@ -26,31 +25,17 @@ type Feed struct {
 	Entries      []*Entry            `xml:",omitempty"`
 }
 
-// NewFeed creates a new Feed. It returns a *Feed and an error.
-func NewFeed(title string) (*Feed, error) {
-	text, err := NewText("text", title)
-	if err != nil {
-		return nil, fmt.Errorf("error creating new feed: %v", err)
-	}
-
-	id, err := NewID(NewURN())
-	if err != nil {
-		return nil, fmt.Errorf("error creating new feed: %v", err)
-	}
-
+// NewFeed creates a new Feed. It returns a *Feed.
+func NewFeed(title string) *Feed {
 	return &Feed{
-		ID:      id,
-		Title:   text,
+		ID:      NewID(NewURN()),
+		Title:   NewText("text", title),
 		Updated: NewDate(time.Now()),
-	}, nil
+	}
 }
 
-// AddAuthor adds the Person as an author to the Feed. It returns an error.
-func (f *Feed) AddAuthor(p *Person) error {
-	if p == nil {
-		return errors.New("error adding author element to feed: *Person is nil")
-	}
-
+// AddAuthor adds the Person as an author to the Feed.
+func (f *Feed) AddAuthor(p *Person) {
 	if f.Authors == nil {
 		f.Authors = make([]*Person, 1)
 		f.Authors[0] = p
@@ -59,15 +44,10 @@ func (f *Feed) AddAuthor(p *Person) error {
 	}
 
 	f.Updated.DateTime = DateTime(time.Now())
-	return nil
 }
 
-// AddCategory adds the Category to the Feed. It returns an error.
-func (f *Feed) AddCategory(c *Category) error {
-	if c == nil {
-		return errors.New("error adding category element to feed: *Category is nil")
-	}
-
+// AddCategory adds the Category to the Feed.
+func (f *Feed) AddCategory(c *Category) {
 	if f.Categories == nil {
 		f.Categories = make([]*Category, 1)
 		f.Categories[0] = c
@@ -76,16 +56,10 @@ func (f *Feed) AddCategory(c *Category) error {
 	}
 
 	f.Updated.DateTime = DateTime(time.Now())
-	return nil
 }
 
-// AddContributor adds the Person as a contributor to the Feed. It returns an
-// error.
-func (f *Feed) AddContributor(c *Person) error {
-	if c == nil {
-		return errors.New("error adding contributor element to feed: *Person is nil")
-	}
-
+// AddContributor adds the Person as a contributor to the Feed.
+func (f *Feed) AddContributor(c *Person) {
 	if f.Contributors == nil {
 		f.Contributors = make([]*Person, 1)
 		f.Contributors[0] = c
@@ -94,16 +68,10 @@ func (f *Feed) AddContributor(c *Person) error {
 	}
 
 	f.Updated.DateTime = DateTime(time.Now())
-	return nil
 }
 
-// AddLink adds the Link to the Feed. It returns an error. There should be one
-// Link with Rel "self".
-func (f *Feed) AddLink(l *Link) error {
-	if l == nil {
-		return errors.New("error adding link element to feed: *Link is nil")
-	}
-
+// AddLink adds the Link to the Feed. There should be one Link with Rel "self".
+func (f *Feed) AddLink(l *Link) {
 	if f.Links == nil {
 		f.Links = make([]*Link, 1)
 		f.Links[0] = l
@@ -112,15 +80,10 @@ func (f *Feed) AddLink(l *Link) error {
 	}
 
 	f.Updated.DateTime = DateTime(time.Now())
-	return nil
 }
 
-// AddExtension adds the Extension to the Feed. It returns an error.
-func (f *Feed) AddExtension(e *ExtensionElement) error {
-	if e == nil {
-		return errors.New("error adding extension element to feed: *ExtensionElement is nil")
-	}
-
+// AddExtension adds the Extension to the Feed.
+func (f *Feed) AddExtension(e *ExtensionElement) {
 	if f.Extensions == nil {
 		f.Extensions = make([]*ExtensionElement, 1)
 		f.Extensions[0] = e
@@ -129,15 +92,10 @@ func (f *Feed) AddExtension(e *ExtensionElement) error {
 	}
 
 	f.Updated.DateTime = DateTime(time.Now())
-	return nil
 }
 
-// AddEntry adds the Entry to the Feed. It returns an error.
-func (f *Feed) AddEntry(e *Entry) error {
-	if e == nil {
-		return errors.New("error adding entry element to feed: *Entry is nil")
-	}
-
+// AddEntry adds the Entry to the Feed.
+func (f *Feed) AddEntry(e *Entry) {
 	if f.Entries == nil {
 		f.Entries = make([]*Entry, 1)
 		f.Entries[0] = e
@@ -146,7 +104,6 @@ func (f *Feed) AddEntry(e *Entry) error {
 	}
 
 	f.Updated.DateTime = DateTime(time.Now())
-	return nil
 }
 
 // Check checks the Feed for incompatibilities with RFC4287. It returns an
diff --git a/generator.go b/generator.go
index c29a40d..f6030c9 100644
--- a/generator.go
+++ b/generator.go
@@ -2,7 +2,6 @@ package atom
 
 import (
 	"encoding/xml"
-	"errors"
 	"fmt"
 	"html"
 )
@@ -15,22 +14,9 @@ type Generator struct {
 	Text    string `xml:",chardata"`
 }
 
-// NewGenerator creates a new Generator. It returns a *Generator and an error.
-func NewGenerator(text string) (*Generator, error) {
-	if text == "" {
-		return nil, errors.New("error creating new generator: text string empty")
-	}
-
-	return &Generator{Text: html.UnescapeString(text)}, nil
-}
-
-// SetURI sets the URI attribute of the Generator. It returns an error.
-func (g *Generator) SetURI(uri string) error {
-	if !isValidIRI(uri) {
-		return fmt.Errorf("uri %v not correctly formatted", g)
-	}
-
-	return nil
+// NewGenerator creates a new Generator. It returns a *Generator.
+func NewGenerator(text string) *Generator {
+	return &Generator{Text: html.UnescapeString(text)}
 }
 
 // Check checks the Generator for incompatibilities with RFC4287. It returns an
diff --git a/icon.go b/icon.go
index 1242105..7bd8148 100644
--- a/icon.go
+++ b/icon.go
@@ -12,13 +12,9 @@ type Icon struct {
 	URI string `xml:",chardata"` // IRI
 }
 
-// NewIcon creates a new Icon. It returns a *Icon and an error.
-func NewIcon(uri string) (*Icon, error) {
-	if !isValidIRI(uri) {
-		return nil, fmt.Errorf("uri %v not correctly formatted", uri)
-	}
-
-	return &Icon{URI: uri}, nil
+// NewIcon creates a new Icon. It returns a *Icon.
+func NewIcon(uri string) *Icon {
+	return &Icon{URI: uri}
 }
 
 // Check checks the Icon for incompatibilities with RFC4287. It returns an
diff --git a/id.go b/id.go
index 18367bf..15f8f9d 100644
--- a/id.go
+++ b/id.go
@@ -12,13 +12,9 @@ type ID struct {
 	URI string `xml:",chardata"` // IRI
 }
 
-// NewID creates a new ID. It returns a *ID and an error.
-func NewID(uri string) (*ID, error) {
-	if !isValidIRI(uri) {
-		return nil, fmt.Errorf("uri %v not correctly formatted", uri)
-	}
-
-	return &ID{URI: uri}, nil
+// NewID creates a new ID. It returns a *ID.
+func NewID(uri string) *ID {
+	return &ID{URI: uri}
 }
 
 // Check checks the ID for incompatibilities with RFC4287. It returns an error.
diff --git a/inlineOtherContent.go b/inlineOtherContent.go
index 4fccdd7..1922122 100644
--- a/inlineOtherContent.go
+++ b/inlineOtherContent.go
@@ -15,13 +15,9 @@ type InlineOtherContent struct {
 
 // newInlineOtherContent creates a new InlineOtherContent. It returns a
 // *InlineOtherContent and an error.
-func newInlineOtherContent(mediaType string, content any) (*InlineOtherContent, error) {
-	if !isValidMediaType(mediaType) {
-		return nil, fmt.Errorf("error creating new inline other content: media type %v invalid", mediaType)
-	}
+func newInlineOtherContent(mediaType string, content any) *InlineOtherContent {
 	mediaType, _, _ = mime.ParseMediaType(mediaType)
-
-	return &InlineOtherContent{Type: mediaType, AnyElement: content}, nil
+	return &InlineOtherContent{Type: mediaType, AnyElement: content}
 }
 
 // isContent checks whether the InlineOtherContent is a Content. It returns a
diff --git a/inlineTextContent.go b/inlineTextContent.go
index 6502e95..7dc76b4 100644
--- a/inlineTextContent.go
+++ b/inlineTextContent.go
@@ -13,18 +13,9 @@ type InlineTextContent struct {
 }
 
 // newInlineTextContent creates a new InlineTextContent. It returns a
-// *InlineTextContent and an error.
-func newInlineTextContent(mediaType string, content any) (*InlineTextContent, error) {
-	if mediaType != "text" && mediaType != "html" && mediaType != "" {
-		return nil, fmt.Errorf("media type %v incompatible with inline text content", mediaType)
-	}
-
-	text, ok := content.(string)
-	if !ok {
-		return nil, fmt.Errorf("content type %T incompatible with inline text content", content)
-	}
-
-	return &InlineTextContent{Type: mediaType, Text: text}, nil
+// *InlineTextContent.
+func newInlineTextContent(mediaType, text string) *InlineTextContent {
+	return &InlineTextContent{Type: mediaType, Text: text}
 }
 
 // isContent checks whether the InlineTextContent is a Content. It returns a
diff --git a/inlineXHTMLContent.go b/inlineXHTMLContent.go
index e88bdd2..755d871 100644
--- a/inlineXHTMLContent.go
+++ b/inlineXHTMLContent.go
@@ -13,18 +13,9 @@ type InlineXHTMLContent struct {
 }
 
 // newInlineXHTMLContent creates a new InlineXHTMLContent. It returns a
-// *InlineXHTMLContent and an error.
-func newInlineXHTMLContent(mediaType string, content any) (*InlineXHTMLContent, error) {
-	if mediaType != "xhtml" {
-		return nil, fmt.Errorf("media type %v incompatible with inline xhtml content", mediaType)
-	}
-
-	xhtmlDiv, ok := content.(*XHTMLDiv)
-	if !ok {
-		return nil, fmt.Errorf("content type %T incompatible with inline xhtml content", content)
-	}
-
-	return &InlineXHTMLContent{Type: mediaType, XHTMLDiv: xhtmlDiv}, nil
+// *InlineXHTMLContent.
+func newInlineXHTMLContent(mediaType string, div *XHTMLDiv) *InlineXHTMLContent {
+	return &InlineXHTMLContent{Type: mediaType, XHTMLDiv: div}
 }
 
 // isContent checks whether the InlineXHTMLContent is a Content. It returns a
diff --git a/link.go b/link.go
index cd3a58d..18b57c6 100644
--- a/link.go
+++ b/link.go
@@ -17,31 +17,9 @@ type Link struct {
 	Length   uint   `xml:"length,attr,omitempty"`
 }
 
-// NewLink creates a new Link. It returns a *Link and an error.
-func NewLink(href string) (*Link, error) {
-	if !isValidIRI(href) {
-		return nil, fmt.Errorf("href %v not correctly formatted", href)
-	}
-
-	return &Link{Href: href}, nil
-}
-
-// SetType sets the Type attribute of the Link. It returns an error.
-func (l *Link) SetType(t string) error {
-	if !isValidMediaType(t) {
-		return fmt.Errorf("type %v invalid media type", t)
-	}
-
-	return nil
-}
-
-// SetHrefLang sets the HrefLang attribute of the Link. It returns an error.
-func (l *Link) SetHrefLang(h string) error {
-	if !isValidLanguageTag(h) {
-		return fmt.Errorf("hreflang %v invalid language tag", h)
-	}
-
-	return nil
+// NewLink creates a new Link. It returns a *Link.
+func NewLink(href string) *Link {
+	return &Link{Href: href}
 }
 
 // Check checks the Link for incompatibilities with RFC4287. It returns an
diff --git a/logo.go b/logo.go
index 62dbe07..802994e 100644
--- a/logo.go
+++ b/logo.go
@@ -11,13 +11,9 @@ type Logo struct {
 	URI string `xml:",chardata"` // IRI
 }
 
-// NewLogo creates a new Logo. It returns a *Logo and an error.
-func NewLogo(uri string) (*Logo, error) {
-	if !isValidIRI(uri) {
-		return nil, fmt.Errorf("uri %v not correctly formatted", uri)
-	}
-
-	return &Logo{URI: uri}, nil
+// NewLogo creates a new Logo. It returns a *Logo.
+func NewLogo(uri string) *Logo {
+	return &Logo{URI: uri}
 }
 
 // Check checks the Logo for incompatibilities with RFC4287. It returns an
diff --git a/outOfLineContent.go b/outOfLineContent.go
index c6dc931..a6f60a6 100644
--- a/outOfLineContent.go
+++ b/outOfLineContent.go
@@ -14,23 +14,10 @@ type OutOfLineContent struct {
 }
 
 // newOutOfLineContent creates a new OutOfLineContent. It returns a
-// *OutOfLineContent and an error.
-func newOutOfLineContent(mediaType string, content any) (*OutOfLineContent, error) {
-	if !isValidMediaType(mediaType) {
-		return nil, fmt.Errorf("error creating new out of line content: media type %v invalid", mediaType)
-	}
+// *OutOfLineContent.
+func newOutOfLineContent(mediaType, src string) *OutOfLineContent {
 	mediaType, _, _ = mime.ParseMediaType(mediaType)
-
-	iri, ok := content.(string)
-	if !ok {
-		return nil, fmt.Errorf("content type %T incompatible with out of line content", content)
-	}
-
-	if !isValidIRI(iri) {
-		return nil, fmt.Errorf("content %v not a valid uri", iri)
-	}
-
-	return &OutOfLineContent{Type: mediaType, SRC: iri}, nil
+	return &OutOfLineContent{Type: mediaType, SRC: src}
 }
 
 // isContent checks whether the OutOfLineContent is a Content. It returns a
diff --git a/person.go b/person.go
index 899faf6..ef77cfd 100644
--- a/person.go
+++ b/person.go
@@ -1,7 +1,6 @@
 package atom
 
 import (
-	"errors"
 	"fmt"
 	"net/mail"
 )
@@ -14,38 +13,19 @@ type Person struct {
 	Extensions []*ExtensionElement `xml:",any,omitempty"`
 }
 
-// NewPerson creates a new Person. It returns a *Person and an error.
-func NewPerson(name string) (*Person, error) {
-	if name == "" {
-		return nil, errors.New("error creating new person: name string empty")
-	}
-
-	return &Person{Name: name}, nil
+// NewPerson creates a new Person. It returns a *Person.
+func NewPerson(name string) *Person {
+	return &Person{Name: name}
 }
 
-// SetURI sets the URI element of the Person. It returns an error.
-func (l *Link) SetURI(uri string) error {
-	if !isValidIRI(uri) {
-		return fmt.Errorf("uri %v not correctly formatted", uri)
-	}
-
-	return nil
-}
-
-// AddExtension adds the Extension to the Person. It returns an error.
-func (p *Person) AddExtension(e *ExtensionElement) error {
-	if e == nil {
-		return errors.New("error adding extension element to person: *ExtensionElement is nil")
-	}
-
+// AddExtension adds the Extension to the Person.
+func (p *Person) AddExtension(e *ExtensionElement) {
 	if p.Extensions == nil {
 		p.Extensions = make([]*ExtensionElement, 1)
 		p.Extensions[0] = e
 	} else {
 		p.Extensions = append(p.Extensions, e)
 	}
-
-	return nil
 }
 
 // Check checks the Person for incompatibilities with RFC4287. It returns an
diff --git a/plainText.go b/plainText.go
index a24d4ce..7403391 100644
--- a/plainText.go
+++ b/plainText.go
@@ -1,7 +1,6 @@
 package atom
 
 import (
-	"errors"
 	"fmt"
 )
 
@@ -14,13 +13,9 @@ type PlainText struct {
 // isText checks whether the PlainText is a Text. It returns a bool.
 func (p *PlainText) isText() bool { return true }
 
-// newPlainText creates a new PlainText. It returns a *PlainText and an error.
-func newPlainText(textType, content string) (*PlainText, error) {
-	if content == "" {
-		return nil, errors.New("error creating new plain text: content string empty")
-	}
-
-	return &PlainText{Type: textType, Text: content}, nil
+// newPlainText creates a new PlainText. It returns a *PlainText.
+func newPlainText(textType, content string) *PlainText {
+	return &PlainText{Type: textType, Text: content}
 }
 
 // Check checks the PlainText for incompatibilities with RFC4287. It returns an
diff --git a/text.go b/text.go
index a174d42..c8b0f78 100644
--- a/text.go
+++ b/text.go
@@ -1,17 +1,14 @@
 package atom
 
-import (
-	"fmt"
-	"html"
-)
+import "html"
 
 type Text interface {
 	isText() bool
 	Check() error
 }
 
-// NewText creates a new Text. It returns a Text and an error.
-func NewText(textType, content string) (Text, error) {
+// NewText creates a new Text. It returns a Text.
+func NewText(textType, content string) Text {
 	switch textType {
 	case "text", "":
 		return newPlainText(textType, content)
@@ -20,6 +17,6 @@ func NewText(textType, content string) (Text, error) {
 	case "xhtml":
 		return newXHTMLText(textType, content)
 	default:
-		return nil, fmt.Errorf("%v is not a valid text type", textType)
+		return nil
 	}
 }
diff --git a/xhtmlDiv.go b/xhtmlDiv.go
index 0c9bbbe..0629a37 100644
--- a/xhtmlDiv.go
+++ b/xhtmlDiv.go
@@ -2,7 +2,6 @@ package atom
 
 import (
 	"encoding/xml"
-	"errors"
 	"fmt"
 )
 
@@ -12,16 +11,12 @@ type XHTMLDiv struct {
 	Content string   `xml:",innerxml"`
 }
 
-// NewXHTMLDiv creates a new XHTMLDiv. It returns a *XHTMLDiv and an error.
-func NewXHTMLDiv(content string) (*XHTMLDiv, error) {
-	if content == "" {
-		return nil, errors.New("error creating new xhtml div: content string empty")
-	}
-
+// NewXHTMLDiv creates a new XHTMLDiv. It returns a *XHTMLDiv.
+func NewXHTMLDiv(content string) *XHTMLDiv {
 	return &XHTMLDiv{
 		XMLNS:   "http://www.w3.org/1999/xhtml",
 		Content: content,
-	}, nil
+	}
 }
 
 // Check checks the XHTMLDiv for incompatibilities with RFC4287. It returns an
diff --git a/xhtmlText.go b/xhtmlText.go
index 719fb74..ea57804 100644
--- a/xhtmlText.go
+++ b/xhtmlText.go
@@ -13,17 +13,12 @@ type XHTMLText struct {
 // isText checks whether the XHTMLText is a Text. It returns a bool.
 func (x *XHTMLText) isText() bool { return true }
 
-// newPlainText creates a new PlainText. It returns a *PlainText and an error.
-func newXHTMLText(textType, content string) (*XHTMLText, error) {
-	xhtmlDiv, err := NewXHTMLDiv(content)
-	if err != nil {
-		return nil, fmt.Errorf("error creating new xhtml text: %v", err)
-	}
-
+// newPlainText creates a new PlainText. It returns a *PlainText.
+func newXHTMLText(textType, content string) *XHTMLText {
 	return &XHTMLText{
 		Type:     textType,
-		XHTMLDiv: xhtmlDiv,
-	}, nil
+		XHTMLDiv: NewXHTMLDiv(content),
+	}
 }
 
 // Check checks the XHTMLText for incompatibilities with RFC4287. It returns an