Meet Gor - Tag: go

Crossposter Agent

Sun, 15 Mar 2026 00:00:00 UTC

An AI agent for posting your thoughts to any platform. Built to automate multi-platform publishing while keeping the workflow lightweight.

GCP Log Explorer TUI

Sun, 15 Mar 2026 00:00:00 UTC

TUI for GCP's Log Explorer UI. Built to make log exploration faster from the terminal without relying on the web UI.

Printf Debugging in Go with Q

Thu, 08 Jan 2026 00:00:00 UTC

This is cool, we make logging a mess. For logs we need to have separate scripts to get relevant data. How much chaos it can be.

Building Golang from Source v1.23 and Above

Tue, 19 Nov 2024 00:00:00 UTC

## Introduction Are you excited to try out the latest golang version, or test out your changes (cooking some serious stuff?), or install some random golang version? Then let’s explore one of the easiest ways to install golang on your system (Linux). ## Building Go from source 1.23+ The process for installing and building golang from source is quite simple. * Clone the repo * Build the binary * Set Environment Variables * Export the binary to the system path For detailed other steps, you can follow [this guide](https://go.dev/doc/install/source). ### Clone the repo Just clone the repo from GitHub or Google Git repo. ```bash git clone https://github.com/golang/go OR git clone https://go.googlesource.com/go ``` This will install the golang source code required to build the golang binary and the ecosystem (gofmt + standard library + test suite). Then let’s navigate to the cloned repo and we can build the golang from the source. ### Build it We need to run the bash script in the folder to build the binary. They `all.bash` can be run to build the binary which will be stored in the `go/bin` folder `go/bin/go` and `go/bin/gofmt` files. These two binaries will be generated and are required in the Golang ecosystem. ```bash cd src ./all.bash ``` Once we have the binaries in the specified folder, we can move ahead to make the environment understand where the actual binary is located. ### Environment Variables The `GOROOT` and `GOPATH` variables are required for the golang ecosystem to work as expected. The `GOROOT` is set as the path to the actual golang source repository, the cloned repository from which we built the binary. This `GOPATH` is the path where Golang stores the external repositories or modules for use anywhere in the system. ```bash export GOROOT=path_to_clone_repo export GOPATH=$(HOME)/go export PATH=$PATH:$GOROOT/bin:$GOPATH/bin ``` The `PATH` environment needs to be updated with the `GOROOT` and `GOPATH` to make the binaries in those paths visible and accessible to the system. > NOTE: If you are installing the golang from source when you have already a version of golang installed on your system, then you need to make sure you do not mess up the `GOROOT` and `GOPATH`. > > Those could be juse set with the current shell session, as you do not want this golang version permantely on the system, if you do requrie the newly installed golang version as your default, then you can set this environment variables in your shell config. Finally, we can now set the binary as something different because we do not want it to clash with the default golang version. ### Run the binary The binary can be stored in the `/usr/local/bin/` to make any binary available in the system from anywhere. This is not necessary but handy if you are going to use it commonly but don’t need it as the default golang version. ```bash # The binary is stored in the # path_to_cloned_repo/bin # Whatever you want to name the binary cp bin/go /usr/local/bin/go-dev OR cp bin/go /usr/local/bin/go1.24 ``` Once this is done. we can check the installed golang version ```bash go1.24 version ``` With this, you can use it as go1.24 or go-dev as the binary name. So, that is how we install and build from source any golang version above 1.23. ## Conclusion For context, I wanted to check out the latest changes in 1.24, so I cloned the repo and after some trial and error of some commands to build the golang version, I was able to do it correctly. So just decided to share it here, hope you found it helpful. Thank you for reading. Happy Coding :)

Connect LibSQL Database hosted on Turso in a Golang Application

Mon, 30 Sep 2024 00:00:00 UTC

