🔔 Prelude: When writing Rust programs, Result and Option are data structures we can hardly avoid. I believe that rather than understanding their underlying mechanisms, we should first quickly figure out how to handle them.

Gift Wrapping

Actually, we don’t need to think of Option<T> and Result<T,E> as too complicated:

• Option contains the data we want, where the data type is T. However, there might be no data inside (None). But regardless, as long as what we care about is wrapped, it will be an Option.
• Result also contains the data we want, but it comes with another “restless” additional item E (Error). In fact, combinations of Result and Option are very common, such as Result<Option<T>, E>. Result provides a powerful and unified specification for Rust’s error handling.

So, how do we open the gift box…

The moment of unwrapping gifts is always exciting.

Whether it’s Option or Result, we can use unwrap() to open this package.

• If the gift box contains a normal value, everything goes smoothly, and everyone’s happy.
• But if it contains something “weird” (None or Err), the program will immediately panic and crash.

Of course, if we insist on using safer unwrapping methods (like unwrap_or, match, etc.), we can control whether the program crashes ourselves, which is very practical.

What functions do these gift boxes provide?

Let’s quickly go through the methods they provide. Detailed explanations won’t be provided here, as I believe you can look up relevant information through https://doc.rust-lang.org/std/option/ and https://doc.rust-lang.org/std/result/.

Option

Notable methods:

• map(f) provides a way to operate on inner data without unpacking, very commonly used
• expect("Hi") can display error messages when panicking, more practical than unwrap()
• ? can greatly improve code cleanliness
• is_some() and is_none() are also very useful for making decisions

Result

Compared to the intuitive and easy-to-understand Option, Result seems more “convoluted” with an additional type, but essentially it’s almost identical to Option: what to do if we didn’t get the value (possibly due to an error).

Result also has: map(f) and ?, as well as useful is_ok() and is_err()

In Result<T, E>:

• T is the type of value returned on success (e.g., file content, calculation result, etc.).
• E is the type of value returned on error (e.g., std::io::Error, custom error enum, etc.).
• Actually:
  • E can be any type, with no restrictions
  • But to use ?, facilitate debugging and printing, E usually needs to implement Debug, Display, Error, and other traits
  • Yes, E can be very complex types (carrying context, providing helper methods), or very simple error structures (like, a string). Err is just the shell that Result uses to mark “this is the error branch”, with E inside

Examples

// ===== Creating Option =====
let some_value: Option<i32> = Some(42);  // Has value
let none_value: Option<i32> = None;      // No value

// Common usage: returning from functions
fn find_number(flag: bool) -> Option<i32> {
    if flag { Some(7) } else { None }
}

// ===== Creating Result =====
let ok_value: Result<i32, String> = Ok(42);                    // Success
let err_value: Result<i32, String> = Err("Oops".to_string()); // Failure

// Common usage: returning from functions
fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err("Division by zero".to_string())
    } else {
        Ok(a / b)
    }
}

🔔 Prelude: Yes, You can always type :h to see help, for example, :h windows

Vim in not so short

Preliminaries

• When vim is not available, you can temporarily use cat or nano as alternatives
• When using a new IDE, you should first learn or configure:
  • save
  • copy / paste
  • duplicate line
  • delete word / delete line
  • line movement
  • navigate forward / back
  • undo / redo
  • page navigation (page down, page up, center to middle, etc.)
  • indent / unindent
  • multi-cursor
  • search / content search
  • input commands (Ctrl + P in VSCode, double Shift in IntelliJ, : in vim…)
  • completion, suggestion, parameter hint, hover hint
  • go to / peek definition, type, declaration, reference, implementation
  • rename symbol / refactor (if available)
  • AI controlling: toggle chat box, trigger inline chat…
  • tabs / windows management
• Use the :help command to query anything you don’t understand
• :set option? can view current settings

Windows and Tabs

Buffer: Can be understood as a temporary file. Even if this file is edited, it doesn’t mean it’s written to the actual file. We can observe buffers through windows and manage them through tabs.

1. Use commands starting with b in Ex (command line) mode for buffer operations:
   • bd buffer delete; bwipeout clears more thoroughly
   • bn or bnext switch to next buffer
   • bp or bprevious switch to previous buffer
   • ctrl + ^ switch to the last buffer

Ctrl + W window shortcuts and :sp split commands are the basics of window management. :sp can use parameters to specify files to split (open a new window for this file)

1. Ctrl + W + w cycle windows, Ctrl + W + hjkl switch focus left/down/up/right (move cursor)
2. Ctrl + W + = (make window panes equal size)
3. Ctrl + W + + Ctrl + W + Ctrl + W + < Ctrl + W + > (fine-tune window size)
4. :vsp performs vertical split, dividing into two sides
5. :resize 20 sets height to 20 lines; :vertical resize 80 sets width to 80 columns

:tabs is the basic tab management command.

1. :tabnew opens a new tab, :tabe (edit) opens a tab for editing. Can be followed by filename.
2. :tabn :tabp switch tabs, or use gt gT to switch
3. Display current buffer in new tab: :tab split
4. :tabmove move tab, for example :tabmove 2
5. Batch execution:
   • :tabdo {cmd} execute on all tabs, e.g., :tabdo set nocursorline
   • :windo {cmd} execute on each window in current tab, e.g., :windo diffthis

:only and :close are universal management methods

1. Type :close :only directly to manage windows
2. Type :tabclose :tabonly to manage tabs

Key Remapping

Here’s the key remapping configuration in VSCode vim extension:

{
"vim.leader": "<space>",
"vim.useSystemClipboard": true, // important
"vim.normalModeKeyBindings": [
    {
      "before" : ["J"],
      "after" : ["5", "j"]
    },
    {
      "before" : ["K"],
      "after" : ["5", "k"]
    },
  ],
"vim.normalModeKeyBindingsNonRecursive": [
    {
      "before" : ["<Backspace>"],
      "after" : ["x"]
    },
  ],
"vim.insertModeKeyBindingsNonRecursive": [

  ],
"vim.visualModeKeyBindingsNonRecursive": [
    {
      "before" : ["<Backspace>"],
      "after" : ["d"]
    },
  ]
}

Common key aliases:

