feat: make Money exchangeable & add Lookup funcs

Update Types:

1. Money: make it exchangeable for different currencies.

New Types:

1. ExchangeableCurrency: Currency with exchange rate.

New Functions:

1. LookupCountry
2. LookupLanguage
3. LookupCurrency
3. LookupCulture

BREAKING CHANGES: use Lookup functions instead of Get functions.

Removed Get functions:

1. GetCountry
2. GetLanguage
3. GetCurrency
4. GetCulture

Author: wayn3h0

country.go

@@ -14,6 +14,12 @@ type Country struct {
 	Aliases     *MultiLanguageStringArray
 }
 
+// Eaual reports whether two countries are same.
+// It compares the alpha-2 code.
+func (x *Country) Equal(y *Country) bool {
+	return strings.EqualFold(x.Alpha2Code, y.Alpha2Code)
+}
+
 // Countries represents a sorcountryTable collection of Country.
 type Countries []*Country
 
@@ -92,7 +98,7 @@ func init() {
 			Alpha3Code:  alpha3Code,
 			NumericCode: numericCode,
 			Name:        NewMultiLanguageString(),
-			Aliases:     NewMultiLanguageStringArray("|"),
+			Aliases:     NewMultiLanguageStringArray(";"),
 		}
 
 		countryTableAlpha2[alpha2Code] = country
@@ -107,44 +113,42 @@ func AllCountries() Countries {
 	return countryList
 }
 
-// GetCountry returns the country by given keyword (code, name, alias with language).
-// It returns nil if the country not found.
-func GetCountry(language *Language, keyword string) *Country {
+// LookupCountry returns the country by given keyword (code, name, alias with language).
+func LookupCountry(language *Language, keyword string) (*Country, bool) {
 	keyword = strings.TrimSpace(keyword)
 	if len(keyword) == 0 {
-		return nil
+		return nil, false
 	}
-
+	// alpha-2 code
 	if len(keyword) == 2 {
 		if v, ok := countryTableAlpha2[strings.ToUpper(keyword)]; ok {
-			return v
+			return v, true
 		}
 	}
-
+	// alpha-3 & numeric code
 	if len(keyword) == 3 {
 		if v, ok := countryTableAlpha3[strings.ToUpper(keyword)]; ok {
-			return v
+			return v, true
 		}
 		if v, ok := countryTableNumeric[strings.ToUpper(keyword)]; ok {
-			return v
+			return v, true
 		}
 	}
-
+	// keyword
 	if language != nil {
 		for _, country := range countryList {
 			// compare name
 			name := country.Name.Value(language)
 			if strings.EqualFold(name, keyword) {
-				return country
+				return country, true
 			}
 
 			// compare aliases
 			aliases := country.Aliases.Value(language)
 			if strings.Contains(strings.ToLower(aliases), strings.ToLower(keyword)) {
-				return country
+				return country, true
 			}
 		}
 	}
-
-	return nil
+	return nil, false
 }

culture.go

@@ -16,6 +16,12 @@ type Culture struct {
 	Formatter  *Formatter
 }
 
+// Eaual reports whether two cultures are same.
+// It compares the code.
+func (x *Culture) Equal(y *Culture) bool {
+	return strings.EqualFold(x.Code, y.Code)
+}
+
 // FormatNumber formats the number to string.
 func (c *Culture) FormatNumber(number float64) string {
 	return c.Formatter.Number.Format(number)
@@ -149,16 +155,13 @@ func init() {
 		nativeName := cultureNativeNames[code]
 		countryCode := code[strings.LastIndex(code, "-")+1:]
 		languageCode := code[0:strings.Index(code, "-")]
-		country := GetCountry(nil, countryCode)
-		language := GetLanguage(languageCode)
-
+		country, _ := LookupCountry(nil, countryCode)
+		language, _ := LookupLanguage(languageCode)
 		var curr *Currency
 		if currencyCode, ok := cultureCurrencyCodes[code]; ok {
-			curr = GetCurrency(currencyCode)
+			curr, _ = LookupCurrency(currencyCode)
 		}
-
 		formatter := cultureFormatters[code]
-
 		culture := &Culture{
 			Code:       code,
 			NativeName: nativeName,
@@ -168,7 +171,6 @@ func init() {
 			Currency:   curr,
 			Formatter:  formatter,
 		}
-
 		cultureTable[strings.ToLower(code)] = culture
 		cultureList[i] = culture
 	}
@@ -179,15 +181,13 @@ func AllCultures() Cultures {
 	return cultureList
 }
 
-// GetCulture returns the culture by given code.
-// It returns nil if the culture not found.
-func GetCulture(code string) *Culture {
+// LookupCulture returns the culture by given code.
+func LookupCulture(code string) (*Culture, bool) {
 	code = strings.TrimSpace(code)
 	if len(code) > 0 {
 		if cult, ok := cultureTable[strings.ToLower(code)]; ok {
-			return cult
+			return cult, true
 		}
 	}
-
-	return nil
+	return nil, false
 }

currency.go

@@ -11,6 +11,12 @@ type Currency struct {
 	Name *MultiLanguageString
 }
 
+// Equal reports whether two currencies are same.
+// It compares the code.
+func (x *Currency) Equal(y *Currency) bool {
+	return strings.EqualFold(x.Code, y.Code)
+}
+
 // Currencies represents a sorcurrencyTable collection of Currency.
 type Currencies []*Currency
 
@@ -93,15 +99,13 @@ func AllCurrencies() Currencies {
 	return currencyList
 }
 
-// GetCurrency returns the currency by given code.
-// It returns nil if the currency not found.
-func GetCurrency(code string) *Currency {
+// LookupCurrency returns the currency by given code.
+func LookupCurrency(code string) (*Currency, bool) {
 	code = strings.TrimSpace(code)
-	if len(code) > 0 {
+	if len(code) == 3 {
 		if curr, ok := currencyTable[strings.ToUpper(code)]; ok {
-			return curr
+			return curr, true
 		}
 	}
-
-	return nil
+	return nil, false
 }

language.go

@@ -12,14 +12,10 @@ type Language struct {
 	Name       *MultiLanguageString
 }
 
-// Equal reports whether two language are same.
-// It compares the language codes.
-func (l *Language) Equal(another *Language) bool {
-	if another == nil {
-		return false
-	}
-
-	return strings.EqualFold(l.Code, another.Code)
+// Equal reports whether two languages are same.
+// It compares the code.
+func (x *Language) Equal(y *Language) bool {
+	return strings.EqualFold(x.Code, y.Code)
 }
 
 // Languages represents a sortable collection of Language.
@@ -103,15 +99,13 @@ func AllLanguages() Languages {
 	return languageList
 }
 
-// GetLanguage returns the language by given code.
-// It returns nil if the language not found.
-func GetLanguage(code string) *Language {
+// LookupLanguage returns the language by given code.
+func LookupLanguage(code string) (*Language, bool) {
 	code = strings.TrimSpace(code)
 	if len(code) > 0 {
 		if lang, ok := languageTable[strings.ToLower(code)]; ok {
-			return lang
+			return lang, true
 		}
 	}
-
-	return nil
+	return nil, false
 }