This is a big reason I still use Damus as my daily driver. No idea what relays it’s connecting to or their status.
Finally convinced nostr:npub1xtscya34g58tk0z605fvr788k263gsu6cy9x0mhnm87echrgufzsevkk5s that this is the way too 💜
Tell him to get NouBells. They’re a bit pricey but we’ll worth it IMO
Test failed successfully
“brands need to have spent at least $1,000 on ads within the prior 30 days or $6,000 in the previous 180 days to retain the gold checkmark”
🤡 nostr:note19mssukczseqpz4z7utxwm3dtjydgac9texfy30wykz328r9u6nrqkl3tz3
They’re out here playing checkers while Bitcoin is playing chess
Yup.
It’s painful as a dev to have to explain why certain designs aren’t feasible or worth the trade offs.
The old StarCraft TD maps got me hooked on the play style.
It’s possible. Not sure it’s very likely though.
Asked ChatGPT to make a cheatsheet for me earlier.
### Variables and Data Types:
```rust
// Variable declaration
let variable_name: data_type = value;
// Immutable variable
let x: i32 = 10;
// Mutable variable
let mut y: f64 = 3.14;
// Constants (immutable)
const PI: f64 = 3.14159265359;
// Basic data types
let number: i32 = 42;
let float_number: f64 = 3.14;
let character: char = 'a';
let is_true: bool = true;
let text: &str = "Hello, Rust!";
```
### Control Flow:
```rust
// If-else statement
if condition {
// code block
} else if another_condition {
// code block
} else {
// code block
}
// While loop
while condition {
// code block
}
// For loop (range-based)
for i in 0..5 {
// code block (i takes values 0 to 4)
}
// For loop (collection-based)
let numbers = vec![1, 2, 3];
for num in numbers {
// code block (num takes values 1, 2, 3)
}
// Match statement (pattern matching)
match value {
pattern1 => { /* code block */ },
pattern2 if condition => { /* code block */ },
_ => { /* default code block */ },
}
```
### Functions:
```rust
// Function with no return value
fn function_name(param1: data_type, param2: data_type) {
// code block
}
// Function with a return value
fn add_numbers(a: i32, b: i32) -> i32 {
// code block
a + b
}
// Function with a generic type
fn generic_function
// code block
}
```
### Ownership and Borrowing:
```rust
// Ownership (Move semantics)
let vector1 = vec![1, 2, 3];
let vector2 = vector1; // vector1 is moved to vector2, vector1 is no longer valid
// Borrowing (Reference)
let vector3 = vec![4, 5, 6];
let reference = &vector3; // Borrowing the reference of vector3
```
### Structs and Enums:
```rust
// Struct declaration
struct MyStruct {
field1: data_type1,
field2: data_type2,
}
// Enum declaration
enum MyEnum {
Variant1,
Variant2(data_type),
Variant3 { field: data_type },
}
```
### Traits and Implementations:
```rust
// Trait declaration
trait MyTrait {
fn method1(&self);
fn method2(&mut self) -> data_type;
}
// Implementing a trait for a struct
impl MyTrait for MyStruct {
fn method1(&self) {
// code block
}
fn method2(&mut self) -> data_type {
// code block
}
}
```
### Error Handling:
```rust
// Result enum for error handling
enum Result
Ok(T),
Err(E),
}
// Function returning a Result
fn divide(x: f64, y: f64) -> Result
if y == 0.0 {
return Err("Division by zero".to_string());
}
Ok(x / y)
}
// Handling Result with match
match divide(10.0, 2.0) {
Ok(result) => println!("Result: {}", result),
Err(error) => eprintln!("Error: {}", error),
}
```
### Modules and Visibility:
```rust
// Module declaration (in separate file mod.rs or module_name.rs)
mod module_name {
// code inside the module
}
// Making items public within a module
mod my_module {
pub fn public_function() {
// code block
}
pub struct PublicStruct {
// fields
}
}
```
