5 |
6 | ## Formatting Strings
7 | I asked [Claude](https://claude.ai) how to format strings in Rust. It introduced me to the `format!` macro.
8 |
9 | Here is what Claude had to say.
10 |
11 | In Rust, there are several ways to format strings. I'll show you the most common methods:
12 |
13 | 1. Using `format!` Macro
14 | ```rs
15 | let name = "Alice";
16 | let age = 30;
17 | let formatted = format!("My name is {} and I am {} years old", name, age);
18 | println!("{}", formatted);
19 | ```
20 |
21 | 2. Using Positional Arguments
22 | ```rs
23 | let formatted = format!("First: {0}, Second: {1}, First again: {0}", "hello", "world");
24 | ```
25 |
26 | 3. Named Parameters
27 | ```rs
28 | let formatted = format!("Name: {name}, Age: {age}", name="Bob", age=25);
29 | ```
30 |
31 | 4. Specifying Formatting Traits
32 | ```rs
33 | // Debugging format
34 | let debug_str = format!("Debug: {:?}", vec![1, 2, 3]);
35 |
36 | // Precision for floating-point numbers
37 | let pi = 3.14159;
38 | let precise = format!("Pi to two decimal places: {:.2}", pi);
39 | ```
40 |
41 | 5. Padding and Alignment
42 | ```rs
43 | let padded = format!("{:10}", "hi"); // Right-aligned, width 10
44 | let left_aligned = format!("{:<10}", "hi"); // Left-aligned, width 10
45 | let zero_padded = format!("{:0>5}", 42); // Zero-padded to width 5
46 | ```
47 |
48 | The `format!` macro is versatile and allows you to create formatted strings without printing them, while `println!` directly prints to the console. The syntax is consistent across these methods, making string formatting in Rust quite flexible and powerful.
49 |
--------------------------------------------------------------------------------
/content/index.md:
--------------------------------------------------------------------------------
1 | ## Recent Posts
2 | 0. [Trying Neovim](/post/trying-neovim) *12/13/2024*
3 | 1. [Async Rust](/post/async-rust) *12/14/2024*
4 | 2. [Formatting Strings in Rust](/post/formatting-strings-in-rust) *12/15/2024*
5 | 3. [Random Numbers in Rust](/post/random-numbers-in-rust) *12/15/2024*
6 | 4. [How I Generate This Site](/post/how-i-generate-this-site) *12/15/2024*
7 | 5. [Structs, Traits, and Enums in Rust](/post/structs-traits-and-enums-in-rust) *12/15/2024*
8 | 6. [Rust Hyper](/post/rust-hyper) *12/16/2024*
9 | 7. [Iterators in Rust](/post/iterators-in-rust) *12/17/2024*
10 | 8. [Rust Lifetimes](/post/rust-lifetimes) *12/18/2024*
11 | 9. [Rust Generics](/post/rust-generics) *12/19/2024*
12 | 10. [Rust Blanket Implementations](/post/rust-blanket-implementations) *12/20/2024*
13 |
14 | ## Welcome,
15 |
16 | My name is Phillip England, and I am passionate about programming. This website is my notebook. Here, I will be documenting my software development educational journey.
17 |
18 | I began coding in 2019 when I became interested in making a website. I still remember when I ran my first for loop in the browser console. Since then, I've been programming as a hobby. Around 3 years ago, I ramped up my learning and have been waking up at 4AM to study.
19 |
20 | A while back, I thought to myself, "I would probably keep coding even if it was never a career for me." That's when I knew I needed to start documenting my learning. There is a chance this is a craft I keep with me for a lifetime regardless of my professional endeavours.
21 |
22 | That in and of itself might be worth something.
23 |
24 | ## Learning Wishlist
25 | When I think to myself, "I need to learn that!", I will document the thought here.
26 |
27 | - Learn about blanket implementations in Rust. They basically allow you to create methods which apply to a multitude of types. I discovered this idea when starting my string parsing lib, `stur`.
28 |
--------------------------------------------------------------------------------
/static/img/logo-dark.svg:
--------------------------------------------------------------------------------
1 |
2 |
36 |
--------------------------------------------------------------------------------
/templates/root.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
24 |
25 | {{ .Title }}
26 |
27 |
28 |
29 | {{ template "header" . }}
30 | {{ template "social" . }}
31 | {{ template "nav" . }}
32 | {{ template "overlay" . }}
33 |
34 |
5 |
6 | ## Generating Random Numbers
7 | I asked [Calude](https://claude.ai) how to generate random numbers in Rust. Here is the response:
8 |
9 | I'll show you how to generate random numbers in Rust using the rand crate, which is the most common way to generate random numbers in Rust.
10 | First, you'll need to add the rand crate to your Cargo.toml file:
11 | ```toml
12 | [dependencies]
13 | rand = "0.8.5"
14 | ```
15 |
16 | Here are different ways to generate random numbers:
17 |
18 | 1. Generating a Random Integer
19 | ```rs
20 | use rand::Rng;
21 |
22 | fn main() {
23 | let mut rng = rand::thread_rng();
24 |
25 | // Random integer between 1 and 10
26 | let random_number = rng.gen_range(1..=10);
27 | println!("Random number: {}", random_number);
28 | }
29 | ```
30 |
31 | 2. Generating a Random Float
32 | ```rs
33 | use rand::Rng;
34 |
35 | fn main() {
36 | let mut rng = rand::thread_rng();
37 |
38 | // Random float between 0.0 and 1.0
39 | let random_float = rng.gen::();
40 | println!("Random float: {}", random_float);
41 |
42 | // Random float in a specific range
43 | let random_range_float = rng.gen_range(0.0..10.0);
44 | println!("Random float in range: {}", random_range_float);
45 | }
46 | ```
47 |
48 | 3. Random Boolean
49 | ```rs
50 | use rand::Rng;
51 |
52 | fn main() {
53 | let mut rng = rand::thread_rng();
54 |
55 | let random_bool = rng.gen_bool(0.5); // 50% true, 50% false
56 | println!("Random boolean: {}", random_bool);
57 | }
58 | ```
59 |
60 | 4. Random Choice from a Collection
61 | ```rs
62 | use rand::seq::SliceRandom;
63 |
64 | fn main() {
65 | let mut rng = rand::thread_rng();
66 |
67 | let choices = vec![1, 2, 3, 4, 5];
68 |
69 | // Random element
70 | if let Some(chosen) = choices.choose(&mut rng) {
71 | println!("Randomly chosen: {}", chosen);
72 | }
73 |
74 | // Shuffling a vector
75 | let mut nums = vec![1, 2, 3, 4, 5];
76 | nums.shuffle(&mut rng);
77 | println!("Shuffled vector: {:?}", nums);
78 | }
79 | ```
80 |
81 | 5. Random Distribution (Noraml/Gaussian)
82 | ```rs
83 | use rand::distributions::{Normal, Distribution};
84 |
85 | fn main() {
86 | let mut rng = rand::thread_rng();
87 |
88 | // Normal distribution with mean 0.0 and standard deviation 1.0
89 | let normal = Normal::new(0.0, 1.0).unwrap();
90 | let random_gaussian = normal.sample(&mut rng);
91 | println!("Gaussian distributed number: {}", random_gaussian);
92 | }
93 | ```
94 |
95 | Key points to remember:
96 |
97 | - rand::thread_rng() creates a random number generator local to the current thread
98 | - gen_range() lets you specify a range (inclusive or exclusive)
99 | - gen() generates a random number of the specified type
100 | - Always import rand::Rng to use these methods
101 |
102 | Each time you run the program, you'll get different random numbers. The rand crate provides a robust and secure way to generate random numbers in Rust.
103 |
--------------------------------------------------------------------------------
/static/img/logo.svg:
--------------------------------------------------------------------------------
1 |
2 |
46 |
--------------------------------------------------------------------------------
/templates/social.html:
--------------------------------------------------------------------------------
1 | {{ define "social" }}
2 |
5 |
6 | ## Easy Peasy
7 | It really is. Using [flint](https://github.com/phillip-england/flint), I run `flint spark`. The following is the resulting output, which walks you through each step flint takes as it bundles up your static assets.
8 |
9 | ```bash
10 |
11 | ########## ## ## ### ## ########
12 | ## ## #### ## ##
13 | ####### ## ## ## ## ## ##
14 | ## ## ## ## ## ## ##
15 | ## ## ## ## ## ## ##
16 | ## ## ## ## ## ##
17 | ## ######### ## #### ##
18 | -------------------------------------------------
19 | Language-Agnostic Static Sites
20 | -------------------------------------------------
21 | 🔥 sparking flint
22 | 🗃️ searching for flint.json
23 | 🔎 parsing routes from flint.json
24 | 🏹 making an http request to each route
25 | 🔨 generating static html assests
26 | 🗑️ removing ./out
27 | ✍️ writing minified, static html to ./out
28 | 🖌️ copying over minified, static assests from ./static
29 | ✏️ copying over the favicon from ./favicon.ico to ./out
30 | ⚠️ Favicon does not exist at: ./favicon.ico
31 | 📚 your assets have been bundled at ./out
32 | 🙏 thank you for using flint
33 | ⭐ dont forget to give me star at: https://github.com/phillip-england/flint
34 | ```
35 |
36 | ## Why Flint?
37 | You see, I found myself repeating a common pattern in my web applications. I consider myself fairly effecient with Go, and I can get a web server up and running with some html pages quickly.
38 |
39 | I don't want to be locked into a certain way of doing things.
40 |
41 | That's why I built flint, a minimal static site generator for people who can already get their static site running on a localhost server.
42 |
43 | Why use some big static site generator when you might not have to?
44 |
45 | ## Follow Along
46 | I can explain how `flint` works, but it's probably easier if you just follow along. Below, I will walk you through how to install this website, install flint, and use flint to generate a minified, static version of this website.
47 |
48 |
49 | ## Install This Website
50 | Clone the repo:
51 | ```bash
52 | git clone https://github.com/phillip-england/portfolio-site
53 | ```
54 |
55 | You'll need `go` version `1.23.3` or later.
56 |
57 | Once installed, `cd` into the project and serve it:
58 | ```bash
59 | cd portfolio-site
60 | go run main.go
61 | ```
62 |
63 | Okay, now we can leave this application running in the background.
64 |
65 | ## Installing Flint
66 | In a new terminal, clone the repo:
67 | ```bash
68 | git clone https://github.com/phillip-england/flint
69 | ```
70 |
71 | Then install:
72 | ```bash
73 | cd flint
74 | go install
75 | ```
76 |
77 | You'll need to verify `go` properly installed the binary on your `PATH`. After, reload your terminal to ensure the changes take effect.
78 |
79 | To verify installation, run `flint help`.
80 |
81 | ## flint.json
82 | Inside of `portfolio-site` you should see a `flint.json`. Go ahead and take a look:
83 |
84 | ```json
85 | {
86 | "host": "http://localhost:8080",
87 | "static": "./static",
88 | "favicon": "./favicon.ico",
89 | "out": "./out",
90 | "target": "https://phillip-england.com",
91 | "routes": [
92 | "/",
93 | "/posts",
94 |
95 | ... more routes
96 | ]
97 | }
98 | ```
99 |
100 | This config tells flint where to ping, which routes to ping, and where all the static assets are located. It also tells flint where the website will be deployed so all `href` values can be changed to absolute paths pointing towards the deployment location.
101 |
102 | ## Generating The Site
103 | Navigate back to the `portfolio-site` and make sure it is still running in the background on `localhost:8080`.
104 |
105 | Once you've ensured the website is still running locally, run the following command from within `portfolio-site`:
106 | ```bash
107 | flint spark
108 | ```
109 |
110 | Afterward, you should see a new directory named `./out` at `/portfolio-site/out`.
111 |
112 | This directory contains all the static assets for the site and can easily be dropped into any static deployment environment.
113 |
--------------------------------------------------------------------------------
/main.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "fmt"
5 | "html/template"
6 | "io/fs"
7 | "net/http"
8 | "path/filepath"
9 | "strings"
10 |
11 | "github.com/PuerkitoBio/goquery"
12 | "github.com/phillip-england/vbf"
13 | )
14 |
15 | const KeyTemplates = "KEYTEMPLATES"
16 |
17 | func main() {
18 |
19 | mux, gCtx := vbf.VeryBestFramework()
20 |
21 | strEquals := func(input string, value string) bool {
22 | return input == value
23 | }
24 |
25 | funcMap := template.FuncMap{
26 | "strEquals": strEquals,
27 | }
28 |
29 | templates, err := vbf.ParseTemplates("./templates", funcMap)
30 | if err != nil {
31 | panic(err)
32 | }
33 |
34 | vbf.SetGlobalContext(gCtx, KeyTemplates, templates)
35 | vbf.HandleStaticFiles(mux)
36 | vbf.HandleFavicon(mux)
37 |
38 | vbf.AddRoute("GET /", mux, gCtx, func(w http.ResponseWriter, r *http.Request) {
39 | if r.URL.Path == "/" {
40 | templates, _ := vbf.GetContext(KeyTemplates, r).(*template.Template)
41 | mdContent, err := vbf.LoadMarkdown("./content/index.md", "dracula")
42 | if err != nil {
43 | fmt.Println(err.Error())
44 | w.WriteHeader(500)
45 | return
46 | }
47 | vbf.ExecuteTemplate(w, templates, "root.html", map[string]interface{}{
48 | "Title": "phillip england",
49 | "Content": template.HTML(mdContent),
50 | "ReqPath": r.URL.Path,
51 | "PostName": "[phillip england]",
52 | "SubText": "learning in public",
53 | "ImagePath": "/static/img/me2.jpg",
54 | "DateWritten": "🎂 born on 12/9/2024",
55 | })
56 | } else {
57 | vbf.WriteString(w, "404 not found")
58 | }
59 | }, vbf.MwLogger)
60 |
61 | vbf.AddRoute("GET /posts", mux, gCtx, func(w http.ResponseWriter, r *http.Request) {
62 | templates, _ := vbf.GetContext(KeyTemplates, r).(*template.Template)
63 | mdContent, err := vbf.LoadMarkdown("./content/posts.md", "dracula")
64 | if err != nil {
65 | fmt.Println(err.Error())
66 | w.WriteHeader(500)
67 | return
68 | }
69 | vbf.ExecuteTemplate(w, templates, "root.html", map[string]interface{}{
70 | "Title": "phillip england",
71 | "Content": template.HTML(mdContent),
72 | "ReqPath": r.URL.Path,
73 | "PostName": "[posts]",
74 | "SubText": "see what i've been learning about",
75 | "ImagePath": "/static/img/posts.webp",
76 | "DateWritten": "🎂 born on 12/9/2024",
77 | })
78 | }, vbf.MwLogger)
79 |
80 | filepath.Walk("./content", func(path string, info fs.FileInfo, err error) error {
81 | if !strings.Contains(path, "/post/") {
82 | return nil
83 | }
84 | parts := strings.Split(path, "/")
85 | if len(parts) == 0 {
86 | return nil
87 | }
88 | lastPart := parts[len(parts)-1]
89 | moreParts := strings.Split(lastPart, ".")
90 | if len(moreParts) < 3 {
91 | return nil
92 | }
93 | index := moreParts[0]
94 | title := moreParts[1]
95 | extension := moreParts[2]
96 | if extension != "md" {
97 | return nil
98 | }
99 | imagePath := "/static/img/post/"+index+".webp"
100 | appPath := "/post/"+title
101 | vbf.AddRoute("GET "+appPath, mux, gCtx, func(w http.ResponseWriter, r *http.Request) {
102 | templates, _ := vbf.GetContext(KeyTemplates, r).(*template.Template)
103 | mdContent, err := vbf.LoadMarkdown("/"+path, "dracula")
104 | if err != nil {
105 | fmt.Println(err.Error())
106 | w.WriteHeader(500)
107 | return
108 | }
109 | doc, err := goquery.NewDocumentFromReader(strings.NewReader(mdContent))
110 | if err != nil {
111 | fmt.Println(err.Error())
112 | w.WriteHeader(500)
113 | return
114 | }
115 | metaDataElm := doc.Find("#meta-data")
116 | var subText string
117 | var dob string
118 | metaDataElm.Find("*").Each(func(i int, sel *goquery.Selection) {
119 | key, _ := sel.Attr("key")
120 | if key == "subtext" {
121 | val, _ := sel.Attr("value")
122 | subText = val
123 | }
124 | if key == "dob" {
125 | val, _ := sel.Attr("value")
126 | dob = val
127 | }
128 | })
129 | vbf.ExecuteTemplate(w, templates, "root.html", map[string]interface{}{
130 | "Title": "phillip england",
131 | "Content": template.HTML(mdContent),
132 | "ReqPath": r.URL.Path,
133 | "PostName": "["+ strings.ReplaceAll(title, "-", " ") +"]",
134 | "SubText": subText,
135 | "ImagePath": imagePath,
136 | "DateWritten": "written " +dob,
137 | })
138 | }, vbf.MwLogger)
139 | return nil
140 | })
141 |
142 | err = vbf.Serve(mux, "8080")
143 | if err != nil {
144 | panic(err)
145 | }
146 |
147 | }
148 |
--------------------------------------------------------------------------------
/content/post/10.rust-blanket-implementations.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | ## Sandbox
7 | The sandbox for this article can be found [here](https://github.com/Phillip-England/sandbox-rust-blanket-implementations).
8 |
9 | My conversation with ChatGPT regarding the topics can be found [here](https://chatgpt.com/share/6766d509-bdb8-8005-a6eb-28fd226dd9e2).
10 |
11 |
12 | ## Discovery
13 | I wanted to get started working on a simple string parsing library in Rust to get my feet wet, and to build a low-level primitive tool I can bring with me into future projects.
14 |
15 | I basically want something that will allow me to do quick string operations I find myself performing frequently.
16 |
17 | [Here](https://github.com/phillip-england/purse) is a tiny Go implementation of the sort of thing I am discussing.
18 |
19 | Just some quick and dirty functions.
20 |
21 | ## Rust is Different
22 | Upon researching how to lay out the library and the best methods to ensure my users can work with both `String` and `&str`, I came across the idea of [blanket implementations](https://users.rust-lang.org/t/what-are-blanket-implementations/49904).
23 |
24 | In Go, it made sense to use functions because Go only has one string type. But since Rust has multiple string types, we need to think about how to incorporate multiple types in our library.
25 |
26 | I thought to myself, "Can I just create a trait and apply it to both `String` and `&str`?"
27 |
28 | The answer is, yes, using blanket implementations.
29 |
30 | ## Compare to Javascript
31 | I think looking at how Javascript and Rust handle this idea is important as the Javascript example is a bit more easy to digest, but it has the same underlying idea.
32 |
33 | In Javascript, let's imagine we want to take some object and extend it. Well, we could do something like this in the browser:
34 |
35 | ```js
36 | window.hello = () => {
37 | console.log('hello from the window');
38 | }
39 | ```
40 |
41 | Then, later on in our program, we may call the method like:
42 | ```js
43 | window.hello();
44 | // hello from the window
45 | ```
46 |
47 | Javascript is prototype-based and allows you to directly mutate core objects in the language.
48 |
49 | Rust does not provide us the ability to do this. So, in Rust, instead of directly altering core types, we can *extend* them using traits.
50 |
51 | ## Traits as Extensions
52 | Traits can be implemented on types in a unique variety of ways.
53 |
54 | NOTE TO SELF: Here I am again, discussing traits in Rust. Of all the features I've come across, traits seem to be one of the most fundamental building blocks of Rust.
55 |
56 | Let's first start by defining a trait we wish to implement on `&str` and `String`:
57 |
58 | ```rs
59 | pub trait SomeExtension {
60 | fn shout(&self) -> String;
61 | }
62 | ```
63 |
64 | ## The AsRef Trait
65 | Rust has a trait named, `AsRef` which can be used to implement other traits on multiple core types at once.
66 |
67 | Before we dive into how to use `AsRef` to implement `SomeExtension` on both `&str` and `String`, we should take a closer look at how `AsRef` actually works.
68 |
69 | You can find the [docs](https://doc.rust-lang.org/std/convert/trait.AsRef.html) for `AsRef` here along with a [page](https://web.mit.edu/rust-lang_v1.25/arch/amd64_ubuntu1404/share/doc/rust/html/book/first-edition/borrow-and-asref.html) that works through the `AsRef` trait versus the `Borrow` trait.
70 |
71 | One of the first things I've noticed is how the Rust standard library has a whole module called `convert` which might be useful to take a deeper dive into later. It might be a good idea to just study the standard library and see how the core Rust team codes their own data types.
72 |
73 | NOTE TO SELF: Did you take the time to study the Rust standard library?
74 |
75 | ## Implementing Our Extension
76 | Now that we know `AsRef` can be used to implement traits on multiple types in a generic way, we can use it to implement `SomeExtension` on both `&str` and `String` types.
77 |
78 | To implement `SomeExtension`, write:
79 | ```rs
80 | impl SomeExtension for T
81 | where
82 | T: AsRef,
83 | {
84 | fn shout(&self) -> String {
85 | let s = self.as_ref();
86 | format!("{}!", s.to_uppercase())
87 | }
88 | }
89 | ```
90 |
91 | Then, we can use our extension like so:
92 | ```rs
93 | fn main() {
94 | let some_str = "i am going to shout";
95 | let shout = some_str.shout();
96 | let some_string = String::from("i also shout");
97 | let shout2 = some_string.shout();
98 | println!("{} - {}", shout, shout2);
99 | }
100 | ```
101 |
102 | As you can see, `&str` and `String` can now use the `shout` method from the `MyExtension` trait.
103 |
104 | ## Conclusion
105 | Again, I am finding myself in a place where I feel the need to really dive deep into traits in Rust. They keep coming up and their generic syntax is one of the most challenging things about reading the language and getting a good mental model of it.
106 |
107 | I am thinking I skim through [The Book](https://doc.rust-lang.org/book/) over the next few days and just get some more general exposure to Rust concepts and to get better at looking at the code.
108 |
--------------------------------------------------------------------------------
/content/post/1.async-rust.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | ## Article Sandbox
7 | I will be running experiments in my own editor and will be saving the repo [here](https://github.com/phillip-england/sandbox-async-rust).
8 |
9 | ## My Experience With Rust
10 | Rust is going to be my language for 2025. I've tinkered with a low-level networking framework called [Zeke](https://github.com/Phillip-England/zeke) and I would like to continue working on that project.
11 |
12 | Since working on Zeke, I've learned a bit more about programming on an interface level, and I think those skills will help a lot.
13 |
14 | Rust has a few concepts that are challenging to me such as lifetimes and the borrow checker. But the number one thing which caused me challenges when writing zeke was multi-threaded rust.
15 |
16 | If I had a good grapse on those concepts I would feel way more comfortable in the language. I think before I start diving into all the different multi-threaded types rust provides, I need to understand it's async model better.
17 |
18 | ## Let's Get Rusty
19 | Any time I think about rust, I think about Bodgen from [Let's Get Rusty](https://www.youtube.com/@letsgetrusty) on youtube.
20 |
21 | This [video](https://www.youtube.com/watch?v=K8LNPYNvT-U) is where I am going to start.
22 |
23 | ## Futures
24 | The first big takeaway is that `async` functions in rust are just a facade over a function which returns a `Future`.
25 |
26 | ```rs
27 | async fn my_function() {
28 | println!("I'm an async function!")
29 | }
30 | ```
31 |
32 | is really just a fasade over:
33 | ```rs
34 | fn my_function() -> impl Future
7 | 
10 | 
41 |