Golang 1.21 is here (Part 2)
Tags: go, development, tutorial
Published: 2023-08-31 10:07:07

In this comprehensive post, I will delve into the intricacies of **maps** and **cmp** packages in the context of Go programming. I'll shed light on the standout features that have been intelligently incorporated to enhance your day-to-day experience while developing Go applications. Stay tuned for valuable insights and practical tips!


## Maps

```
	m := map[string]string{
		"name": "Pedro",
		"age":  "20",
	}

	m2 := map[string]string{
		"name": "Pedro",
		"age":  "20",
	}

	m3 := make(map[string]string)

	r := maps.Equal(m, m2)
	r2 := maps.EqualFunc(m, m2, func(s1, s2 string) bool {
		return m["name"] == m2["name"] && m["age"] == m2["age"]
	})

	fmt.Println("Equal: ", r)
	fmt.Println("Equal Func: ", r2)

	cloned := maps.Clone[map[string]string](m)
	maps.Copy[map[string]string](m3, m)

	fmt.Printf("Cloned: %+v: \n", cloned)
	fmt.Printf("Copied: %+v: \n", m3)
```

In the presented code snippet, we can observe the introduction of some remarkably useful functions for maps. When using **copy** it generates a shallow clone of the chosen map, when use **clone** it generates a full copy of the the map. This becomes incredibly advantageous when the aim is to duplicate a map variable while preserving the integrity of the original data.

The result of the previous code is:

```
Equal:  true
Equal Func:  true
Cloned: map[age:20 name:Pedro] 
Copied: map[age:20 name:Pedro] 
```

You can also check the code [here](https://gist.github.com/pedrobertao/5d11c8ff0f3de6f8878640620ea9f439)

## Cmp

From the documentation, it is simple as:

> Package cmp provides types and functions related to comparing ordered values.

It's crucial to grasp that the cmp functions exclusively operate with [ordered types constraints](https://pkg.go.dev/cmp@master#Ordered), adding a layer of convenience for mathematical operations and more.

Here is the code of two functions available in the cmp package

```
	var num, num2, num3 int64 = 1, 2, 1
	var str, str2, str3 = "ab", "abc", "ab"

	r := cmp.Compare[int64](num, num2)
	r2 := cmp.Compare[int64](num, num3)

	r3 := cmp.Less[string](str, str2)
	r4 := cmp.Less[string](str, str3)

	fmt.Println("Num is less than Num2: ", r <= 0)
	fmt.Println("Num is equal to Num3: ", r2 >= 0)
	fmt.Println("Num2 is greater than Num: ", r2 >= 0)
	fmt.Println("")
	fmt.Println("Str is less than Str2: ", r3)
	fmt.Println("Str is less than Str3 ", r4)
```
With the result


```
Num is less than Num2:  true
Num is equal to Num3:  true
Num2 is greater than Num:  true

Str is less than Str2:  true
Str is less than Str3  false
```

When using **cmp.Compare** it will return -1,0,1 which means from the documentation:

> -1 if x is less than y,
 0 if x equals y,
+1 if x is greater than y.

When employing **cmp.Less**, it evaluates whether the first value is less than or equal to the second. This utility proves highly beneficial for tackling algorithmic challenges.

You can check the code [here](https://gist.github.com/pedrobertao/3f7b32dcbeacefdfa7ede2f64270bfdf)


And that concludes this post. In our next installment, we'll wrap up with discussions on slices packages. Stay tuned!

[Part three](https://dev.to/pedrobertao/golang-121-is-here-part-3-11j)