## Introduction Welcome to the new series in Golang, Let's Go with Turso. In this series, we will learn how to interact with LibSQL databases with Golang. We will connect with a remote/local LibSQL database, create Embedded replicas, set up a local LibSQL database, and so much more as we explore and find out more features of LibSQL. ## Connect a LibSQL database in a Golang application In this post, we will learn how to connect and query a LibSQL database hosted on Turso/Cloud in a Golang Application using libsql-client package. We will go from setting up golang project, installing turso-cli, creating a database on turso with the cli, connecting to the database with shell, and golang and finally, we can query the database using Golang. If you want to check out the YouTube video, check this out: [Conenct LibSQL Database hosted on Turso with Golang](https://www.youtube.com/watch?v=vBrvX0X0phw) ### Initializing a Golang project Let's start with initializing a Golang project. ```bash # go mod init // # Example go mod init github.com/mr-destructive/lets-go-with-turso ``` This will initialize the project in the current directory, creating a `go.mod` file with the specification of the Golang version and the packages that we will install and use in this module. ### Installing Turso CLI ```bash # Linux/Windows curl -sSfL https://get.tur.so/install.sh | bash curl -sSfL https://get.tur.so/install.sh | bash # macOS brew install tursodatabase/tap/turso ``` This will install the Turso CLI. To verify that Turso CLI is installed properly, you can run the version command to check the setup. ``` turso --version ``` Once it is installed, we can now log in into Turso platform, simply by running the `auth signup` or `auth login` to Register or Log-in. ``` turso auth signup # OR turso auth login ``` This will redirect to the browser for the OAuth flow, once signed up and logged in, this will allow to interact with the Turso platform with the CLI that we downloaded. To make sure we are logged in as the correct user, we can run the `auth whoami` command to get the currently logged-in user. ``` turso auth whoami ``` This will print the username if you are logged-in. If everything seems correct, we can move ahead with the database creation step. ### Creating a Remote LibSQL Database on Turso To create a LibSQL database hosted on Turso, we will use the `turso db create` command. ``` turso db create # OR turso db create ``` This will create a database with the specified name, even if you don't provide the name, it will give out a random friendly two-word name to your database. It will create a database on the nearest location available from your location. This command will output the following: ``` Created database at group default in 1.99s. Start an interactive SQL shell with the following: turso db shell To see information about the database, including a connection URL, run: turso db show To get an authentication token for the database, run: turso db tokens create ``` The next step, it shows to start an interactive shell, to see information about the database, and to generate an authentication token for the database. We will move to the next part, which would be to create an authentication token for accessing the database from an external application. ### Generating and Storing Authentication Token for LibSQL Database After we executed the `db create` command, and it created the database on the Turso cloud, there was a command hint for creating a `token` with the command `db tokens create` So, this command will create a JWT authentication token, that will be used to connect and read/write to the database. ```bash turso db tokens create # OR turso db tokens create --read-only # OR turso db tokens create --expiration 30d ``` We can use the simple `db tokens create ` to create an authentication token for the database with (read + write access). You can copy that returned token into a environment variable, or wherever your application can read that token. This could be stored in the environment variable as follows: ```bash export TURSO_AUTH_TOKEN="" ``` To make a `read-only` token, we can use the flag `--read-only`. This will be handy, if you only have a database as a local replica, and the only purpose of the database is for querying data. This will prevent any write operation on the database. We can also use the `--expiration` flag that will be used to set the duration of the token. By default the value for expiry is `never`, but that could be a little too risky if you are making a serious application. You can either set it to `7d` which will make the token expire after seven days. Now, we can get the remote database URL and connect to the database. The URL could be obtained by running the command `db show ` ``` turso db show ``` This will output the following: ```bash Name: URL: libsql://-.turso.io ID: Group: default Version: 0.24.22 Locations: bom Size: 4.1 kB Archived: No Bytes Synced: 0 B Is Schema: No Database Instances: NAME TYPE LOCATION bom primary bom ``` The above output shows the meta-information of the database. This also has the URL hosted on Turso. We can construct the URL using the name of the database and your username as `libsql://-.turso.io`, you can set this in an environment variable or in the configuration wherever you can access it from the application. To set the URL of the database in your application, you can use the `TURSO_DB_URL` environment variable. ```bash export TURSO_DATABASE_URL="libsql://-.turso.io" ``` So, we have a remote database URL, and the access token configured, these are the two pieces that we will need to connect, read and write to the libsql database. ### Installing LibSQL Client for Golang So, we can install the [libsql-client-go](https://pkg.go.dev/github.com/tursodatabase/libsql-client-go/libsql) package for Golang which will be used as an SDK in Golang to interact with a remote LibSQL database. ```bash go get github.com/tursodatabase/libsql-client-go/libsql ``` This will install the package `libsql` into the golang module. Now, we can use this in our golang application. ### Populating the LibSQL Database Moving ahead, we have a database, but it doesn't have data! So let's create some tables and insert some rows. We can use the `db shell` command to open an interactive SQL shell on a remote LibSQL database. ```bash turso db shell libsql://-.turso.io ``` This will be a default `sqlite3` like a shell, where we can execute SQL commands, like `.schema`, `.mode`, `.tables`, etc. ```bash .dump Render database content as SQL .help List of all available commands. .indexes List indexes in a table or database .mode Set output mode .quit Exit this program .read Execute commands from a file .schema Show table schemas. .tables List all existing tables in the database. ``` And definitely, we can use the normal SQL queries, to read, write and delete data from the database. #### Creating a Table First, let's create a simple table, called `posts` with columns like `id`, `title` as a `VARCHAR(100)`, `description` as a `VARCHAR(255)`, and `content` as `TEXT` which won't be `NULL`. ```sql CREATE TABLE posts ( id INTEGER PRIMARY KEY, title VARCHAR(100), description VARCHAR(255), content TEXT NOT NULL ); ``` This will create a table `posts` on the LibSQL database, yes this will mutate the primary LibSQL database which is hosted on Turso. #### Inserting Rows Now, since we have the `posts` table, we will insert some rows into the table. ```bash INSERT INTO posts (title, description, content) VALUES ('test title', 'test description', 'test content'); ``` Now, we have some rows populated in the `posts` table. We can add more tables, and rows into the database, as usual, but this is just an example, so I'll keep it short. ### Connecting to the LibSQL Database Now, we have something to query from a database, after we connect to the database via the Golang application program. First, we will grab two pieces to connect to the database. ```bash export TURSO_DATABASE_URL="libsql://-.turso.io" export TURSO_AUTH_TOKEN="" ``` Now, let's start with the Golang program code. ```go package main import ( "fmt" "os" ) func main() { dbURL := os.Getenv("TURSO_DATABASE_URL") dbToken := os.Getenv("TURSO_AUTH_TOKEN") dbUrl := fmt.Sprintf("%s?authToken=%s", dbURL, dbToken) } ``` This will be the basic config to grab the database URL and the authentication token, then we can construct the `dbURL` along with `dbToken` to construct the complete dbURL which will allow to access the database. Moving ahead, we will import `database/sql` package that will be used to open the database connection and `github.com/tursodatabase/libsql-client-go/libsql` to connect to the remote LibSQL database. ```go package main import ( "database/sql" "fmt" "os" _ "github.com/tursodatabase/libsql-client-go/libsql" ) func main() { dbURL := os.Getenv("TURSO_DATABASE_URL") dbToken := os.Getenv("TURSO_AUTH_TOKEN") dbUrl := fmt.Sprintf("%s?authToken=%s", dbURL, dbToken) db, err := sql.Open("libsql", dbUrl) if err != nil { fmt.Fprintf(os.Stderr, "failed to open db %s: %s", dbUrl, err) os.Exit(1) } defer db.Close() } ``` The `sql.Open` function will open the connection to the database, this will return a `sql.DB` object. The driver selected is `libsql` and the `dbURL` is the entire URL along with the authentication token. ```go type Post struct { Id int Title string Description string Content string } rows, err := db.Query("SELECT * FROM posts") if err != nil { fmt.Fprintf(os.Stderr, "failed to query: %s", err) os.Exit(1) } for rows.Next() { var post Post if err := rows.Scan(&post.Id, &post.Title, &post.Description, &post.Content); err != nil { fmt.Fprintf(os.Stderr, "failed to scan: %s", err) os.Exit(1) } fmt.Println(post) } defer rows.Close() ``` Now, let's query some data from the database. We can construct the `Post` struct that will be used to grab the required fields like `Id`, `Title`, `Description`, and `Content` from the `posts` table in the database. Then, we will use the `db.Query` function to query the database. This function takes in a query and returns a `sql.Rows` object. We will iterate over all the `rows` returned from the database, with the `rows.Next()` that will fetch each row. Then we can `row.Scan` the row object with the appropriate and respective fields returned in the row. In this case, the `Id`, `Title`, `Description`, and the `Content` is fetched and stored into the `post` fields. We have fetched the rows and we can do operations on them as required, this was just a basic example. So the entire code can be found below. ```go package main import ( "database/sql" "fmt" "os" _ "github.com/tursodatabase/libsql-client-go/libsql" ) type Post struct { Id int Title string Description string Content string } func main() { dbURL := os.Getenv("TURSO_DATABASE_URL") dbToken := os.Getenv("TURSO_AUTH_TOKEN") dbUrl := fmt.Sprintf("%s?authToken=%s", dbURL, dbToken) db, err := sql.Open("libsql", dbUrl) if err != nil { fmt.Fprintf(os.Stderr, "failed to open db %s: %s", dbUrl, err) os.Exit(1) } defer db.Close() rows, err := db.Query("SELECT * FROM posts") if err != nil { fmt.Fprintf(os.Stderr, "failed to query: %s", err) os.Exit(1) } for rows.Next() { var post Post if err := rows.Scan(&post.Id, &post.Title, &post.Description, &post.Content); err != nil { fmt.Fprintf(os.Stderr, "failed to scan: %s", err) os.Exit(1) } fmt.Println(post) } defer rows.Close() } ``` The output of the above code will result in all the rows present in the post table of the LibSQL database. ```bash $ go run remote.go {1 test title test description test content} {2 test title test description test content} {3 sample post libsql tutorial create db, connect, create tables, insert rows, sync} {4 test title test description test content} ``` I have added a few more rows to the post table, as you can see we have successfully connected, inserted, and read from the post table in the LibSQL database hosted on Turso. For all the code related to this article, you can check out the [Let's Go with Turso](https://github.com/mr-destructive/lets-go-with-turso) GitHub repo for all the examples and additional examples for using LibSQL with Golang. ## Conclusion So, that is a wrap for this part of the series, we have explored how to connect a remote LibSQL database hosted on Turso with Golang. In the next part of the series, we will explore how to create embedded replicas on Turso's LibSQL database in Golang. Thank you for reading this post, If you have any questions, feedback, and suggestions, feel free to drop them in the comments. Happy Coding :)

