5. State and Lifecycle

This page introduces the concept of state and lifecycle in a React component. You can find a detailed component API reference here - https://reactjs.org/docs/react-component.html.

Handling Events

Handling events with React elements is very similar to handling events on DOM elements. There are some syntax differences:

• React events are named using camelCase, rather than lowercase.

• With JSX you pass a function as the event handler, rather than a string.

Hidden Bar

Hidden Bar lets you hide menu bar items to give your Mac a cleaner look.

Talking-Golang (Go) Index

Types

Variable Declaration and Initialization

(TODO) new() VS make()

(TODO) Zero Values

Type Assertions

Type Twitches

(TODO) Type Conversion

Naming

(TODO) Errors

ini

Package ini provides INI file read and write functionality in Go.

evcxr_repl

evcxr_repl is A Rust REPL (Read-Eval-Print loop) built to provide evaluation context for Interactive programming.

Interactive programming, in which expressions are entered and evaluated in real-time, can be a powerful tool for exploring a language and problem solving. This capability is most often associated with dynamically evaluated languages such as JavaScript and Python. Compiled languages such as Java and C++ can also be used interactively, but tooling tends to lag by many years. Rust is a newer compiled language for which interactive programming has recently emerged. This article discusses interactive programming with Rust courtesy of the google/evcxr - https://github.com/google/evcxr crate.

testify

Go code (golang) set of packages that provide many tools for testifying that your code will behave as you intend.

Features include:

• Easy assertions

• Mocking

• Testing suite interfaces and functions

strconv

Package strconv implements conversions to and from string representations of basic data types.

15. Smart Pointers

15.3 Running Code on Cleanup with the Drop Trait

The second trait important to the smart pointer pattern is Drop, which lets you customize what happens when a value is about to go out of scope. You can provide an implementation for the Drop` trait on any type, and the code you specify can be used to release resources like files or network connections.

Specify the code to run when a value goes out of scope by implementing the Drop trait. The Drop trait requires you to implement one method named drop that takes a mutable reference to self. To see when Rust calls drop, let’s implement drop with println! statements for now.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

struct CustomSmartPointer {
    data: String,
}

impl Drop for CustomSmartPointer {
    fn drop(&mut self) {
        println!("Dropping CustomSmartPointer with data `{}`!", self.data);
    }
}

fn main() {
    let c = CustomSmartPointer {
        data: String::from("my stuff"),
    };
    let d = CustomSmartPointer {
        data: String::from("other stuff"),
    };
    println!("CustomSmartPointers created.");
}

When we run this program, we’ll see the following output:

1
2
3
4

$ cargo run
CustomSmartPointers created.
Dropping CustomSmartPointer with data `other stuff`!
Dropping CustomSmartPointer with data `my stuff`!

Rust automatically called drop for us when our instances went out of scope, calling the code we specified. Variables are dropped in the reverse order of their creation, so d was dropped before c.

Dropping a Value Early with std::mem::drop

You might want to force the drop method that releases the lock so that other code in the same scope can acquire the lock. Rust doesn’t let you call the Drop trait’s drop method manually; instead you have to call the std::mem::drop function provided by the standard library if you want to force a value to be dropped before the end of its scope.

Rust doesn’t let us call drop of Drop trait explicitly because Rust would still automatically call drop on the value at the end of main. This would be a double free error because Rust would be trying to clean up the same value twice.

The std::mem::drop function is different from the drop method in the Drop trait. We call it by passing the value we want to force to be dropped early as an argument.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

struct CustomSmartPointer {
    data: String,
}

impl Drop for CustomSmartPointer {
    fn drop(&mut self) {
        println!("Dropping CustomSmartPointer with data `{}`!", self.data);
    }
}

fn main() {
    let c = CustomSmartPointer {
        data: String::from("some data"),
    };
    println!("CustomSmartPointer created.");
    drop(c);
    println!("CustomSmartPointer dropped before the end of main.");
}

Running this code will print the following:

1
2
3
4

$ cargo run
CustomSmartPointer created.
Dropping CustomSmartPointer with data `some data`!
CustomSmartPointer dropped before the end of main.

References

[1] Smart Pointers - The Rust Programming Language - https://doc.rust-lang.org/book/ch15-00-smart-pointers.html

[2] The Rust Programming Language - The Rust Programming Language - https://doc.rust-lang.org/book/title-page.html

10. Generic Types, Traits, and Lifetimes

Generics are abstract stand-ins for concrete types or other properties. When we’re writing code, we can express the behavior of generics or how they relate to other generics without knowing what will be in their place when compiling and running the code.

Then you’ll learn how to use traits to define behavior in a generic way. You can combine traits with generic types to constrain a generic type to only those types that have a particular behavior, as opposed to just any type.

Finally, we’ll discuss lifetimes, a variety of generics that give the compiler information about how references relate to each other. Lifetimes allow us to borrow values in many situations while still enabling the compiler to check that the references are valid.