• <Backspace>
• <C-c> -> Ctrl + C
• <A-c> -> Alt + C
• <Shift>
• <CapsLock>
• <Tab>
• <Enter>
• <Esc>
• <Cmd-> Mac specific
• <Up>
• <Down>
• <Left>
• <Right>

vim Configuration File

Use the .vimrc file in the home directory:

" This is vimscript, so use let for assignment and " for comments

nnoremap <SPACE> <Nop>
let mapleader = " "
set number

" Use system clipboard
set clipboard=unnamedplus

" Map `J` to `5j`, `K` to `5k`, `<Backspace>` to `x`
nnoremap J 5j
nnoremap K 5k
nnoremap <Backspace> x
" inoremap
" vnoremap

" nmap
" imap
" vmap
nnoremap <Enter> o<Esc>

Unbound Keys

In VSCode and other IDEs, you can return Vim-controlled keys to the IDE, since they have no use in GUI interfaces.

• Ctrl + D scroll down
• Ctrl + Z suspend Vim
• Ctrl + X decrease number at cursor by 1, in insert mode it’s completion, decrease by 1 is quite useful
• Ctrl + C can be considered
• Ctrl + F scroll forward, in insert mode used to view command history
• Ctrl + W window command, delete one word before cursor
• Ctrl + P completion
• Ctrl + S pause output
• Ctrl + Q same as Ctrl + V, only q alone is for recording macros, VSCode defaults to Add cursor below, multi-cursor editing tool
• Ctrl + Y / E scroll window up/down by 1 line
• Ctrl + T depends on situation

Quick Reference

(jut for memory, may not be accurate)

1. w -> word
2. b -> back
3. e -> end
4. H -> page head; L -> low; M -> middle
5. zz move current line to the middle position
6. Ctrl + U & Ctrl + D half screen move up & down
   • Ctrl + F & Ctrl + B full screen move forward & back
7. g -> go (sometimes obviously more than that)
   • gn go to next (matched), commonly used
   • gi go to (last) insert
   • gd go to definition
   • gf go to file
8. d -> delete (actually puts deleted content into register); sometimes means down
   • dd delete one line
9. x -> dl; X -> dh
   • s -> (x + i)
   • c -> change (d + i)
10. y -> yank
11. p -> do paste | as paragraph
12. { } -> paragraph
13. f -> find occurrence (char)
    • ; -> next occurrence
    • , -> last occurrence
    • t -> till next occurrence
    • F -> backward to occurrence
14. / -> search item with pattern
    • n -> next item
    • ? -> back search
15. u -> undo; Ctrl + R redo
16. 123… -> as line number / do multiple times
17. i -> do insert | as inner (inside); o -> open a line below; a -> append | around
18. s -> as sentence | do substitute
19. q -> record macro
20. v -> visual
21. s -> surrounding. cs{old}{new}. plugin command
    • v S{desire pair} -> surrounding by.
22. J join
23. r replace

Special Characters

