Refactor variable and function names for improved clarity in msg.go

The change updates various variable and function names in msg.go to make the code more intuitive. Updated names better capture what they represent or do, improving code readability and maintainability. This refactor does not impact functionality or logic of the code.

msg.go

@@ -126,8 +126,8 @@ const SendmailPath = "/usr/sbin/sendmail"
 type MsgOption func(*Msg)
 
 // NewMsg returns a new Msg pointer
-func NewMsg(o ...MsgOption) *Msg {
+func NewMsg(opts ...MsgOption) *Msg {
-	m := &Msg{
+	msg := &Msg{
 		addrHeader:    make(map[AddrHeader][]*mail.Address),
 		charset:       CharsetUTF8,
 		encoding:      EncodingQP,
@@ -137,17 +137,17 @@ func NewMsg(o ...MsgOption) *Msg {
 	}
 
 	// Override defaults with optionally provided MsgOption functions
-	for _, co := range o {
+	for _, option := range opts {
-		if co == nil {
+		if option == nil {
 			continue
 		}
-		co(m)
+		option(msg)
 	}
 
 	// Set the matcing mime.WordEncoder for the Msg
-	m.setEncoder()
+	msg.setEncoder()
 
-	return m
+	return msg
 }
 
 // WithCharset overrides the default message charset
@@ -186,9 +186,9 @@ func WithMiddleware(mw Middleware) MsgOption {
 }
 
 // WithPGPType overrides the default PGPType of the message
-func WithPGPType(t PGPType) MsgOption {
+func WithPGPType(pt PGPType) MsgOption {
 	return func(m *Msg) {
-		m.pgptype = t
+		m.pgptype = pt
 	}
 }
 
@@ -232,20 +232,20 @@ func (m *Msg) Charset() string {
 // For adding address headers like "To:" or "From", see SetAddrHeader
 //
 // Deprecated: This method only exists for compatibility reason. Please use SetGenHeader instead
-func (m *Msg) SetHeader(h Header, v ...string) {
+func (m *Msg) SetHeader(header Header, values ...string) {
-	m.SetGenHeader(h, v...)
+	m.SetGenHeader(header, values...)
 }
 
 // SetGenHeader sets a generic header field of the Msg
 // For adding address headers like "To:" or "From", see SetAddrHeader
-func (m *Msg) SetGenHeader(h Header, v ...string) {
+func (m *Msg) SetGenHeader(header Header, values ...string) {
 	if m.genHeader == nil {
 		m.genHeader = make(map[Header][]string)
 	}
-	for i, hv := range v {
+	for i, val := range values {
-		v[i] = m.encodeString(hv)
+		values[i] = m.encodeString(val)
 	}
-	m.genHeader[h] = v
+	m.genHeader[header] = values
 }
 
 // SetHeaderPreformatted sets a generic header field of the Msg which content is
@@ -253,8 +253,8 @@ func (m *Msg) SetGenHeader(h Header, v ...string) {
 //
 // Deprecated: This method only exists for compatibility reason. Please use
 // SetGenHeaderPreformatted instead
-func (m *Msg) SetHeaderPreformatted(h Header, v string) {
+func (m *Msg) SetHeaderPreformatted(header Header, value string) {
-	m.SetGenHeaderPreformatted(h, v)
+	m.SetGenHeaderPreformatted(header, value)
 }
 
 // SetGenHeaderPreformatted sets a generic header field of the Msg which content is
@@ -268,206 +268,207 @@ func (m *Msg) SetHeaderPreformatted(h Header, v string) {
 // user is respondible for the formating of the message header, go-mail cannot
 // guarantee the fully compliance with the RFC 2822. It is recommended to use
 // SetGenHeader instead.
-func (m *Msg) SetGenHeaderPreformatted(h Header, v string) {
+func (m *Msg) SetGenHeaderPreformatted(header Header, value string) {
 	if m.preformHeader == nil {
 		m.preformHeader = make(map[Header]string)
 	}
-	m.preformHeader[h] = v
+	m.preformHeader[header] = value
 }
 
 // SetAddrHeader sets an address related header field of the Msg
-func (m *Msg) SetAddrHeader(h AddrHeader, v ...string) error {
+func (m *Msg) SetAddrHeader(header AddrHeader, values ...string) error {
 	if m.addrHeader == nil {
 		m.addrHeader = make(map[AddrHeader][]*mail.Address)
 	}
-	var al []*mail.Address
+	var addresses []*mail.Address
-	for _, av := range v {
+	for _, addrVal := range values {
-		a, err := mail.ParseAddress(av)
+		address, err := mail.ParseAddress(addrVal)
 		if err != nil {
-			return fmt.Errorf(errParseMailAddr, av, err)
+			return fmt.Errorf(errParseMailAddr, addrVal, err)
 		}
-		al = append(al, a)
+		addresses = append(addresses, address)
 	}
-	switch h {
+	switch header {
 	case HeaderFrom:
-		if len(al) > 0 {
+		if len(addresses) > 0 {
-			m.addrHeader[h] = []*mail.Address{al[0]}
+			m.addrHeader[header] = []*mail.Address{addresses[0]}
 		}
 	default:
-		m.addrHeader[h] = al
+		m.addrHeader[header] = addresses
 	}
 	return nil
 }
 
 // SetAddrHeaderIgnoreInvalid sets an address related header field of the Msg and ignores invalid address
 // in the validation process
-func (m *Msg) SetAddrHeaderIgnoreInvalid(h AddrHeader, v ...string) {
+func (m *Msg) SetAddrHeaderIgnoreInvalid(header AddrHeader, values ...string) {
-	var al []*mail.Address
+	var addresses []*mail.Address
-	for _, av := range v {
+	for _, addrVal := range values {
-		a, err := mail.ParseAddress(m.encodeString(av))
+		address, err := mail.ParseAddress(m.encodeString(addrVal))
 		if err != nil {
 			continue
 		}
-		al = append(al, a)
+		addresses = append(addresses, address)
 	}
-	m.addrHeader[h] = al
+	m.addrHeader[header] = addresses
 }
 
 // EnvelopeFrom takes and validates a given mail address and sets it as envelope "FROM"
 // addrHeader of the Msg
-func (m *Msg) EnvelopeFrom(f string) error {
+func (m *Msg) EnvelopeFrom(from string) error {
-	return m.SetAddrHeader(HeaderEnvelopeFrom, f)
+	return m.SetAddrHeader(HeaderEnvelopeFrom, from)
 }
 
 // EnvelopeFromFormat takes a name and address, formats them RFC5322 compliant and stores them as
 // the envelope FROM address header field
-func (m *Msg) EnvelopeFromFormat(n, a string) error {
+func (m *Msg) EnvelopeFromFormat(name, addr string) error {
-	return m.SetAddrHeader(HeaderEnvelopeFrom, fmt.Sprintf(`"%s" <%s>`, n, a))
+	return m.SetAddrHeader(HeaderEnvelopeFrom, fmt.Sprintf(`"%s" <%s>`, name, addr))
 }
 
 // From takes and validates a given mail address and sets it as "From" genHeader of the Msg
-func (m *Msg) From(f string) error {
+func (m *Msg) From(from string) error {
-	return m.SetAddrHeader(HeaderFrom, f)
+	return m.SetAddrHeader(HeaderFrom, from)
 }
 
 // FromFormat takes a name and address, formats them RFC5322 compliant and stores them as
 // the From address header field
-func (m *Msg) FromFormat(n, a string) error {
+func (m *Msg) FromFormat(name, addr string) error {
-	return m.SetAddrHeader(HeaderFrom, fmt.Sprintf(`"%s" <%s>`, n, a))
+	return m.SetAddrHeader(HeaderFrom, fmt.Sprintf(`"%s" <%s>`, name, addr))
 }
 
 // To takes and validates a given mail address list sets the To: addresses of the Msg
-func (m *Msg) To(t ...string) error {
+func (m *Msg) To(rcpts ...string) error {
-	return m.SetAddrHeader(HeaderTo, t...)
+	return m.SetAddrHeader(HeaderTo, rcpts...)
 }
 
 // AddTo adds an additional address to the To address header field
-func (m *Msg) AddTo(t string) error {
+func (m *Msg) AddTo(rcpt string) error {
-	return m.addAddr(HeaderTo, t)
+	return m.addAddr(HeaderTo, rcpt)
 }
 
 // AddToFormat takes a name and address, formats them RFC5322 compliant and stores them as
 // as additional To address header field
-func (m *Msg) AddToFormat(n, a string) error {
+func (m *Msg) AddToFormat(name, addr string) error {
-	return m.addAddr(HeaderTo, fmt.Sprintf(`"%s" <%s>`, n, a))
+	return m.addAddr(HeaderTo, fmt.Sprintf(`"%s" <%s>`, name, addr))
 }
 
 // ToIgnoreInvalid takes and validates a given mail address list sets the To: addresses of the Msg
 // Any provided address that is not RFC5322 compliant, will be ignored
-func (m *Msg) ToIgnoreInvalid(t ...string) {
+func (m *Msg) ToIgnoreInvalid(rcpts ...string) {
-	m.SetAddrHeaderIgnoreInvalid(HeaderTo, t...)
+	m.SetAddrHeaderIgnoreInvalid(HeaderTo, rcpts...)
 }
 
 // ToFromString takes and validates a given string of comma separted
 // mail address and sets them as To: addresses of the Msg
-func (m *Msg) ToFromString(v string) error {
+func (m *Msg) ToFromString(rcpts string) error {
-	return m.To(strings.Split(v, ",")...)
+	return m.To(strings.Split(rcpts, ",")...)
 }
 
 // Cc takes and validates a given mail address list sets the Cc: addresses of the Msg
-func (m *Msg) Cc(c ...string) error {
+func (m *Msg) Cc(rcpts ...string) error {
-	return m.SetAddrHeader(HeaderCc, c...)
+	return m.SetAddrHeader(HeaderCc, rcpts...)
 }
 
 // AddCc adds an additional address to the Cc address header field
-func (m *Msg) AddCc(t string) error {
+func (m *Msg) AddCc(rcpt string) error {
-	return m.addAddr(HeaderCc, t)
+	return m.addAddr(HeaderCc, rcpt)
 }
 
 // AddCcFormat takes a name and address, formats them RFC5322 compliant and stores them as
 // as additional Cc address header field
-func (m *Msg) AddCcFormat(n, a string) error {
+func (m *Msg) AddCcFormat(name, addr string) error {
-	return m.addAddr(HeaderCc, fmt.Sprintf(`"%s" <%s>`, n, a))
+	return m.addAddr(HeaderCc, fmt.Sprintf(`"%s" <%s>`, name, addr))
 }
 
 // CcIgnoreInvalid takes and validates a given mail address list sets the Cc: addresses of the Msg
 // Any provided address that is not RFC5322 compliant, will be ignored
-func (m *Msg) CcIgnoreInvalid(c ...string) {
+func (m *Msg) CcIgnoreInvalid(rcpts ...string) {
-	m.SetAddrHeaderIgnoreInvalid(HeaderCc, c...)
+	m.SetAddrHeaderIgnoreInvalid(HeaderCc, rcpts...)
 }
 
 // CcFromString takes and validates a given string of comma separted
 // mail address and sets them as Cc: addresses of the Msg
-func (m *Msg) CcFromString(v string) error {
+func (m *Msg) CcFromString(rcpts string) error {
-	return m.Cc(strings.Split(v, ",")...)
+	return m.Cc(strings.Split(rcpts, ",")...)
 }
 
 // Bcc takes and validates a given mail address list sets the Bcc: addresses of the Msg
-func (m *Msg) Bcc(b ...string) error {
+func (m *Msg) Bcc(rcpts ...string) error {
-	return m.SetAddrHeader(HeaderBcc, b...)
+	return m.SetAddrHeader(HeaderBcc, rcpts...)
 }
 
 // AddBcc adds an additional address to the Bcc address header field
-func (m *Msg) AddBcc(t string) error {
+func (m *Msg) AddBcc(rcpt string) error {
-	return m.addAddr(HeaderBcc, t)
+	return m.addAddr(HeaderBcc, rcpt)
 }
 
 // AddBccFormat takes a name and address, formats them RFC5322 compliant and stores them as
 // as additional Bcc address header field
-func (m *Msg) AddBccFormat(n, a string) error {
+func (m *Msg) AddBccFormat(name, addr string) error {
-	return m.addAddr(HeaderBcc, fmt.Sprintf(`"%s" <%s>`, n, a))
+	return m.addAddr(HeaderBcc, fmt.Sprintf(`"%s" <%s>`, name, addr))
 }
 
 // BccIgnoreInvalid takes and validates a given mail address list sets the Bcc: addresses of the Msg
 // Any provided address that is not RFC5322 compliant, will be ignored
-func (m *Msg) BccIgnoreInvalid(b ...string) {
+func (m *Msg) BccIgnoreInvalid(rcpts ...string) {
-	m.SetAddrHeaderIgnoreInvalid(HeaderBcc, b...)
+	m.SetAddrHeaderIgnoreInvalid(HeaderBcc, rcpts...)
 }
 
 // BccFromString takes and validates a given string of comma separted
 // mail address and sets them as Bcc: addresses of the Msg
-func (m *Msg) BccFromString(v string) error {
+func (m *Msg) BccFromString(rcpts string) error {
-	return m.Bcc(strings.Split(v, ",")...)
+	return m.Bcc(strings.Split(rcpts, ",")...)
 }
 
 // ReplyTo takes and validates a given mail address and sets it as "Reply-To" addrHeader of the Msg
-func (m *Msg) ReplyTo(r string) error {
+func (m *Msg) ReplyTo(addr string) error {
-	rt, err := mail.ParseAddress(r)
+	replyTo, err := mail.ParseAddress(addr)
 	if err != nil {
 		return fmt.Errorf("failed to parse reply-to address: %w", err)
 	}
-	m.SetGenHeader(HeaderReplyTo, rt.String())
+	m.SetGenHeader(HeaderReplyTo, replyTo.String())
 	return nil
 }
 
 // ReplyToFormat takes a name and address, formats them RFC5322 compliant and stores them as
 // the Reply-To header field
-func (m *Msg) ReplyToFormat(n, a string) error {
+func (m *Msg) ReplyToFormat(name, addr string) error {
-	return m.ReplyTo(fmt.Sprintf(`"%s" <%s>`, n, a))
+	return m.ReplyTo(fmt.Sprintf(`"%s" <%s>`, name, addr))
 }
 
 // addAddr adds an additional address to the given addrHeader of the Msg
-func (m *Msg) addAddr(h AddrHeader, a string) error {
+func (m *Msg) addAddr(header AddrHeader, addr string) error {
-	var al []string
+	var addresses []string
-	for _, ca := range m.addrHeader[h] {
+	for _, address := range m.addrHeader[header] {
-		al = append(al, ca.String())
+		addresses = append(addresses, address.String())
 	}
-	al = append(al, a)
+	addresses = append(addresses, addr)
-	return m.SetAddrHeader(h, al...)
+	return m.SetAddrHeader(header, addresses...)
 }
 
 // Subject sets the "Subject" header field of the Msg
-func (m *Msg) Subject(s string) {
+func (m *Msg) Subject(subj string) {
-	m.SetGenHeader(HeaderSubject, s)
+	m.SetGenHeader(HeaderSubject, subj)
 }
 
 // SetMessageID generates a random message id for the mail
 func (m *Msg) SetMessageID() {
-	hn, err := os.Hostname()
+	hostname, err := os.Hostname()
 	if err != nil {
-		hn = "localhost.localdomain"
+		hostname = "localhost.localdomain"
 	}
-	rn, _ := randNum(100000000)
+	randNumPrimary, _ := randNum(100000000)
-	rm, _ := randNum(10000)
+	randNumSecondary, _ := randNum(10000)
-	rs, _ := randomStringSecure(17)
+	randString, _ := randomStringSecure(17)
-	pid := os.Getpid() * rm
+	procID := os.Getpid() * randNumSecondary
-	mid := fmt.Sprintf("%d.%d%d.%s@%s", pid, rn, rm, rs, hn)
+	messageID := fmt.Sprintf("%d.%d%d.%s@%s", procID, randNumPrimary, randNumSecondary,
-	m.SetMessageIDWithValue(mid)
+		randString, hostname)
+	m.SetMessageIDWithValue(messageID)
 }
 
 // SetMessageIDWithValue sets the message id for the mail
-func (m *Msg) SetMessageIDWithValue(v string) {
+func (m *Msg) SetMessageIDWithValue(messageID string) {
-	m.SetGenHeader(HeaderMessageID, fmt.Sprintf("<%s>", v))
+	m.SetGenHeader(HeaderMessageID, fmt.Sprintf("<%s>", messageID))
 }
 
 // SetBulk sets the "Precedence: bulk" and "X-Auto-Response-Suppress: All" genHeaders which are
@@ -481,35 +482,35 @@ func (m *Msg) SetBulk() {
 
 // SetDate sets the Date genHeader field to the current time in a valid format
 func (m *Msg) SetDate() {
-	ts := time.Now().Format(time.RFC1123Z)
+	now := time.Now().Format(time.RFC1123Z)
-	m.SetGenHeader(HeaderDate, ts)
+	m.SetGenHeader(HeaderDate, now)
 }
 
 // SetDateWithValue sets the Date genHeader field to the provided time in a valid format
-func (m *Msg) SetDateWithValue(t time.Time) {
+func (m *Msg) SetDateWithValue(timeVal time.Time) {
-	m.SetGenHeader(HeaderDate, t.Format(time.RFC1123Z))
+	m.SetGenHeader(HeaderDate, timeVal.Format(time.RFC1123Z))
 }
 
 // SetImportance sets the Msg Importance/Priority header to given Importance
-func (m *Msg) SetImportance(i Importance) {
+func (m *Msg) SetImportance(importance Importance) {
-	if i == ImportanceNormal {
+	if importance == ImportanceNormal {
 		return
 	}
-	m.SetGenHeader(HeaderImportance, i.String())
+	m.SetGenHeader(HeaderImportance, importance.String())
-	m.SetGenHeader(HeaderPriority, i.NumString())
+	m.SetGenHeader(HeaderPriority, importance.NumString())
-	m.SetGenHeader(HeaderXPriority, i.XPrioString())
+	m.SetGenHeader(HeaderXPriority, importance.XPrioString())
-	m.SetGenHeader(HeaderXMSMailPriority, i.NumString())
+	m.SetGenHeader(HeaderXMSMailPriority, importance.NumString())
 }
 
 // SetOrganization sets the provided string as Organization header for the Msg
-func (m *Msg) SetOrganization(o string) {
+func (m *Msg) SetOrganization(org string) {
-	m.SetGenHeader(HeaderOrganization, o)
+	m.SetGenHeader(HeaderOrganization, org)
 }
 
 // SetUserAgent sets the User-Agent/X-Mailer header for the Msg
-func (m *Msg) SetUserAgent(a string) {
+func (m *Msg) SetUserAgent(userAgent string) {
-	m.SetGenHeader(HeaderUserAgent, a)
+	m.SetGenHeader(HeaderUserAgent, userAgent)
-	m.SetGenHeader(HeaderXMailer, a)
+	m.SetGenHeader(HeaderXMailer, userAgent)
 }
 
 // IsDelivered will return true if the Msg has been successfully delivered
@@ -521,17 +522,17 @@ func (m *Msg) IsDelivered() bool {
 // as described in RFC8098. It allows to provide a list recipient addresses.
 // Address validation is performed
 // See: https://www.rfc-editor.org/rfc/rfc8098.html
-func (m *Msg) RequestMDNTo(t ...string) error {
+func (m *Msg) RequestMDNTo(rcpts ...string) error {
-	var tl []string
+	var addresses []string
-	for _, at := range t {
+	for _, addrVal := range rcpts {
-		a, err := mail.ParseAddress(at)
+		address, err := mail.ParseAddress(addrVal)
 		if err != nil {
-			return fmt.Errorf(errParseMailAddr, at, err)
+			return fmt.Errorf(errParseMailAddr, addrVal, err)
 		}
-		tl = append(tl, a.String())
+		addresses = append(addresses, address.String())
 	}
 	if _, ok := m.genHeader[HeaderDispositionNotificationTo]; ok {
-		m.genHeader[HeaderDispositionNotificationTo] = tl
+		m.genHeader[HeaderDispositionNotificationTo] = addresses
 	}
 	return nil
 }
@@ -540,77 +541,77 @@ func (m *Msg) RequestMDNTo(t ...string) error {
 // as described in RFC8098. It allows to provide a recipient address with name and address and will format
 // accordingly. Address validation is performed
 // See: https://www.rfc-editor.org/rfc/rfc8098.html
-func (m *Msg) RequestMDNToFormat(n, a string) error {
+func (m *Msg) RequestMDNToFormat(name, addr string) error {
-	return m.RequestMDNTo(fmt.Sprintf(`%s <%s>`, n, a))
+	return m.RequestMDNTo(fmt.Sprintf(`%s <%s>`, name, addr))
 }
 
 // RequestMDNAddTo adds an additional recipient to the recipient list of the MDN
-func (m *Msg) RequestMDNAddTo(t string) error {
+func (m *Msg) RequestMDNAddTo(rcpt string) error {
-	a, err := mail.ParseAddress(t)
+	address, err := mail.ParseAddress(rcpt)
 	if err != nil {
-		return fmt.Errorf(errParseMailAddr, t, err)
+		return fmt.Errorf(errParseMailAddr, rcpt, err)
 	}
-	var tl []string
+	var addresses []string
-	tl = append(tl, m.genHeader[HeaderDispositionNotificationTo]...)
+	addresses = append(addresses, m.genHeader[HeaderDispositionNotificationTo]...)
-	tl = append(tl, a.String())
+	addresses = append(addresses, address.String())
 	if _, ok := m.genHeader[HeaderDispositionNotificationTo]; ok {
-		m.genHeader[HeaderDispositionNotificationTo] = tl
+		m.genHeader[HeaderDispositionNotificationTo] = addresses
 	}
 	return nil
 }
 
 // RequestMDNAddToFormat adds an additional formated recipient to the recipient list of the MDN
-func (m *Msg) RequestMDNAddToFormat(n, a string) error {
+func (m *Msg) RequestMDNAddToFormat(name, addr string) error {
-	return m.RequestMDNAddTo(fmt.Sprintf(`"%s" <%s>`, n, a))
+	return m.RequestMDNAddTo(fmt.Sprintf(`"%s" <%s>`, name, addr))
 }
 
 // GetSender returns the currently set envelope FROM address. If no envelope FROM is set it will use
-// the first mail body FROM address. If ff is true, it will return the full address string including
+// the first mail body FROM address. If useFullAddr is true, it will return the full address string
-// the address name, if set
+// including the address name, if set
-func (m *Msg) GetSender(ff bool) (string, error) {
+func (m *Msg) GetSender(useFullAddr bool) (string, error) {
-	f, ok := m.addrHeader[HeaderEnvelopeFrom]
+	from, ok := m.addrHeader[HeaderEnvelopeFrom]
-	if !ok || len(f) == 0 {
+	if !ok || len(from) == 0 {
-		f, ok = m.addrHeader[HeaderFrom]
+		from, ok = m.addrHeader[HeaderFrom]
-		if !ok || len(f) == 0 {
+		if !ok || len(from) == 0 {
 			return "", ErrNoFromAddress
 		}
 	}
-	if ff {
+	if useFullAddr {
-		return f[0].String(), nil
+		return from[0].String(), nil
 	}
-	return f[0].Address, nil
+	return from[0].Address, nil
 }
 
 // GetRecipients returns a list of the currently set TO/CC/BCC addresses.
 func (m *Msg) GetRecipients() ([]string, error) {
-	var rl []string
+	var rcpts []string
-	for _, t := range []AddrHeader{HeaderTo, HeaderCc, HeaderBcc} {
+	for _, addressType := range []AddrHeader{HeaderTo, HeaderCc, HeaderBcc} {
-		al, ok := m.addrHeader[t]
+		addresses, ok := m.addrHeader[addressType]
-		if !ok || len(al) == 0 {
+		if !ok || len(addresses) == 0 {
 			continue
 		}
-		for _, r := range al {
+		for _, r := range addresses {
-			rl = append(rl, r.Address)
+			rcpts = append(rcpts, r.Address)
 		}
 	}
-	if len(rl) <= 0 {
+	if len(rcpts) <= 0 {
-		return rl, ErrNoRcptAddresses
+		return rcpts, ErrNoRcptAddresses
 	}
-	return rl, nil
+	return rcpts, nil
 }
 
 // GetAddrHeader returns the content of the requested address header of the Msg
-func (m *Msg) GetAddrHeader(h AddrHeader) []*mail.Address {
+func (m *Msg) GetAddrHeader(header AddrHeader) []*mail.Address {
-	return m.addrHeader[h]
+	return m.addrHeader[header]
 }
 
 // GetAddrHeaderString returns the address string of the requested address header of the Msg
-func (m *Msg) GetAddrHeaderString(h AddrHeader) []string {
+func (m *Msg) GetAddrHeaderString(header AddrHeader) []string {
-	var al []string
+	var addresses []string
-	for _, mh := range m.addrHeader[h] {
+	for _, mh := range m.addrHeader[header] {
-		al = append(al, mh.String())
+		addresses = append(addresses, mh.String())
 	}
-	return al
+	return addresses
 }
 
 // GetFrom returns the content of the From address header of the Msg
@@ -654,8 +655,8 @@ func (m *Msg) GetBccString() []string {
 }
 
 // GetGenHeader returns the content of the requested generic header of the Msg
-func (m *Msg) GetGenHeader(h Header) []string {
+func (m *Msg) GetGenHeader(header Header) []string {
-	return m.genHeader[h]
+	return m.genHeader[header]
 }
 
 // GetParts returns the message parts of the Msg
@@ -669,8 +670,8 @@ func (m *Msg) GetAttachments() []*File {
 }
 
 // SetAttachements sets the attachements of the message.
-func (m *Msg) SetAttachements(ff []*File) {
+func (m *Msg) SetAttachements(files []*File) {
-	m.attachments = ff
+	m.attachments = files
 }
 
 // UnsetAllAttachments unset the attachments of the message.
@@ -684,8 +685,8 @@ func (m *Msg) GetEmbeds() []*File {
 }
 
 // SetEmbeds sets the embeds of the message.
-func (m *Msg) SetEmbeds(ff []*File) {
+func (m *Msg) SetEmbeds(files []*File) {
-	m.embeds = ff
+	m.embeds = files
 }
 
 // UnsetAllEmbeds unset the embeds of the message.
@@ -700,16 +701,16 @@ func (m *Msg) UnsetAllParts() {
 }
 
 // SetBodyString sets the body of the message.
-func (m *Msg) SetBodyString(ct ContentType, b string, o ...PartOption) {
+func (m *Msg) SetBodyString(contentType ContentType, content string, opts ...PartOption) {
-	buf := bytes.NewBufferString(b)
+	buffer := bytes.NewBufferString(content)
-	w := writeFuncFromBuffer(buf)
+	writeFunc := writeFuncFromBuffer(buffer)
-	m.SetBodyWriter(ct, w, o...)
+	m.SetBodyWriter(contentType, writeFunc, opts...)
 }
 
 // SetBodyWriter sets the body of the message.
-func (m *Msg) SetBodyWriter(ct ContentType, w func(io.Writer) (int64, error), o ...PartOption) {
+func (m *Msg) SetBodyWriter(contentType ContentType, writeFunc func(io.Writer) (int64, error), opts ...PartOption) {
-	p := m.newPart(ct, o...)
+	p := m.newPart(contentType, opts...)
-	p.w = w
+	p.w = writeFunc
 	m.parts = []*Part{p}
 }