Golang: Sort Package Introduction

Mon, 15 Jan 2024 00:00:00 UTC

I have been learning Golang for around 2 years now, and I have never paid attention to the sort package, can you believe that! Where was this package hiding? The `sort` package provides convenient methods for sorting slices and user-defined collections in Go. Here's a quick overview of what it can do: ## Sorting Slices To sort a slice of builtin types like ints, strings, etc, you can simply call `sort.Slice()`: ```go nums := []int{5, 2, 6, 3, 1} sort.Slice(nums, func(i, j int) bool { return nums[i] < nums[j] }) // or // sorts.Ints(nums) fmt.Println(nums) ``` ```bash $ go run main.go [1, 2, 3, 5, 6] ``` The sort is in-place, mutating the original slice. You can customize the sort order by providing a less(i, j int) bool function. ## Sorting Struct Slices To sort a slice of custom structs, add a Len(), Less(i, j int) bool, and Swap(i, j int) method: ```go type Person struct { Name string Age int } people := []Person{ {"Bob", 30}, {"John", 20}, {"Alice", 25}, } sort.Slice(people, func(i, j int) bool { return people[i].Age < people[j].Age }) fmt.Println(person) ``` ```bash $ go run main.go [{"Name":"Alice","Age":25},{"Name":"Bob","Age":30},{"Name":"John","Age":20}] ``` This will sort people by age. ## Sorting Maps Maps are inherently unordered in Go. We can't sort them, but we can iterate them in a sorted way. We need a separate slice of keys or values(whicher required), we will sort those keys/values and iterate over them in that order.: ### Sort by Keys To sort a map by keys, we can use the `sort.Strings()` function or any other sort function as per the data structure, there are functions like [sort.Ints](https://pkg.go.dev/sort#Ints), [sort.Float64](https://pkg.go.dev/sort#Float64s), or [sort.Slice](https://pkg.go.dev/sort#Slice). We can create a new slice of keys from the map and then apply the sort on that newly created slice. After the slice of keys is created, we can iterate over it and access the map values in a order of sorted keys. ```go counts := map[string]int{ "hello": 5, "world": 2, "foo": 3, } keys := make([]string, 0, len(counts)) // extract keys for k := range counts { keys = append(keys, k) } // sort keys sort.Strings(keys) // iterate with the sorted keys slice for _, k := range keys { fmt.Println(k, counts[k]) } ``` ```bash $ go run main.go foo 3 hello 5 world 2 ``` This prints the map ordered by key. You can sort by value too. ### Sort by Value To iterate the map with sorting order of values, we can approach it in a similar way. We create a slice of keys. This time, we don't sort the keys, instead, we change the position of the slice of keys depending on the values. This changes the key order based on the sorted values in the map. By similarly iterating over the key slice, we iterate over the map in a sorted order of the values. ```go counts := map[string]int{ "hello": 5, "world": 2, "foo": 3, } keys := make([]string, 0, len(counts)) // extract keys for k := range counts { keys = append(keys, k) } // sort by value // i.e. change the order of key based on values sort order sort.SliceStable(keys, func(i, j int) bool { return counts[keys[i]] < counts[keys[j]] }) // iterate sorted for _, k := range keys { fmt.Println(k, counts[k]) } ``` ```bash $ go run main.go world 2 foo 3 hello 5 ``` The `sort.SliceStable` function is used to sort the slice in place. It takes in a slice and the less function which is the actual logic for comparison in the values. This function sorts the key elements based on the values in the map, and thereby the key slice is shuffled by the sorted order of the values in the map. The sort package is super useful for quickly organizing Go data structures. There are [Find](https://pkg.go.dev/sort#Find) which tries to return a index of the first element that satisfies a comparison condition with a flag or found or not with a boolean. There is also a [Search](https://pkg.go.dev/sort#Search) which is used specifically for searching elements in a sorted array, it also gives a first index of the occuring element. But that is a topic for another day! Thank you, Happy Coding :)

Golang: Test Output JSON

Mon, 01 Jan 2024 00:00:00 UTC