1. @ -> execute register content
2. . > as current line | do repeat last change, very commonly used, for repeating edit operations
3. % -> as all lines(all contents); in normal mode represents matching symbols like {[(
4. 0 -> beginning of line
   • $ -> end of line
   • ^ first meaningful character
   • _ first meaningful character (can be operated by g etc.)
   • g_ last meaningful character
5. ; repeat last f, F, t, T command. For example, if you used f to find a character, pressing ; will continue to find the next matching character.
   • , reverse repeat
6. ' for mark navigation. For example, pressing 'a jumps to the beginning of line of mark ‘a’.
7. ``` (backtick) for mark navigation. For example, pressing ``a` jumps to the exact position of mark ‘a’.
8. ~ change char case.
9. & repeat last substitution command

Modes

1. Normal mode: Enter normal mode when first starting, press i (insert) to enter insert mode, press : to enter command input mode
2. Insert mode: Edit file, press Esc to exit.
3. Command input mode: Input commands, press Esc to exit.
4. Press v to enter visual mode, generally used for selecting paragraphs

Command Structure

1. Normal mode commands are almost based on the verb + adj(count) + obj(motion, text-object) pattern, e.g.: d3j, ca(
   • Omitting verb means cursor movement, which can actually be understood as a type of verb.
     • Example: 3j, move down 3 lines
     • Example: 0, $, these are special characters
     • Example: v3w, v only switches mode, doesn’t count as verb, but subsequent behavior without verb is treated as cursor movement
   • Special case: Omitting adj. means based on current position, or only operating on one object.
     • Example: cw, f{
   • Special case: Omitting both adj. and obj. generally means some single character/line shortcuts
     • Example: dd, yy, gg
     • Example: s, x, ~, u
2. Command line mode has almost no pattern. If anything, they can almost all be categorized as command-like modes.
   • verb + obj pattern: :set number, :r file (read file)
   • adj + verb pattern: :3,5 d
     • adj + verb + obj: :3,5 d0
   • obj pattern: :map
   • verb pattern: :w, :q
   • Special pattern (can be viewed as mode switching): :!command (execute external command)
   • Command-like pattern: :s/foo/bar/gc

Repeat Operations

• . for modifications.
• ; for f, etc.
• r means replace
• f sth -> r -> ; -> . -> ; -> . -> … : guess what will happen?
• gn for / etc. Need to operate on current search content once first, then use . to repeat.

Tips

• verb is almost never absent, omitting verb generally means movement (v provides selection function, but still needs to move to some position to trigger)
• At the same time, obj is also almost never absent, omitting obj generally means current position

When inputting commands, if you’re unclear what else to input, consider these questions:

1. Does the command have an object? E.g., w, p, s. (Specifically, line operations generally omit objects). Selection in v mode actually provides objects. Similarly, movement actions actually also provide objects. So, this part should be considered first, but input last.

2. Does the command have modifiers? If there’s a clear area to operate on, you must pay attention to modifier input. Because if not provided, it will immediately operate based on current position, very easy to cause misoperations.

3. What does the command need to do? Please treat this as the last part to think about, to control vim behavior more precisely. But when inputting commands, generally need to input first. So, input this first.

Seqs: 3 → 2 → 1

Commonly used Commands

• :w save
• :q quit
• :q! force quit without saving
• :w filename save file as filename
• :w! filename force save to filename
• :set nu :set number display line numbers, commonly used
• /word search downward (note, no :, when pressing /, command line becomes / mode)
  • Press n, N to search next/previous
  • ?word search upward
• u and :u undo
• Ctrl + R redo
• x = dl, X = dh
• s = ch

Compound Commands

• :5 d delete line 5, commonly used
• :3,5 d delete lines 3 to 5
• :$ d delete last line of document
• :% d delete all content in document
• :n move m move line n to after line m, commonly used
• :n,n+3 t m copy lines n to n+3 to after line m, commonly used
  • Summary: :n,m generally means from line n to line m
• :%s/hello/nihao/g replace all hello with nihao, similar to sed operation
  • :s/hello/nihao/g only replace in current line
• :5,8s/hello/nihao/g replace hello with nihao in lines 5-8

Common Shortcuts

Movement

1. Ctrl + O previous position, Ctrl + I next position
2. If you have Home End PageUp and PageDown keys, you can use them directly, adding Ctrl is more convenient
   1. PgUp PgDown behavior varies, specifically use with Ctrl and Shift
3. Ctrl + U and Ctrl + D half screen scroll; Ctrl + F and Ctrl + B full screen scroll
4. Ctrl + Up to beginning of line, vice versa

Normal Mode

Cursor Movement

Character-based Movement

• h l move left/right, k j move up/down, arrow keys also work
• Use f to find next character, uppercase for reverse search; using t stops before that character
  • Use ; and , to repeat forward/backward search
• ^ move to first non-whitespace position
• g_ find first non-whitespace position from end of line
• Use $ to move to end of line
• Use % to match brackets like ( { [

Word-based Movement

• w move to next word, commonly used, remember as word
• b move to beginning of current/previous word, commonly used, remember as back
• e move to end of current/next word, commonly used, remember as end
  • Uppercase W, B, E, gE for including characters after words
  • ge move to end of previous word
  • 3w can move 3 times
• Use / and ? to search for pattern, use n and N to jump to next/previous

Line-based Movement

• g is the most basic line movement command
• 0 move cursor to beginning of line, $ move cursor to end of line
• Home key to beginning of line, End key to end of line
• G (Shift+G)/gg move cursor to end/beginning of file
• Actually G is go, so you can input 500G or 500gg to locate to line 500, commonly used
  • Or directly use :line_number to locate
  • gi return to last insert location, commonly used

Block or Screen-based Movement

• { } move by paragraph
• H move to top line of screen; L move to bottom line of screen; M move to middle of screen

Mark-based Movement

• ma set mark a
• 'a jump to beginning of line of mark a
• ``a` jump to exact position of mark a
• '' jump to beginning of line of previous position, commonly used

Operation Commands

Follow {operator}{count}{motion} pattern, e.g.: d2w

• c change, d delete, y yank (copy), p paste
  • change means delete corresponding content and directly enter insert mode
• gu gU or directly press ~ to change char’s case (commonly used)
• = format, for formatting, need to set code standards in advance, e.g.:

set autoindent        " Inherit indentation from previous line
set smartindent       " Smart indentation based on syntax
set cindent           " C/C++ style indentation
set shiftwidth=4      " Move 4 spaces for each indentation operation
set tabstop=4         " Display one Tab as 4 spaces
set expandtab         " Use spaces instead of Tab

Common formatting commands:

• ==: Format current line.

• =motion: Format range specified by motion.

• =ap: Format current paragraph (ap means “a paragraph”).

• =%: Format content within brackets matching current cursor position.

• gg=G: Format entire file.

• Use >> for indentation, use > when target is provided

Text Objects (delete content of specific patterns)

Follow {operator}{a/i}{text object} pattern, e.g.: di' (delete inside ’)

• Generally used with c, d
• a -> around, i -> inside
• text-object identifiers:
  • w word
  • s sentence
  • p paragraph
  • '"[{< ` corresponding to respective special blocks
  • t tag, commonly used in html language, between ><

Copy and Delete

• yy copy current line, commonly used
• dd cut current line, commonly used
• 3dd delete 3 lines, commonly used
• p/P paste content after/before cursor, commonly used
• x delete character at cursor, X delete previous character
• r modify character at cursor
• R enter replace mode

Undo

• u undo, commonly used
• Ctrl + R redo, commonly used

Enter Insert Mode

• i enter insert mode at current position
• a enter insert mode at next character
• A enter insert mode at end of line
• o enter insert mode on next line, often used with G and End, commonly used
• s delete current character and enter insert mode
• S delete current line and enter insert mode
• cw delete next word and enter insert mode
• cb delete previous word and enter insert mode

Insert Mode

Generally use shortcuts for operations

Cursor Movement

1. Ctrl + A move cursor to beginning of line, uppercase moves to beginning of document
2. Ctrl + E move cursor to end of line

Text Operations

1. Ctrl + W: Delete one word before cursor.
2. Ctrl + U: Delete all content from current cursor position to beginning of line.
3. Ctrl + T increase indentation to the right
4. Ctrl + D decrease indentation to the left
5. Ctrl + R: Insert register content. After pressing, need to input register identifier, e.g., Ctrl + R, 0 inserts content of register 0.

Completion Features

1. Ctrl + N: Auto-complete next matching word. commonly used
2. Ctrl + P: Auto-complete previous matching word.
3. Ctrl + X, Ctrl + L: Full line completion, shows dropdown menu
4. Ctrl + X, Ctrl + N/P: Word completion based on current file.
5. Ctrl + X, Ctrl + F: Filename completion.
6. Ctrl + X, Ctrl + K: Dictionary lookup completion.

Others

1. Ctrl + C: Exit input mode. Replace Esc, commonly used
2. Ctrl + O: Temporarily switch to normal mode to execute one command, then return to input mode. commonly used
3. What if you press wrong key? In normal mode use Ctrl + O to return to previous position, meaning in input mode press Ctrl + O x2

Visual Mode

Follow {trigger v}{motion}{operator} pattern, e.g.: v2wd (select two words then delete)

• Press v for character selection, V for line selection, Ctrl + V for block selection
• Generally only used for copy-paste, operation speed is slow

: Command Mode

Batch Processing (delete, move, copy, paste)

1. :2,5d a: Delete lines 2 to 5 and save in register a
2. 0 line 0; `# Vim in a Nutshell
3. :.,+3d delete current lint & plus 3 lines
4. In visual mode，:'<,'>d means “delete selected content”
5. @: repeat last : command
   • After using q for macro recording we can use @@ repeat it
   • After @: , @@ is still available
6. :'<,'>move .
   • :m 10 move (current line) to 10 line after
7. :/ looking for last found pattern

Quick Reference

Find and Replace

• :%s/old/new/g: In entire file range, replace all strings matching old with new. Add c to ask before each replacement.
• :s/old/new/g: Replace all old with new in current line.
• :g/pattern/d: Delete all lines matching pattern.
• :'<,'>s/old/new/g: In visual mode selected range, replace all old with new.
• :'<,'>normal command: Execute normal mode command on each line selected in visual mode.

Line Operations

• :d: Delete current line (similar to dd).
• :t .+1: Copy current line and paste to next line.
• :m .+1: Move current line down one line.
• :m .-2: Move current line up two lines.
• :-3,. m .+1: Move 3 lines above current line to below current line
• :-3,.y | :.+1put: Copy above three lines, paste to next line. put creates new line, p pastes at cursor position

sed-like Command Usage

1. Replace all matching patterns at once: :%s/pattern/replacement/gc for entire file range (%), substitute (s) pattern with replacement
2. gc are flags, common flags include:
   • g: Global replacement (apply command to all lines)
   • c: Ask before each command execution.
   • i: Ignore case
   • n: Maximum number of replacements
   • p: Print results
   • v: Invert results
   • !: Pass to external tool -> %!sort will sort entire text
3. Explicitly use normal commands in Ex mode. Use norm
   • Very useful with v mode
   • Example: :'<,'>norm A!, will for content selected in v mode (‘<,’>), uniformly add a “!” at the end of lines (A)

% itself is shorthand for **`1,# Vim in a Nutshell

Tips

• Accidentally pressed Ctrl + S? Use Ctrl + Q to release
• It’s best not to use the right numeric keypad for editing, there might be key conflicts

Copy-Paste Issues

Vim editor has its own clipboard system called registers. Vim uses registers to store text, which are different from X11 clipboards. If Vim is compiled with X11 clipboard support (through +clipboard option), then you can use special registers "* and "+ to access X11’s PRIMARY and CLIPBOARD.

Paste Mode

To prevent auto-formatting from corrupting pasted content, Vim provides paste mode. Before pasting, execute :set paste command to enter paste mode, which will temporarily disable auto-indent, auto-wrap and other functions. After pasting, execute :set nopaste to return to normal mode.

You can also install some programs to access X11 clipboard, such as xclip or xsel.

Right mouse button enters visual mode?

• :set mouse-=a

Register Overview

Vim uses a set of registers as its “clipboard”. These registers can be used to save text and paste later. Each register has an identifier, which can be a single letter or special character. Here are some basics about Vim registers:

Note, to use registers, first press ", then switch to the desired register, then perform operations

To view register status, type :reg in command line mode

Basic Registers

• "" - Default register, if you don’t know where copied content went, look here
• "0 - Number 0 register. Stores content of your last yank (copy).
• "- - Small delete register. Stores content of your last delete or change that’s less than one line.
• "1 to "9 - Number registers. Store your recent delete or change history ("1 is most recent, "9 is oldest).
• "a to "z or "A to "Z - Named registers. You can use lowercase letters to store text, uppercase letters to append text to corresponding lowercase register.

Special Registers

• "* and "+ - Clipboard registers. In Vim with clipboard support (usually GUI version Vim or Vim with +clipboard feature), these two registers communicate with system clipboard:
  • "* register corresponds to X11’s PRIMARY clipboard (usually the select-to-copy one).
  • "+ register corresponds to CLIPBOARD clipboard (usually used with Ctrl+C/Ctrl+V key combinations). Most commonly used.

Using Registers

• Copy to register: You can use "ay to copy to register a, where a is the register name, y is the yank command.
  • Almost the same in visual mode
• Paste from register: To paste from register, you can use "ap to paste content of register a, where a is the register name, p is the paste command.
• In insert mode: Use Ctrl + R to call up " symbol

Using Registers in Insert Mode

Press

Ctrl + R + register name

For example

Ctrl + R + " uses default register, Ctrl + R + + uses system register.

Using Registers in Terminal

When you use Vim in terminal instead of GUI version, accessing system clipboard becomes more complex, because Vim needs to include clipboard support at compile time. You can run vim --version to see if your Vim supports clipboard (look for +clipboard or +xterm_clipboard).

If your Vim supports clipboard, you can interact with system clipboard in the following ways:

• Use "*y to copy to system’s PRIMARY clipboard.
• Use "+y to copy to system’s CLIPBOARD clipboard.
• Use "*p or "+p to paste from corresponding system clipboard to Vim.

If your Vim doesn’t have clipboard support, you won’t be able to directly access system clipboard from Vim. In this case, you need to use external programs (like xclip or xsel) to help you copy Vim register content to system clipboard, or paste from system clipboard to Vim.

External Commands

Using :! to Execute External Commands

You can use :! followed by command to execute any external command. For example, if you want to see current directory contents, you can type in Vim’s command mode:

:!ls

Using :r to Read External Command Output

If you want to insert output of sed, awk or other commands into current Vim editor text, you can use :r ! command. For example, if you want to insert ls command output at current position, you can type:

:r !ls

Using :%! to Process Entire File Content Through External Command

If you want to apply sed or awk command to entire file content and replace current file content, you can use :%! followed by corresponding command. For example, use sed command to replace all “foo” with “bar” in document:

:%!sed 's/foo/bar/g'

Partial Usage

You can also specify a range to use external command only on certain parts of the file. For example, only process lines 5 to 10 through awk command:

:5,10!awk '{print $1}'

Macro Recording

1. Use q for macro recording in normal mode
   • Give register a name, say a, the full name of this register is @a
   • Press q again to end recording after recording is complete
   • Type @a to execute macro, @@ to execute last macro, 9@a to execute macro 9 times
2. +1 operation on numbers. <C-a>, can be used with macro recording to write ordered lists:
   • 1. sth, then yyp, perform <C-a> on 1, repeat

Other Features

1. Spell check. :set spell! spelllang=en_us
2. :set rnu set relative line numbers. Convenient for jumping

🔔 Prelude: No need for digging a big hole, just use it.

Golang in short

Go is

1. A modern high-level programming language that resembles C
2. Open-source, compiled, statically typed, and memory-safe

Go has

1. Simple yet powerful package management (pulls directly from GitHub)
2. Built-in concurrency primitives
3. Garbage collection (GC)
4. Lightning-fast compilation
5. Minimal syntax
6. Cross-platform compilation

Go doesn’t have

1. Classes and inheritance
2. Function overloading
3. Implicit type conversions

I use Go to

1. Say goodbye to Java’s verbose syntax
2. Build web services and microservices
3. Handle high-concurrency scenarios

Go is perfect for

1. Web services and RESTful APIs
2. Microservices architecture
3. Network programming and distributed systems

Go might not be ideal for

1. GUI desktop applications
2. Kernel development
3. Machine learning (Python has a stronger ecosystem)

Installing Go

1. Using OS package managers
   • Linux: apt, yum, snap
   • macOS: brew
   • Windows: choco, scoop, etc.
2. Download official precompiled binaries
   • Already compiled, ready to use
   • Set up path and links manually
3. Verify with go version

Hello World

// This is a comment
/* This is
   a multiline
   comment */
package main // This is the main package

// No semicolons at line endings

import (
    "fmt"
    "math"
) // Importing other packages

const myConstant int = 0 // Constants need explicit initialization

func main() {
    fmt.Println("helloworld")
    // Package names -> lowercase
    // Lowercase in package -> myConstant -> package-private
    // Capitalized -> Println() -> exported (public)
}

Types

bool

string

int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr // Has pointers but no pointer arithmetic

byte // alias for uint8

rune // alias for int32
     // Represents a Unicode code point
     // From ancient Nordic "rune"

float32 float64

complex64 complex128

// Zero value for reference types is nil

// Type assertion
t, ok := variable.(int) // Returns two values, ok indicates success
                        // Panics if ok is not captured and type is wrong

// Type conversion
var myInt int32 = 42
myAnotherInt := int64(myInt) // Type conversion
                             // No direct conversion between bool and int
                             // Generally, single characters and numbers can convert
                             // Otherwise, only conversions within same type family

Variables and Functions

var hi bool = true // Variables outside functions must have explicit types

func myFunc(x, y int) (int, int) {
    innerHi := "hi" // Inside functions, use := for type inference
    const hiConst = "hi again" // Constants cannot use :=
    return x + 1, y + 1
}

func MapFilter[T any, R comparable](
    slice []T,
    mapper func(T) R,
    predicate func(R) bool,
) func(options ...int) (filtered []R, count int, err error) {
    // Returns a function
    return func(options ...int) (filtered []R, count int, err error) {
        // Implementation
        return
    }
}
// A complete function signature example
// Note the second func starts parameters
// The last func starts return type -> returns a function
// T is generic, R is constraint, but they're essentially the same thing

func(x int) int { return x * 2 } // Anonymous function definition

Arrays, Slices, and Maps

// Arrays - fixed length
var arr [5]int = [5]int{1, 2, 3, 4, 5}
arr2 := [...]int{1, 2, 3} // Compiler infers length

// Slices - dynamic length
var slice []int = []int{1, 2, 3}
slice2 := make([]int, 5)     // Length 5
slice3 := make([]int, 5, 10) // Length 5, capacity 10

// Maps
var m map[string]int = map[string]int{"one": 1, "two": 2}
m2 := make(map[string]int)
m2["key"] = 42

// Check if key exists
value, exists := m["key"]
if exists {
    fmt.Println(value)
}

Control Flow

// Only for loops exist
// All parts of for loop are optional
for i := 0; i < 10; i++ {
    // Loop body
}

// Infinite loop
for {
    // Equivalent to while(true)
}

// Condition loop
i := 0
for i < 10 {
    i++
}

for i, v := range expression {} // Iterate over iterables
                                // Similar to Python's for..in
                                // Directly provides index and value
                                // No enumerate function needed
                                // Use _, v to ignore index

// if statement
if v := 5; v < 6 { // Can assign in condition
    // Condition body
}

// switch statement
switch x := 5; x { // x is optional
    case 1:
        fmt.Println("one")
    case 2, 3, 4:      // Multiple values
        fmt.Println("two, three or four")
    default:
        fmt.Println("other")
}

// Type switch
switch v := x.(type) {
    case int:
        fmt.Printf("int: %d\n", v)
    case string:
        fmt.Printf("string: %s\n", v)
    default:
        fmt.Printf("unknown type\n")
}

Defer and Channels

// defer - deferred execution (stack structure, LIFO)
defer fmt.Println(1)
defer fmt.Println(2)
defer fmt.Println(3)
panic("!")

// Output order: 3 2 1 panic
// defer provides stack-based deferred execution
// panic triggers deferred functions

// channel - channels (queue structure, FIFO)
func channelExample() {
    myChan := make(chan int, 2) // Buffer size 2
    myChan <- 10 // 10 goes in
    myChan <- 20 // then 20 goes in
    took := <-myChan      // took is 10
    fmt.Println(<-myChan) // 20
}

func blockingChannel() {
    ch := make(chan int) // Unbuffered channel
    // ch <- 1           // Will block! Need another goroutine to receive

    // Correct approach
    go func() {
        ch <- 1
    }()
    fmt.Println(<-ch)
}

// Channels provide a queue-like or pipe-like structure
// FIFO

Pointers

// Go has pointers
// Useful when referencing large data
// Go's design philosophy is very close to C-family languages
// Fun fact: When passing pointers to functions, both C and Go copy the pointer
// All parameters are pass-by-value in both languages
// But C++ has completely different reference passing mechanism

func main() {
    var myPtr *int
    // var anotherPtr uintptr  // uintptr is integer type, not pointer

    i := 42
    myPtr = &i // Take address

    fmt.Println(*myPtr) // Dereference, outputs 42
    *myPtr = 43         // Modify through pointer
    fmt.Println(i)      // Outputs 43

    // No pointer arithmetic
}

Format Verbs

Reference:

String Formatting

// %[flags][width][.precision]verb

// Width and alignment
fmt.Printf("%5d\n", 42)      // "   42" right-aligned, width 5
fmt.Printf("%-5d\n", 42)     // "42   " left-aligned, width 5
fmt.Printf("%05d\n", 42)     // "00042" zero-padded

// String alignment
fmt.Printf("|%10s|\n", "hello")   // "|     hello|" right-aligned
fmt.Printf("|%-10s|\n", "hello")  // "|hello     |" left-aligned
fmt.Printf("|%10s|\n", "你好")     // "|        你好|" handles Chinese

pi := 3.14159265359

// Decimal precision
fmt.Printf("%.2f\n", pi)     // "3.14" 2 decimal places
fmt.Printf("%.4f\n", pi)     // "3.1416" 4 decimal places (rounded)
fmt.Printf("%8.2f\n", pi)    // "    3.14" width 8, 2 decimals
fmt.Printf("%08.2f\n", pi)   // "00003.14" zero-padded

// Scientific notation precision
fmt.Printf("%.3e\n", pi)     // "3.142e+00"
fmt.Printf("%.3g\n", 0.00012345)  // "0.000123" auto format

// + flag: show sign
fmt.Printf("%+d\n", 42)      // "+42"
fmt.Printf("%+f\n", -3.14)   // "-3.140000"

// # flag: show base prefix
fmt.Printf("%#x\n", 255)     // "0xff"
fmt.Printf("%#o\n", 8)       // "010"
fmt.Printf("%#b\n", 5)       // "0b101"

// Space: add space for positive numbers
fmt.Printf("% d\n", 42)      // " 42"
fmt.Printf("% d\n", -42)     // "-42"

// Making tables
fmt.Printf("%-10s %8.2f %5d\n", "Apple", 3.99, 10)
fmt.Printf("%-10s %8.2f %5d\n", "Banana", 12.5, 5)
// Output:
// Apple          3.99    10
// Banana        12.50     5

// Dynamic width and precision
width := 10
precision := 2
fmt.Printf("%*.*f\n", width, precision, pi)  // Width and precision from variables

Structs

type MyStruct struct {
    x int  // Private field (package-visible)
    Y int  // Public field (exported)
}

// No need for "->" with struct pointers, Go handles it

// Value receiver method
func (s MyStruct) myFunc(x, y int) (int, int) {
    return s.x + x, s.Y + y
}

// Pointer receiver method
func (s *MyStruct) modify(x int) {
    s.x = x  // Can modify original struct
}

// Pointer receivers can accept values and pointers
// Value receivers can also accept both, Go handles it automatically
// In a sense, pointer parameters have "broader" acceptance

// Struct tags
type User struct {
    Name string `json:"name" xml:"user-name"`
    Age  int    `json:"age,omitempty"`
    Pass string `json:"-"` // Ignore this field
}

// Reading tags with reflection
import "reflect"
field, _ := reflect.TypeOf(User{}).FieldByName("Name")
fmt.Println(field.Tag.Get("json"))  // "name"

Interfaces

// Interfaces define method signatures
// No explicit implementation needed - types automatically implement interfaces
// Interfaces can embed other interfaces

type MyInterface interface {
    myAdd(x, y int) int
}

type MyStruct struct{
    x int
    y int
}

func (s MyStruct) myAdd(x, y int) int { // Implements myAdd
    return x + y
}

// Now MyStruct implements MyInterface

// Empty interface
interface{} // or any (Go 1.18+)
// Can store any type
var x interface{} = 42
x = "hello"
x = []int{1, 2, 3}

// Empty struct
var y struct{} = struct{}{}
// Takes no memory, often used as signal

Error Handling

// error is a built-in interface
type error interface {
    Error() string
}

// Functions typically return result and error
result, err := doSomething()
if err != nil {
    fmt.Printf("couldn't convert number: %v\n", err)
    return
}

// Custom error
type MyError struct {
    msg string
}

func (e MyError) Error() string {
    return e.msg
}

// Create errors with errors package
import "errors"
err := errors.New("something went wrong")

// Format errors with fmt.Errorf
err := fmt.Errorf("invalid value: %d", value)

Concurrency

// Use go keyword to start goroutines
func main() {
    go say("world")
    say("hello")

    // Need to wait for goroutines to finish
    time.Sleep(time.Second)
}

// See Defer and Channels section for channel creation

// Sending to full channel blocks
// Receiving from empty channel blocks

// Close channel
close(myChan)
// Note: Only senders should close channels

// Use select to handle multiple channels
// Like concurrent switch
// select blocks until one case can proceed
// When multiple cases ready, randomly picks one
select {
    case v := <-ch1:
        fmt.Println("received from ch1:", v)
    case ch2 <- x:
        fmt.Println("sent to ch2")
    case <-quit:
        fmt.Println("quit")
        return
    default:
        fmt.Println("no communication")
}

// Mutex
import "sync"
var mu sync.Mutex

mu.Lock()
// Critical section
mu.Unlock()

// Use defer to ensure unlock
mu.Lock()
defer mu.Unlock()
// Critical section

// Directional channels
func send(ch chan<- int) { ch <- 42 }      // Send-only
func recv(ch <-chan int) { val := <-ch }   // Receive-only

// Check if channel is closed
v, ok := <-ch  // ok is false if channel closed and empty

Various Magic 🪄

...

// 1. Variadic functions
func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}

// Calling
sum(1, 2, 3)      // Can pass multiple
sum(1)            // Can pass one
sum()             // Can pass none

// 2. Expanding slices
numbers := []int{1, 2, 3, 4}
result := sum(numbers...)  // Expand to multiple arguments

// Common usage
slice1 := []int{1, 2}
slice2 := []int{3, 4}
combined := append(slice1, slice2...)  // Expand slice2

// 3. Array literals
arr := [...]int{1, 2, 3, 4, 5}  // Compiler calculates length, result is [5]int

// Useful with indices
arr := [...]string{
    0: "zero",
    5: "five",   // Array length is 6
}

Notes:

1. Variadic parameter must be last
2. Inside function, variadic parameter is slice type
3. Types must match when expanding

Initialization Tricks

// Initialize array with indices
arr := [10]int{0: 1, 9: 10}  // 0th is 1, 9th is 10, rest are 0

// Initialize map with keys
m := map[string]int{
    "a": 1,
    "b": 2,
}

// Partial struct initialization
type Point struct{ X, Y int }
p := Point{Y: 10}  // X is 0, Y is 10

iota Enumerations

// iota starts at 0 in each const declaration
const (
    A = iota  // 0
    B         // 1
    C         // 2
)

// Skip values
const (
    _  = iota  // 0 (skip)
    KB = 1 << (10 * iota)  // 1 << 10 = 1024
    MB         // 1 << 20 = 1048576
    GB         // 1 << 30 = 1073741824
)

// Bit flag enums
type Permission int

const (
    Read Permission = 1 << iota  // 1
    Write                        // 2
    Execute                      // 4
)

// Usage
var perm Permission = Read | Write  // Combine permissions

// Check permission
if perm&Read != 0 {
    fmt.Println("Has read permission")
}

// Add permission
perm |= Execute

// Remove permission
perm &^= Write

Type Aliases vs Type Definitions

// Type alias (Go 1.9+) - completely equivalent
type MyInt = int  // MyInt is int, interchangeable

// Type definition - creates new type
type MyInt int    // MyInt is new type, cannot assign directly

// Example
type Celsius float64
type Fahrenheit float64

var c Celsius = 100
var f Fahrenheit = 212
// f = c  // Error! Type mismatch
f = Fahrenheit(c * 9/5 + 32)  // Need explicit conversion

make vs new

new(T)      // Returns *T, zero value allocation; commonly for simple structs
make(...)   // Only for slice/map/chan, returns initialized value (not pointer)

// Examples
p := new(int)           // *int, value is 0
s := make([]int, 5)     // []int, length 5, initialized
m := make(map[string]int) // map[string]int, initialized

Go Gotchas and Important Notes

Slice Underlying Array Sharing

// Passing slice copies slice header (pointer, len, cap), shares underlying array
s := []int{1, 2, 3}
t := s[:2]         // Shares underlying array with s
s = append(s, 4)   // May trigger reallocation, t no longer shares

// Modifying shared underlying array
s := []int{1, 2, 3, 4, 5}
t := s[1:3]  // [2, 3]
t[0] = 99    // s becomes [1, 99, 3, 4, 5]

Map Randomness

// Map iteration order is random, don't rely on order
m := map[string]int{"a": 1, "b": 2, "c": 3}
for k, v := range m {
    fmt.Println(k, v)  // Order may differ each run
}

// Cannot take address of map elements
// &m["key"]  // Compile error: map values not addressable

String Bytes vs Characters

// len(string) returns byte count, not character count
s := "你好"
fmt.Println(len(s))  // 6 (3 bytes per Chinese character)

// for range string iterates by rune (UTF-8 decoded)
for i, r := range "你好" {
    fmt.Printf("%d: %c\n", i, r)  // 0: 你, 3: 好
}

// s[i] gives byte
fmt.Printf("%x\n", "你"[0])  // e4 (first byte)

// Strings are immutable, convert to []byte or []rune to modify
s := "hello"
// s[0] = 'H'  // Error!
bs := []byte(s)
bs[0] = 'H'
s = string(bs)  // "Hello"

Interface nil Pitfall

// Interface value is (type, data) pair
// When type != nil, even if data == nil, interface is not nil

type MyErr struct{}
func (e *MyErr) Error() string { return "error" }

var e error
fmt.Println(e == nil)  // true

var pe *MyErr = nil
e = pe
fmt.Println(e == nil)  // false! type=*MyErr, data=nil

Loop Variable Pitfall

// Loop variables reuse same memory location
// Be careful in goroutines/closures

// Wrong
for i, v := range []int{1, 2, 3} {
    go func() {
        fmt.Println(i, v)  // May all print 2, 3
    }()
}

// Correct: rebind
for i, v := range []int{1, 2, 3} {
    i, v := i, v  // Create new local variables
    go func() {
        fmt.Println(i, v)
    }()
}

Method Call Auto-conversion

// Compiler automatically handles value/pointer conversion

type S struct{ n int }
func (s *S) Inc() { s.n++ }  // Pointer receiver

var v S
v.Inc()    // Compiler converts to (&v).Inc()

var p = &S{}
(*p).Inc() // Works but unnecessary
p.Inc()    // Direct call

Struct Embedding (Anonymous Fields)

// Embedded field methods and properties are "promoted"

type A struct{ X int }
func (a A) Show() { fmt.Println(a.X) }

type B struct{
    A          // Anonymous embedding
    Y int
}

var b B
b.X = 1        // Direct access, equivalent to b.A.X
b.Show()       // Calls A's method

// With name conflicts, must specify explicitly
type C struct {
    A
    X int      // Shadows A.X
}
var c C
c.X = 1        // Accesses C.X
c.A.X = 2      // Accesses A.X

init Functions and Package Imports

// init() executes automatically on package load
// Order: imported package init -> current package init -> main

package main

import (
    _ "database/sql"      // Only execute init, don't use exports
    _ "github.com/go-sql-driver/mysql"  // Register MySQL driver
)

func init() {
    fmt.Println("main init")
}

func main() {
    // Database driver already registered in init
}

🔔 Prelude: I often noticed Makefile files in the root directory when browsing open-source projects on GitHub. For a long time, I thought it was some kind of sophisticated “magic tool”. So during my spare time at my internship, I decided to learn some basic syntax… only to discover that it’s actually like a “recipe” for compilation - to get a target file (the dish), you need some dependencies (ingredients) and commands (cooking instructions). Anyway, at least now I can understand it (mostly).

Make

Basic Rules

target: dependencies ..
[tab][Command]

TARGET = main
main: hello.o world.o   # will be run by default as the first target
    gcc $^ -o $(TARGET) # treat these as normal bash commands

hello.o: hello.c
    gcc -c hello.c      # -c for compile only

world.o: world.c
    gcc -c world.c

clean:                  # will not be run unless "make clean"
    rm -f $(wildcard *.o) $(TARGET)

.PHONY: clean

Common CLI Parameters

-v
-n --just-print        # Print commands without executing
-p                     # Output makefile data (lots of info)
-t --touch             # Update file timestamps without changing targets (dry run)
-q --question          # Check if target exists. Do nothing if yes, print error if no
                       # Usually used with -qp
-W --what-if <file>    # Pretend this file was just modified, trigger related rules
-B                     # Rebuild everything
-b -m                  # Used to ignore compatibility between different make versions
-debug=[option]        # Debug mode
                       # option can be: a(all), b(basic), v(verbose)
                       # i(implicit), j(jobs), m(makefile)
                       # -d = -debug=a
-e var=sth             # Override environment variable values
-h                     # Help me!
-f <file>              # Execute specific makefile
-i                     # Ignore errors
-I --include-dir <dir> # Specify make search directory
-k --keep-going        # Continue on errors, except missing dependencies
-s --silent
-j --jobs              # Parallel compilation when dependencies allow
                       # make will try to parallelize as much as possible by default

Special Syntax

$<                  # First item in dependencies
                    # Note: if target is matched via %,
                    # $< represents all matched items
$^                  # All dependencies
$?                  # All dependencies that are newer than target
$+                  # All dependencies without deduplication
$*                  # The part matched by %
$@                  # The target
$%                  # Target member name (only for archive files)
$$                  # Escape $ character
$(wildcard *.c)     # Use wildcards
$(source:.c=.o)     # Change suffix of variable

:=                  # Immediate expansion of $() expressions (no variable hoisting)
?=                  # Assign only if not already defined
+=                  # Append to variable value (with leading space)

%                   # Wildcard in pattern rules

@[command]          # Execute command silently
-[command]          # Ignore errors, continue running
[command];[command] # Similar to pipeline ("|")
                    # If written on separate lines, executed separately

override var := new-value

# $ with uppercase D(Directory) and F(File)
# Further specify the scope of dependency strings

dir/foo.o: ...

# Need parentheses to avoid ambiguity
$(@D)               # dir/foo.o -> dir
$(@F)               # dir/foo.o -> foo.o

Pattern Rules

%.o: %.c    # % means "match", represents "any string"
            # Meaning: to build .o file, its dependency is corresponding .c file
            # No directory search performed

# Study these examples for better understanding

src/eat
e%t
% -> src/a

# then, % is passed to another place...

c%r -> csrc/ar

# but if there is a nested % pattern on the original side...

c%r -> src/car  # % should be "src/a"
                # but "src/" will be removed before matching patterns
                # so in this situation, % is "a"
                # this rule also applies to the first step

Functions

# Basic syntax
$(<function> <arguments>)

# Can also be written as
${<function> <arguments>}   # Perhaps more readable

$(patsubst %.c,%.o,$(source))  # Better demonstrates % syntax behavior
                               # patsubst = pattern substitute
                               # For any .c file, replace with corresponding .o file
                               # Scope is $(source), which should be text

# Common functions

subst <from>,<to>,<text>    # Substitute text
strip <text>                # Remove spaces
findstring <find>,<in>      # Find substring, return <find> if found
filter <pattern...>,<text>  # Can pass multiple patterns
filter-out <pattern...>,<text> # Reverse filter, keeps unmatched items
sort <list>                 # Default ascending order
word <n>,<text>             # Get nth word (a.c b.c c.c -> b.c)
wordlist <s>,<e>,<text>     # Slice
words <text>                # Count words
firstword <text>

dir <names...>              # Extract directory from filename
notdir <names...>           # Remove directory part, keep filename only
suffix <names...>           # Extract suffix
basename <names...>         # Extract name without suffix (prefix)
addsuffix <suffix>,<names...> # Add suffix
addprefix <prefix>,<names...>
join <list1>,<list2>

origin <variable>           # Where did this variable come from?

shell <command>             # Execute command in shell

error <text ...>            # Generate error message, but doesn't abort
warning <text ...>          # Generate warning message

# Iteration
foreach <var>,<list>,<text>

names := a b c d
files := $(foreach n,$(names),$(n).o)  # a.o b.o c.o d.o

Custom Functions with call

call <expression>,<parm1>,<parm2>,...,<parmn>

# Examples are easier to understand
reverse = $(2) $(1)
foo = $(call reverse,a,b)  # $(foo) -> b a

Special Variables

VPATH                            # Set default search path
# Syntax: vpath <pattern> <directories>
# Example: vpath %.h src:../headers:lib  # Directories separated by colon (:)

# Can actively set paths
# Advantage: if file not found, will search in VPATH
VPATH = src
BUILD_DIR = build

$(BUILD_DIR)/%.o: %.c
    gcc -c $< -o $@

Sub-Makefiles

subsystem:
    cd subdir && $(MAKE)

# Equivalent to

subsystem:
    $(MAKE) -C subdir

# Execute make in subsystem

export VAR = value     # Pass VAR to subsystem
unexport VAR_PRIVATE   # Don't pass this variable

# $(SHELL) and $(MAKEFLAGS) are always passed to subsystems

Define Directive

define reusable
dosth..
dosth..
endef

$(reusable)

Conditionals

# Similar to bash syntax
ifeq (var1, var2)
    [command]
else
    [command]
endif

# Available keywords
ifeq ifneq ifdef ifndef

# if as a function
$(if <condition>,<then-part>)
$(if <condition>,<then-part>,<else-part>)

Implicit Rules

# Implicit rules use these predefined variables:

CC = gcc        # C compiler
CXX = g++       # C++ compiler
CFLAGS =        # C compile options
CXXFLAGS =      # C++ compile options
LDFLAGS =       # Linker options

# Only need to define dependencies, compile rules apply automatically
CFLAGS = -Wall -O2

main: main.o utils.o  # Implicit rules automatically compile .c → .o
    $(CC) $^ -o $@    # Linking rules need to be written manually
                      # (implicit rules only handle single file compilation)

# View all implicit rules
make -p | grep "^%"  # Display all pattern rules

Include Directive

include file1.mk file2.mk
-include optional.mk  # Don't error if file doesn't exist