fix dogoc comments

Author: PeterIvanov

id.go

@@ -4,8 +4,8 @@ import "sync/atomic"
 
 var internalID int64
 
-// Create next unique id for errorx entities
-// All equality comparison should take id into account, lest there be some false positive matches
+// nextInternalID creates next unique id for errorx entities.
+// All equality comparison should take id into account, lest there be some false positive matches.
 func nextInternalID() int64 {
 	return atomic.AddInt64(&internalID, 1)
 }

modifier.go

@@ -1,9 +1,9 @@
 package errorx
 
-// Modifier is a way to change a default behaviour for an error type, directly or via type hierarchy
-// Modification is intentionally one-way, as it provides much more clarity
-// If there is a modifier on a type or a namespace, all its descendants definitely have the same default behaviour
-// If some of a subtypes must lack a specific modifier, then the modifier must be removed from the common ancestor
+// Modifier is a way to change a default behaviour for an error type, directly or via type hierarchy.
+// Modification is intentionally one-way, as it provides much more clarity.
+// If there is a modifier on a type or a namespace, all its descendants definitely have the same default behaviour.
+// If some of a subtypes must lack a specific modifier, then the modifier must be removed from the common ancestor.
 type TypeModifier int
 
 const (

namespace.go

@@ -2,10 +2,13 @@ package errorx
 
 import "fmt"
 
-// A namespace is a way go group a number of error types together, and each error type belongs to exactly one namespace
-// Namespaces may form hierarchy, with child namespaces inheriting the traits and modifiers of a parent
-// Those modifiers and traits are then passed upon all error types in the namespace
-// In formatting, a dot notation is used, for example: namespace.sub_namespace.type.subtype
+// Namespace is a way go group a number of error types together, and each error type belongs to exactly one namespace.
+// Namespaces may form hierarchy, with child namespaces inheriting the traits and modifiers of a parent.
+// Those modifiers and traits are then passed upon all error types in the namespace.
+// In formatting, a dot notation is used, for example:
+//
+// 		namespace.sub_namespace.type.subtype
+//
 type Namespace struct {
 	parent    *Namespace
 	id        int64
@@ -14,46 +17,46 @@ type Namespace struct {
 	modifiers modifiers
 }
 
-// Namespace itself is not comparable, so a key be used instead
+// Namespace itself is not comparable, so a key be used instead.
 type NamespaceKey struct {
 	id   int64
 	name string
 }
 
-// Define a namespace with a name and, optionally, a number of inheritable traits
+// NewNamespace defines a namespace with a name and, optionally, a number of inheritable traits.
 func NewNamespace(name string, traits ...Trait) Namespace {
 	namespace := newNamespace(nil, name, traits...)
 	globalRegistry.registerNamespace(namespace)
 	return namespace
 }
 
-// Define a child namespace that inherits all that is defined for a parent and, optionally, adds some more
+// NewSubNamespace defines a child namespace that inherits all that is defined for a parent and, optionally, adds some more.
 func (n Namespace) NewSubNamespace(name string, traits ...Trait) Namespace {
 	namespace := newNamespace(&n, name, traits...)
 	globalRegistry.registerNamespace(namespace)
 	return namespace
 }
 
-// One-time modification of defaults in error creation
+// ApplyModifiers makes a one-time modification of defaults in error creation.
 func (n Namespace) ApplyModifiers(modifiers ...TypeModifier) Namespace {
 	n.modifiers = n.modifiers.ReplaceWith(newTypeModifiers(modifiers...))
 	return n
 }
 
-// Create a new type within a namespace  that inherits all that is defined for namespace and, optionally, adds some more
+// NewType creates a new type within a namespace  that inherits all that is defined for namespace and, optionally, adds some more.
 func (n Namespace) NewType(typeName string, traits ...Trait) *Type {
 	return NewType(n, typeName, traits...)
 }
 
-// A comparison key
+// Key returns a comparison key for namespace.
 func (n Namespace) Key() NamespaceKey {
 	return NamespaceKey{
 		id:   n.id,
 		name: n.name,
 	}
 }
 
-// Check whether or not an error belongs either to this namespace or some of its sub-namespaces
+// IsNamespaceOf checks whether or not an error belongs either to this namespace or some of its sub-namespaces.
 func (n Namespace) IsNamespaceOf(t *Type) bool {
 	namespace := t.namespace
 	other := &namespace
@@ -69,7 +72,7 @@ func (n Namespace) IsNamespaceOf(t *Type) bool {
 	return false
 }
 
-// Returns a full name of a namespace
+// FullName returns a full name of a namespace.
 func (n Namespace) FullName() string {
 	return n.name
 }
@@ -78,8 +81,8 @@ func (n Namespace) String() string {
 	return n.name
 }
 
-// Returns the immediate parent namespace, if present
-// The use of this function outside of a system layer that handles error types (see TypeSubscriber) is a code smell
+// Parent returns the immediate parent namespace, if present.
+// The use of this function outside of a system layer that handles error types (see TypeSubscriber) is a code smell.
 func (n Namespace) Parent() *Namespace {
 	return n.parent
 }