I just discovered that we can generate a JSON output of test results in Golang. I found this [here](https://youtu.be/cf72gMBrsI0?t=80). Let's take a fresh simple example. ```go package jsontest func hello() string { return "Hello, World!" } ``` ```go package jsontest import ( "testing" ) func TestHello(t *testing.T) { want := "Hello, World!" got := hello() t.Logf("got: %q", got) if got != want { t.Errorf("got: %q, want: %q", got, want) } } ``` Here, we have a function `hello` that simply returns a string, the `TestHello` function in the `jsontest` package will check if the returned string is correctly returned or not. So, we can test this with `go test ./...` command, this will give out the output in a standard output/error in text format. However, if we add the `-json` flag, we can get the output in JSON format. ```bash go test ./... -json ``` ```json {"Time":"2024-01-01T20:52:45.861974085+05:30","Action":"start","Package":"json-test"} {"Time":"2024-01-01T20:52:45.863133332+05:30","Action":"run","Package":"json-test","Test":"TestHello"} {"Time":"2024-01-01T20:52:45.863142397+05:30","Action":"output","Package":"json-test","Test":"TestHello","Output":"=== RUN TestHello\n"} {"Time":"2024-01-01T20:52:45.863148346+05:30","Action":"output","Package":"json-test","Test":"TestHello","Output":" main_test.go:10: got: \"Hello, World\"\n"} {"Time":"2024-01-01T20:52:45.863151351+05:30","Action":"output","Package":"json-test","Test":"TestHello","Output":" main_test.go:12: got: \"Hello, World\", want: \"Hello, World!\"\n"} {"Time":"2024-01-01T20:52:45.863157014+05:30","Action":"output","Package":"json-test","Test":"TestHello","Output":"--- FAIL: TestHello (0.00s)\n"} {"Time":"2024-01-01T20:52:45.863160418+05:30","Action":"fail","Package":"json-test","Test":"TestHello","Elapsed":0} {"Time":"2024-01-01T20:52:45.863411555+05:30","Action":"output","Package":"json-test","Output":"FAIL\n"} {"Time":"2024-01-01T20:52:45.863438344+05:30","Action":"output","Package":"json-test","Output":"FAIL\tjson-test\t0.001s\n"} {"Time":"2024-01-01T20:52:45.863443461+05:30","Action":"fail","Package":"json-test","Elapsed":0.001} ``` Pretty cool right? This is really useful for programmatically taking the output and parsing it to get the metrics. We can even combine with the coverage flag to get the coverage metrics as well. ```bash go test ./... -json -cover ``` ```json {"Time":"2024-01-01T21:13:30.771976961+05:30","Action":"start","Package":"jsontest"} {"Time":"2024-01-01T21:13:30.775118482+05:30","Action":"run","Package":"jsontest","Test":"TestHello"} {"Time":"2024-01-01T21:13:30.775172535+05:30","Action":"output","Package":"jsontest","Test":"TestHello","Output":"=== RUN TestHello\n"} {"Time":"2024-01-01T21:13:30.775201647+05:30","Action":"output","Package":"jsontest","Test":"TestHello","Output":" main_test.go:10: got: \"Hello, World!\"\n"} {"Time":"2024-01-01T21:13:30.775231759+05:30","Action":"output","Package":"jsontest","Test":"TestHello","Output":"--- PASS: TestHello (0.00s)\n"} {"Time":"2024-01-01T21:13:30.775253928+05:30","Action":"pass","Package":"jsontest","Test":"TestHello","Elapsed":0} {"Time":"2024-01-01T21:13:30.775269402+05:30","Action":"output","Package":"jsontest","Output":"PASS\n"} {"Time":"2024-01-01T21:13:30.776153185+05:30","Action":"output","Package":"jsontest","Output":"coverage: 100.0% of statements\n"} {"Time":"2024-01-01T21:13:30.776808599+05:30","Action":"output","Package":"jsontest","Output":"ok \tjsontest\t0.004s\tcoverage: 100.0% of statements\n" {"Time":"2024-01-01T21:13:30.777814589+05:30","Action":"pass","Package":"jsontest","Elapsed":0.006} ``` I am planning to use this in my workflow for integrating the output of the tests suite with specific tests. For running the specific tests, you can use `go test -run TestName` command, this will only run the provided test function. ```go // main.go package jsontest func hello() string { return "Hello, World!" } func add(x, y int) int { return x + y } ``` ```go // main_test.go package jsontest import ( "testing" ) func TestHello(t *testing.T) { want := "Hello, World!" got := hello() t.Logf("got: %q", got) if got != want { t.Errorf("got: %q, want: %q", got, want) } } func TestAdd(t *testing.T) { want := 2 got := add(1, 1) t.Logf("got: %d", got) if got != want { t.Errorf("got: %d, want: %d", got, want) } } ``` So, we have two test in this go module, we can run a specific test using `go test -run TestName` command as so: ```bash go test -run TestAdd -json ``` ```json {"Time":"2024-01-01T21:33:44.19397581+05:30","Action":"start","Package":"jsontest"} {"Time":"2024-01-01T21:33:44.198067398+05:30","Action":"run","Package":"jsontest","Test":"TestAdd"} {"Time":"2024-01-01T21:33:44.198150156+05:30","Action":"output","Package":"jsontest","Test":"TestAdd","Output":"=== RUN TestAdd\n"} {"Time":"2024-01-01T21:33:44.198197444+05:30","Action":"output","Package":"jsontest","Test":"TestAdd","Output":" main_test.go:19: got: 2\n"} {"Time":"2024-01-01T21:33:44.198217057+05:30","Action":"output","Package":"jsontest","Test":"TestAdd","Output":"--- PASS: TestAdd (0.00s)\n"} {"Time":"2024-01-01T21:33:44.198230965+05:30","Action":"pass","Package":"jsontest","Test":"TestAdd","Elapsed":0} {"Time":"2024-01-01T21:33:44.198241628+05:30","Action":"output","Package":"jsontest","Output":"PASS\n"} {"Time":"2024-01-01T21:33:44.19869148+05:30","Action":"output","Package":"jsontest","Output":"ok \tjsontest\t0.004s\n"} {"Time":"2024-01-01T21:33:44.198822637+05:30","Action":"pass","Package":"jsontest","Elapsed":0.005} ``` As we can see, there is only one test being executed and the output of the test is in JSON format. These are really good flags and options to have as they make the output more portable. I will be planning to use this to improve my workflow in testing and developing open source projects and personal projects as well. I am really inspired by the Teej's video of executing anything in NeoVim.

Read a Rss Feed with a URL in Golang

Fri, 11 Nov 2022 00:00:00 UTC

## Reding Rss Feed We can use golang's [encoding/xml](https://pkg.go.dev/encoding/xml) package to read a Rss feed. Though we have to be speicific of what type of structure the Rss feed has, so it is not dynamic but it works really well with structs. I have covered a few nuances of reading XML file in the [config file reading](https://www.meetgor.com/golang-config-file-read/#reading-xml-file) post of the 100 days of golang series. ### Get request to Rss feed We first need to send a `GET` request to the Rss feed, we can use the [http](https://pkg.go.dev/net/http) package to grab the response. ```go package main import ( "log" "net/http" ) func main() { url := "https://meetgor.com/rss.xml" response, err := http.Get(url) if err != nil { log.Fatal(err) } log.Println(response.Body) defer response.Body.Close() } ``` So, in the above example, we have used the `net/http` package to send a `GET` request with the [Get](https://pkg.go.dev/net/http#Get) funciton. The function takes in a string as a `URL` and returns either the object as response or an error. If there arose any error, we simply exit out of the program and log the error. If the error is `nil`, we return the response in the `response` variable. This builds up a good foundation for the next step to read the response body and fetching the actual bytes from the response. ### Fetch the content from the Link Since we have the `response` object, we can use the [io.ReadAll](https://pkg.go.dev/io#ReadAll) function to read the bytes in the response body. The function takes in the [Reader](https://pkg.go.dev/io#Reader) object in this case it is [ReadCloser](https://pkg.go.dev/io#ReadCloser) object as a http object. The function then returns the slice of bytes/int8. The slice then can be interpreted as string or other form data that can be used for parsing the xml from the response. ```go package main import ( "log" "net/http" "io" ) func main() { url := "https://meetgor.com/rss.xml" response, err := http.Get(url) if err != nil { log.Fatal(err) } data, err := io.ReadAll(response.Body) if err != nil { log.Fatal(err) } log.Println(string(data)) log.Printf("Type -> %T", data) } ``` ``` ... ... ... Type -> []uint8 ``` So, we can see that the parsed content is indeed xml, it is type casted to string from the slice of bytes. This can be further used for the parsing the text as Rss structure and fetch the required details. ## Parsing Rss with a struct We can now move into creating a struct for individual tags required in the parsing. ```go package main import ( "encoding/xml" "io" "log" "net/http" ) type Rss struct { XMLName xml.Name `xml:"rss"` Channel Channel `xml:"channel"` } type Channel struct { XMLName xml.Name `xml:"channel"` Title string `xml:"title"` Description string `xml:"description"` Item []Item `xml:"item"` } type Item struct { XMLName xml.Name `xml:"item"` Title string `xml:"title"` Link string `xml:"link"` } func main() { url := "https://meetgor.com/rss.xml" response, err := http.Get(url) if err != nil { log.Fatal(err) } data, err := io.ReadAll(response.Body) if err != nil { log.Fatal(err) } log.Println(string(data)) } ``` If you would look at the [rss feed](https://meetgor.com/rss.xml), you can see it has a structure of tags and elements. The `rss` tag is the root tag, followed by `channel` and other types of nested tags speicific for the type of information to be stored like `title` for the title in the feed, `link` for the link to the feed, etc. So, we create those as structure, the root structure is the `Rss` which we will create with a few attributes like `Channel` and the name of the current tag. In the `Rss` case the name of the tag/element is `rss`, so it is given the `xml.Name` as `xml:'rss'` in backticks indicating the type hint for the field. The next field is the `Channel` which is another type(custom type struct). We have defined `Channel` as a struct just after it that will hold information like the `title`, `description` of the website. We also have the `xml.Name` as `xml:"channel"` which indicates the current struct is representation of `channel` tag in the rss feed. Finally, we also have a custom type struct as `Item`. The `Item` struct has a few attributes like `Title`, `Link` and you can now start to see the pattern, you can customize it as per your requirements and speicifications. ```go package main import ( "encoding/xml" "io" "log" "net/http" ) type Rss struct { XMLName xml.Name `xml:"rss"` Channel Channel `xml:"channel"` } type Channel struct { XMLName xml.Name `xml:"channel"` Title string `xml:"title"` Description string `xml:"description"` Item []Item `xml:"item"` } type Item struct { XMLName xml.Name `xml:"item"` Title string `xml:"title"` Link string `xml:"link"` } func main() { url := "https://meetgor.com/rss.xml" response, err := http.Get(url) if err != nil { log.Fatal(err) } data, err := io.ReadAll(response.Body) if err != nil { log.Fatal(err) } // New Code d := Rss{} err = xml.Unmarshal(data, &d) if err != nil { log.Fatal(err) } for _, item := range d.Channel.Item { log.Println(item.Title) } } ``` ``` $ go run main.go Why and How to make and use Vim as a text editor and customizable IDE Setting up Vim for Python Setting up Vim for BASH Scripting Vim: Keymapping Guide ... ... ... Django + HTMX CRUD application PGCLI: Postgres from the terminal Golang: Closures Golang: Interfaces Golang: Error Handling Golang: Paths Golang: File Reading Golang: JSON YAML TOML (config) File Reading. ``` So, here we have initialized the `Rss` struct as empty and then used the [Unmarshal](https://pkg.go.dev/encoding/xml#Unmarshal) method in the `xml` package. The Unmarshal method will parse the data as per the type of either int, float, bool or string, any other type of data will be discarded as interface or struct. We can usually parse any valid type of data into `Unmarshal` method and it generally gives a proper expected outcome. The Unmarshal method takes in the slice of byte and the second paramter as pointer to a struct or any variable that will store the parsed xml content from the slice of byte. The function just returns the error type, either `nil` in case of no errors, and returns the actual error obejct if there arise any type of error. So we parse the `data` which is a slice of byte to the funciton and the reference to the `d` object which is a empty `Rss` object. This will get us the data in the `d` object. We can then iterate over the object as per the struct and use the perform operations like type casting or converting types, etc to get your required data back. In the above example, we simply iterate over the `d.Channel.Item` which is a list of elements of tag `item` in the rss feed. Inside the for loop, we can access the object and simply print or perform any sort of operations. I have simply printed the list of articles with titles. Links for the code available on the [100 days of golang](https://github.com/Mr-Destructive/100-days-of-golang/blob/main/scripts/files/read/config_files/xml/rss.go) GitHub repository. So, that's how we parse an XML feed in golang. Just plug and play if you have a similar type of structure of the Rss XML feed. Happy Coding :)

Golang: Interfaces

Sat, 10 Sep 2022 00:00:00 UTC

## Introduction In the 19th post of the series, we will be taking a look into interfaces in golang. Interfaces allow us to create function signatures common to different structs or types. So, we can allow multiple structs to have a common interface(method) that can have different implementations. ## What are Interfaces Interface as the name suggests is a way to create methods that are common to different structures or types but can have different implementations. It's an interface to define the method or function signatures but not the implementation. Let's take an example of `Laptop` and `Phone` having the functionality of wifi. We can connect to wifi more or the less in a similar way on both devices. The implementation behind the functionality might be different but they share the same operation. The WiFi can act as an interface for both devices to connect to the internet. ## Define an Interface To declare an interface in golang, we can use the `interface` keyword in golang. An interface is created with the type keyword, providing the name of the interface and defining the function declaration. Inside the interface which acts as a struct of general method signatures. The method signatures usually consist of the name of the function with its parameters if any and the return type of the function. ```go package main import "fmt" type Player struct { name string health int } type Mob struct { name string health int is_passive bool } type Creature interface { intro() string //attack() int //heal() int } func main() { player := Player{name: "Steve"} mob := Mob{name: "Zombie"} fmt.Println(player) fmt.Println(mob) } ``` ``` go run main.go {Steve 0} {Zombie 0 false} ``` In this above example, we have created an interface called `Creature`. There are a few structs that we have to define like `Player` and `Mob`, these two methods have a few attributes like `name` as `string` and `health` as `int` which are common in both structs but the `Mob` struct has an additional attribute `is_passive` as a `boolean` value. The `Creature` is an interface that will define certain function signatures, here we have declared `intro`, `attack`, and `heal` as the methods bound to the Creature interface. This means, that any object which satisfies the Creature interface, can define the methods associated with the interface. ## Defining Interfaces Once we have declared the interface method signatures, we can move into defining the functionality of these methods depending on the struct. If we want a different working method for different types of struct objects passed we can define those for each type of struct that we want. Here, we have two types of structs namely `Creature` and `Mob`, based on the struct we can define the `intro` method for them individually. ```go package main import "fmt" type Creature interface { intro() string attack(*int) int } type Player struct { name string health int } type Mob struct { name string health int category bool } func (p Player) intro() string { fmt.Println("Player has spawned") return p.name } func (p Player) attack(m_health *int) int { fmt.Println("Player has attacked!") *m_health = *m_health - 50 return *m_health } func (m Mob) intro() string { fmt.Printf("A wild %s has appeared! ", m.name) return m.name } func (m Mob) attack(p_health *int) int { fmt.Printf("%s has attacked you! -%d ", m.name, 30) *p_health = *p_health - 30 return *p_health } func main() { player := Player{name: "Steve", health: 100} mob := Mob{name: "Zombie", health: 140} fmt.Println(player.intro()) fmt.Println(mob.intro()) fmt.Println(mob) fmt.Println(player) fmt.Println(player.attack(&mob.health)) fmt.Println(mob.attack(&player.health)) fmt.Println(mob) fmt.Println(player) } ``` ``` go run main.go Player has spawned Steve A wild Zombie has appeared! Zombie {Zombie 140 false} {Steve 100} Player has attacked! 90 Zombie has attacked you! -30 70 {Zombie 90 false} {Steve 70} ``` As we can see, the method `intro()` is bound to both the struct depending on what struct signature is associated with the method. The method `intro` takes in the object struct associated as per the call and returns `string` as defined in the method signature. The `attack` method in the `Creature` interface is also implemented separately for the two structs. For the `Player` method, we simply take in a pointer to an integer and return an `int`. The parameter is the pointer to the mob health, and it returns the modified health. We take in a pointer to the mob or player health so as to parse in the actual value and not the copy of the value. If we modify the value, we want to reflect those changes in the actual object. So that is how we can use interfaces to construct dynamic operations on objects as well as different types of structs. We have seen a simple example of how to declare and define interfaces for given type structs. Also, we can pass by value as well as by pointers so as to define the behavior of the method whether to dynamically modify or change the values of the object associated with it. ## Examples of Interfaces There are quite some use cases of interfaces, in object-oriented programming, the above example fits the polymorphism feature quite well. The ability to reuse certain method signatures and define the functions as per requirement brings flexibility to the code structure. We will see a few examples for understanding how we can use interfaces in various ways. ### Type Switch Interface We can use an empty interface to check for the type of variable we have parsed. Using this empty interface we can create a kind of dynamic parameter to a function. ```go package main import ( "fmt" "strconv" ) func parse_int(n interface{}) int { switch n.(type) { case int: return (n).(int) * (n).(int) case string: s, _ := strconv.Atoi(n.(string)) return s case float64: return int(n.(float64)) default: return n.(int) } } func main() { num := parse_int(4) fmt.Println(num) num = parse_int("4") fmt.Println(num) num = parse_int(4.1243) fmt.Println(num) } ``` ``` go run main.go 16 4 4 ``` Here, we can see we have an interface as a parameter to the function `parse_int`, the return type is `int`, so the incoming parameter can be any valid type. But if we don't convert the given type into an appropriate int, it will result in an error as we are returning the int value of the parsed parameter. We are taking the parameter as `interface{}` which is an empty interface, this will contain the parameter parsed as an interface type. That's why we need to convert the interface object into an int or the parsed type of the interface. ### Interface Slice We can even create a slice of interfaces, which means we can initialize or group together various objects of different structs in a single slice. This might be helpful for calling functions associated with different objects via the interface very easily and in a much cleaner way. ```go package main import "fmt" type Creature interface { intro() string } type Player struct { name string health int } type Mob struct { name string health int category bool } func (p Player) intro() string { fmt.Println("Player has spawned") return p.name } func (m Mob) intro() string { var name string if m.name != "" { name = m.name } else { name = "Mob" } fmt.Printf("A wild %s has appeared! ", name) return m.name } func main() { entity := []Creature{Player{}, Mob{}, Mob{}, Player{}} for _, obj := range entity { fmt.Println(obj.intro()) } } ``` ``` Player has spawned A wild Zombie has appeared! A wild Zombie has appeared! Player has spawned ``` In the above example, we can see that the entity variable is created as a slice of interfaces `Creature`, i.e. various objects associated with the `Creature` interface can be contained in a single slice. There are 2 instances of Player and Mob each in the slice. We can further iterate over the slice as a range-based loop and thereby the functions associated with the interfaces can be called. Here, we have called the `intro` function. So, there are a lot of things that can be done with interfaces, we can create multiple interfaces for a single object struct and nest interfaces. Based on the use case of the program, interfaces can be used to reduce the boilerplate code as well as improve the readability of the code. That's it from this part. Reference for all the code examples and commands can be found in the [100 days of Golang](https://github.com/mr-destructive/100-days-of-golang/tree/main/scripts/interfaces/main.go) GitHub repository. ## Conclusion From this part of the series, we were able to understand the basics of interfaces using a few examples. We explored how interfaces can be used to bring in polymorphism in golang, also we can improve the readability of the code. The boilerplate code can be considerably reduced by using interfaces when dealing with structs and types. Hopefully, you found this post helpful and understood even the basics of interfaces in golang. Thank you for reading, if you have any queries, questions, or feedback, you can ping me on my social handles or in the comments. Happy Coding :)

Golang: Math Package

Mon, 25 Apr 2022 00:00:00 UTC

## Introduction Moving on in the 100 days of golang series, we can take a look into the math package in golang's standard library. In programming, math is quite critical aspect, we need to perform certain mathematical operations quite regularly so golang's standard library has a package for serving some quite commonly used math functions and procedures. We'll take a look at some of the basic and common functions which are available in the math package. ## Mathematical Constants We have some constants like `pi`, `e`, `Phi` already defined as constants in the math package of the standard library in golang. They have a precision till 15 digits stored in float64 values. ```go package main import ( "fmt" "math" ) func main() { fmt.Println("Pi = ", math.Pi) fmt.Println("E = ", math.E) fmt.Println("Phi = ", math.Phi) fmt.Println("Sqrt of 2 = ", math.Sqrt2) fmt.Println("Naturla Log 2 = ", math.Ln2) fmt.Println("Naturla Log 10 = ", math.Ln10) } ``` ``` $ go run basic-functions/constants.go Pi = 3.141592653589793 E = 2.718281828459045 Phi = 1.618033988749895 Sqrt of 2 = 1.4142135623730951 Naturla Log 2 = 0.6931471805599453 Naturla Log 10 = 2.302585092994046 ``` We can use these constants in trigonometric calculations and also in scientific computing. Further, you can get a list of all constants defined in the math package of the go standard library from the [documentation](https://pkg.go.dev/math#pkg-constants). ## Basic Math functions We have some quite basic and fundamental functions in the math package that can be used commonly in many programs. Let's take a look at a few of them. ### - Abs :parameters (float64) , returns float64 As the name suggest, the [Abs](https://pkg.go.dev/math#Abs) it returns the absolute result of a numbers. It takes a parameter as a float64 value and returns the absolute value of the provided number as a `float64` number. ```go package main import ( "fmt" "math" ) func main() { a := 45 b := 100 diff := a - b fmt.Println(diff) absolute_diff := math.Abs(float64(a) - float64(b)) fmt.Println(absolute_diff) } ``` ``` $ go run basic-functions/main.go -55 55 ``` As, we can see the `Abs` function takes in a float64 value and returns a absolute value of the given number that too a `float64` value. We need to cast the numbers `a` and `b` into `float64` as we have not provided the initial values and so the compiler has assigned the type to them as `int`. #### Type Casting We can caste a type into other by using the variable around the type name as `type_name(variable)`. In the above example we have converted the `int` value `45` into a `float64` as `float64(45)` which again yields `45` but as a float64 type. ```go foo := 77 fmt.Printf("Type of foo = %T ", foo) fmt.Println("foo = ", int(foo)) fmt.Println("String Cast: ", string(foo)) fmt.Println("Float Cast: ", float64(foo)) ``` Though not every type cannot be casted into due to quite oblivious reasons, for instance `77` or any other integer value (except for 0 or 1) cannot be converted into boolean value. **Hello Gopher! Just a small note, the math package almost deals with float64 types rather than int to avoid backwards compatibility to perform operations on floating point values which can be casted into integers rather than defining separate functions for decimal values and integers.** ### - Min/Max: parameters(float64) , returns float64 We can get the [minimum](https://pkg.go.dev/math#Min) and [maximum](https://pkg.go.dev/math#Max) value of the two numbers provided to the function. ```go var float64 a = 120 var float64 b = 54 minimum := math.Min(float64(a), float64(b)) maximum := math.Max(float64(a), float64(b)) fmt.Printf("Min of %v and %v is %v ", a, b, minimum) fmt.Printf("Max of %v and %v is %v ", a, b, maximum) ``` ``` $ go run basic-functions/main.go Min of 120 and 54 is 54 Max of 120 and 54 is 120 ``` ### - Pow : parameters(float64, float64) , returns float64 ### - Pow10: parameters(int) , returns float64 The [Pow](https://pkg.go.dev/math#Pow) function is used to get the exponential result of the base number. So, if we provide the values x and y, we would get the result as the number x raised to y. ```go var x float64 = 3 var y float64 = 4 z := math.Pow(x, y) z10 := math.Pow10(int(x)) fmt.Println("X ^ Y = ", z) fmt.Println("10 ^ X = ", z10) ``` ``` $ go run basic-functions/main.go X ^ Y = 81 10 ^ X = 1000 ``` We also have the [Pow10](https://pkg.go.dev/math#Pow10) function which works just like the pow function except the x value is 10 and we don't have to provide it, there is just one parameter as a integer which returns a float64 value. ### - Sqrt: parameters(float64) , returns float64 The [Sqrt](https://pkg.go.dev/math#Sqrt) function as the name suggest, it is used to get the square root value of a floating point value which returns a float64 value. ```go var k float64 = 125 sqrt_of_k := math.Sqrt(k) cbrt_of_k := math.Cbrt(k) fmt.Printf("Square root of %v = %v ", k, sqrt_of_k) fmt.Printf("Cube root of %v = %v ", k, cbrt_of_k) ``` ``` $ go run basic-functions/main.go Square root of 125 = 11.180339887498949 Cube root of 125 = 5 ``` ### - Trunc: parameters(float64) , returns float64 The [Truncate](https://pkg.go.dev/math#Trunc) function provides the way to round off a decimal value(float64) to an integer but it returns a value in `float64`. ```go var p float64 = 445.235 trunc_p := math.Trunc(p) fmt.Printf("Truncated value of %v = %v ", p, trunc_p) p = 123.678 trunc_p = math.Trunc(p) fmt.Printf("Truncated value of %v = %v ", p, trunc_p) ``` ``` $ go run basic-functions/main.go Truncated value of 445.235 = 445 Truncated value of 123.678 = 123 ``` ### - Ceil : parameters(float64) , returns float64 We also can use the [Ceil](https://pkg.go.dev/math#Ceil) function to roud up the value to the next integer value but the value is returned as `float64`. ```go var c float64 = 33.25 ceil_c := math.Ceil(c) fmt.Printf("Ceiled value of %v = %v ", c, ceil_c) c = 134.78 ceil_c = math.Ceil(c) fmt.Printf("Ceiled value of %v = %v ", c, ceil_c) ``` ``` $ go run basic-functions/main.go Ceiled value of 33.25 = 34 Ceiled value of 134.78 = 135 ``` ### - Trigonometric Functions Trigonometric functions are quite helpful that can help in intense mathematical computations in backend projects or precision dependent projects. We have functions [Sin](https://pkg.go.dev/math#Sin), [Cos](https://pkg.go.dev/math#Cos), [SinCos](https://pkg.go.dev/math#Sincos), [Tan](https://pkg.go.dev/math#Tan), hyperbolic functions in Trigonometric functions like [Sinh](https://pkg.go.dev/math#Sinh), [Cosh](https://pkg.go.dev/math#Cosh), [Tanh](https://pkg.go.dev/math#Tanh), and Inverse Trigonometric functions like [Asin](https://pkg.go.dev/math#Asin), [Asinh](https://pkg.go.dev/math#Asinh), etc. - Sin: parameters(float64) , returns float64 ```go package main import ( "fmt" "math" ) func main() { // basic trigonometric functions var x float64 = math.Pi / 2 sinx := math.Sin(x) cosx := math.Cos(x) tanx := math.Tan(x) fmt.Printf("Sin(%v) = %v ", x, sinx) fmt.Printf("Cos(%v) = %v ", x, cosx) fmt.Printf("Tan(%v) = %v ", x, tanx) // hyperbolic trigonometric functions var h float64 = math.Pi / 2 sinh := math.Sinh(h) cosh := math.Cosh(h) tanh := math.Tanh(h) fmt.Printf("Sinh(%v) = %v ", h, sinh) fmt.Printf("Cosh(%v) = %v ", h, cosh) fmt.Printf("Tanh(%v) = %v ", h, tanh) // Inverse Trigonometric functions var y float64 = -1 arc_sin := math.Asin(y) // -pi/2 radians or 90 degrees arc_cos := math.Acos(y) // pi randians or 180 degrees arc_tan := math.Atan(y) fmt.Printf("Sin^-1(%v) = %v ", y, arc_sin) fmt.Printf("Cos^-1(%v) = %v ", y, arc_cos) fmt.Printf("Tan^-1(%v) = %v ", y, arc_tan) ``` ``` $ go run basic-functions/trignometric.go Sin(1.5707963267948966) = 1 Cos(1.5707963267948966) = 6.123233995736757e-17 Tan(1.5707963267948966) = 1.6331239353195392e+16 Sinh(1.5707963267948966) = 2.3012989023072947 Cosh(1.5707963267948966) = 2.5091784786580567 Tanh(1.5707963267948966) = 0.9171523356672744 Sin^-1(-1) = -1.5707963267948966 Cos^-1(-1) = 3.141592653589793 Tan^-1(-1) = -0.7853981633974483 ``` Here we can see that the functions are working fine and giving a decently precise value. This might be enough for simple and smaller projects, though for higher precision and accuracy areas, other computations and programming is required to compute the values. ### - Exponential and Logarithmic Functions We also have the exponential and logarithmic functions defined in the math package to leverage computations realted to formulae that deal with logarithmic or exponential calculations. - Exp : parameters(flaot64) , returns float64 - Exp2 : parameters(flaot64) , returns float64 ```go package main import ( "fmt" "math" ) func main() { // exponential function var x float64 = 2 y := math.Exp(x) fmt.Println("e^x = ", y) var n float64 = 3.5 y = math.Exp2(n) fmt.Println("2^n = ", y) // Logarithmic function y = math.Log(x) fmt.Println("natural log x = ", y) n = 128 y = math.Log2(n) fmt.Println("Log2 of 100 = ", y) } ``` ``` $ go run basic-functions/expo_log.go e^x = 7.38905609893065 2^n = 11.31370849898476 natural log x = 0.6931471805599453 Log2 of 100 = 7 ``` Here, we have exponential functions such as `e^x` and `2^n` which might be useful in some common programming calculations. Also the logarithmic functions like `log x` which is natural log of x(base e), and `log2 n` which is logn to the base 2. ## The Random package The `random` sub-package in golang provides some great tools for working with random numbers and generating them. It provides exhaustive list of functions and types that help in generating pseudo random numbers. - Int : parameters() , returns int - Intn : parameters( int ) , returns int ```go package main import ( "fmt" "math/rand" ) func main() { // random integer generation x := rand.Int() fmt.Println(x) // random number generation till range for i := 0; i < 5; i++ { y := rand.Intn(10) fmt.Println(y) } } ``` ``` $ go run basic-functions/rand.go 5577006791947779410 7 7 9 1 8 ``` In the above example, we have used the [Int](https://pkg.go.dev/math/rand@go1.18.1#Int) function in the random sub-package of the math package which generates a pseudo random integer of the range dependent on the system architecture generally `int32` or `int64`. We get a huge number which is pseudo random i.e. not truly random. If you try to execute the program a couple of time, you would notice the number remains the same and we are calling it random? Well we need to dive into random numbers and seeding for a different part of the series for sure. The [Intn](https://pkg.go.dev/math/rand@go1.18.1#Intn) function also generates a pseudo random number but this time, we define the range of the upper boundary to generate them. It is not inclusive of the number provided i.e. we have provide the value `10` so the number `10` is not included in the range. It's called half open interval. It starts from 0 so the range becomes mathematically `[0, n)` if n is the number provided to the Intn function. ## The Bits package We also have a bit sub-package in the math package of the go standard library. This sub package is used for working around with bit manipulation and operations at the binary level. This is quite helpful in competitive programming , also in understanding the basics of data structures and fundamentals in computer science. - Add : parameters(uint, uint, uint) , returns uint, uint - Len : parameters(uint) , returns int - OnesCount : parameters(uint) , returns int ```go package main import ( "fmt" "math/bits" ) func main() { s, c := bits.Add(0, 9, 1) fmt.Printf("Sum = %d Carry = %d ", s, c) // (45) in decimal = (1 0 1 1 0 1) in binary var n uint = 45 length := bits.Len(n) ones_in_45 := bits.OnesCount(n) fmt.Printf("Minimum bits required to represent 45 = %d ", length) fmt.Printf("Set Bits in 45 = %d ", ones_in_45) } ``` ``` $ go run basic-functions/bit.go Sum = 10 Carry = 0 Minimum bits required to represent 45 = 6 Set Bits in 45 = 4 ``` Here, in the above example, we have used the bits sub pacakge in the math package, the [Add](https://pkg.go.dev/math/bits@go1.18.1#Add) function allows us to provide the two numbers and a carry bit on which it returns two values the sum and the carry. The sum is defined as the summation of `x + y + carry` the two numbers and the carry bit. The carry bit needs to be either 0 or 1. Also the value provided the function i.e. `x and y` need to be unsigned `uint` iorder to work with bits. We also have the [Len](https://pkg.go.dev/math/bits@go1.18.1#Len) function which returns the maximum number of bits required to represent the provided unsigned integer. We have used 45 which is equivalent to `10110` and hence the function returns `6` as teh number of bits. The [OnesCount](https://pkg.go.dev/math/bits@go1.18.1#OnesCount) Function is also similar but it returns the number of set bits(the `1` bit) in the number provided to it. We'll see this sub package in a separate section of its own. Bits is really a great pacakge to work with bits and low level manipulation of numbers in Golang. ## The Complex package The complex subpackage is really specific to the operation to the complex numbers and its operations. Using complex numbers with basic operations and trigonometric functions are provided in the package. ```go package main import ( "fmt" "math/cmplx" ) func main() { x := complex(5, 8) y := complex(3, 4) mod_x := cmplx.Abs(x) mod_y := cmplx.Abs(y) conj_x := cmplx.Conj(x) phase_x := cmplx.Phase(x) mod, phase := cmplx.Polar(x) fmt.Println("x = ", x) fmt.Println("Modulus of x = ", mod_x) fmt.Println("Modulus of y = ", mod_y) fmt.Println("Conjugate of x = ", conj_x) fmt.Println("Phase of x = ", phase_x) fmt.Printf("Polar Form : %v, %v ", mod, phase) } ``` ``` $ go run basic-functions/complex.go x = (5+8i) Modulus of x = 9.433981132056603 Modulus of y = 5 Conjugate of x = (5-8i) Phase of x = 1.0121970114513341 Polar Form : 9.433981132056603, 1.0121970114513341 ``` We have used the complex function to create complex numbers. The `cmplx` subpackage in the math package provides many functions to play with trignometric and simple operations with complex numbers. The [Abs](https://pkg.go.dev/math/cmplx@go1.18.1#Abs) function is used to get the modulus of the provided complex number. The modulus is calculated with `sqrt(x^2 + y^2)`, this gives the magnitude of the complex number. Here, we get the modulus as `9.43` as `sqrt(25 + 64)` for the complex number `5+8i`. Also, for `3+4i` the modulus becomes `sqrt(9+16)` which turns out to be `5`. The [Conjugate](https://pkg.go.dev/math/cmplx@go1.18.1#Conj) function is used to get the conjugate of the provided complex number. Also the phase or the Argument of the complex number can be obtained with the [Phase](https://pkg.go.dev/math/cmplx@go1.18.1#Phase) function. The phase is caluculated by the formula `tan^-1 (y/x)` but the angle is returned in randians. So for `x = 5+8i` the argument/Phase becomes `tan^-1( 8/5)` which is `57.995 degrees` or `1.012 radians`. We have the [Polar](https://pkg.go.dev/math/cmplx@go1.18.1#Polar) function which gives the polar form of the complex number i.e. `(modulus r, phase theta)` So this function returns two values the modulus and the argument/phase of the complex number. We have already calcualted both the values but this functions gets both of them in a single function. Quite neat, we can even ignore one value after the return of the function by using the ignore operator `_, phase := cmplx.Polar(5+7i)` to only care and get the phase/argument of the complex number or `modulus, _ := cmplx.Polar(5+7i)` to get the modulus from the complex number. So that's some basic operations on complex numbers, this might have very few use cases but it's still quite useful when needed. That's it from this part. Reference for all the code examples and commands can be found in the [100 days of Golang](https://github.com/mr-destructive/100-days-of-golang/) GitHub repository. ## Conclusion So from this section we were able to get a bit deeper introduction to the `math` package in golang's standard library. We covered some few important functions and constants in the main math package along with the glimpse of other subpackages like `rand`, `cmplx` and `bits`. We didn't get too much in detail with those sub packages as they can be explored on a separate section of their own. Hopefully, you have got a godd overview of the math package in golang which again is really important aspect in programming. Thank you for reading. If you have any questions or feedback, please let me know in the comments or on social handles. Happy Coding :)