DEV Community: Jacob Asper

Variables in Rust - Rust for TypeScript Developers

Jacob Asper — Sat, 11 Feb 2023 07:23:00 +0000

Naming
Scope
Initialization
Declaration
Redeclaration
Reassignment
Mutability

Naming

In Rust, variables are snake cased, while constants are conventially in screaming snake case

const CONSTANT_VALUE: i32 = 2;
let non_constant_value = 32;

Note that variables defined with const must be explicitly typed

Scope

In Rust, variables are block scoped just like variables declared with let and const in TypeScript

fn main() {
  let x = 32;
  {
    let x = 12;
    println!("{x}") // 12
  }
  println!("{x}") // 32
}

Initialization

In TypeScript, the initialization of variables declared with var is hoisted

console.log(x); // undefined
var x = 12;
console.log(x); // 12

The initialization of variables declared with let or const is not hoisted

console.log(x);
let x = 12;

Uncaught ReferenceError: can't access lexical declaration 'x' before initialization

However, they are assigned undefined if not given an initializer

let x;
console.log(x) // undefined

Rust takes the more modern behavior of let and const and takes it one step further. Variables are not assigned a value if not given an initializer

This works

fn main() {
  let x = 12;
  println!("{x}"); // 12
}

This does not

fn main() {
  let x: i32;
  println!("{x}");
}

error[E0381]: used binding `x` isn't initialized
 --> src/main.rs:4:16
  |
2 |     let x: i32;
  |         - binding declared here but left uninitialized
    |
3 |     println!("{x}");
  |                ^ `x` used here but it isn't initialized

Declaration

Variables declared with const in Rust can be global, but variables declared with let cannot

So this works,

const X: i32 = 12;

fn main() {

}

But this does not

let x = 12;

fn main() {

}

error: expected item, found keyword `let`
 --> src/main.rs:1:1
  |
1 | let x = 12;
  | ^^^ consider using `const` or `static` instead of `let` for global variables

In TypeScript, variables declared with var, let, or const can be declared anywhere and aren't required to be explicitly typed

let x = 12;

Redeclaration

In TypeScript, variables assigned with var can be redeclared locally

var x = 12;
console.log(x); // 12

var x = 32;
console.log(x); // 32

Variables declared with let or const cannot be redeclared locally

const x = 12;
console.log(x);

const x = 32;
console.log(x);

Cannot redeclare block-scoped variable 'x'.

Rust's const works the same as TypeScript's in this sense

fn main() {
  const X: i32 = 12;
  const X: i32 = 12;
}

error[E0428]: the name `X` is defined multiple times
 --> src/main.rs:5:3
  |
4 |   const X: i32 = 12;
  |   ------------------ previous definition of the value `X` here
5 |   const X: i32 = 12;
  |   ^^^^^^^^^^^^^^^^^^ `X` redefined here
  |
  = note: `X` must be defined only once in the value namespace of this block

Rust's let works like var here—it can be redeclared in the same namespace

fn main() {
  let x = 12;
  println!("{x}"); // 12

  let x = 43;
  println!("{x}"); // 43
}

However, variables declared with let can be redeclared with a different type!

fn main() {
  let x = 32;
  println!("{x}");

  let x = "hi";
  println!("{x}");
}

While in TypeScript, variable declarations can't change type

var x = 1
var x = 'hi'

Subsequent variable declarations must have the same type.
Variable 'x' must be of type 'number', but here has type 'string'.

Reassignment

In TypeScript, variables declared with const cannot be reassigned

const x = 12;
x = 93;

Cannot assign to 'x' because it is a constant.

Variables declared with var or let can be reassigned

let x = 12;
console.log(x); // 12

x = 32;
console.log(x); // 32

In Rust, variables assigned with both let and const cannot be reassigned

fn main() {
  let x = 12;

  x = 23;
}

error[E0384]: cannot assign twice to immutable variable `x`
 --> src/main.rs:6:3
  |
4 |   let x = 12;
  |       -
  |       |
  |       first assignment to `x`
  |       help: consider making this binding mutable: `mut x`
5 |   
6 |   x = 23;
  |   ^^^^^^ cannot assign twice to immutable variable

Mutability

As the compiler so kindly pointed out, we can use the mut keyword with let to make x mutable

fn main() {
  let mut x = 12;
  println!("{x}"); // 12

  x = 23;
  println!("{x}"); // 23
}

This differs from TypeScript, where objects and arrays are mutable by default

const arr = [];
arr.push(1);

console.log(arr); // [1]

In Rust, this does not compile without the mut keyword

fn main() {
  let vec = Vec::new();
  vec.push(1);
}

error[E0596]: cannot borrow `vec` as mutable, as it is not declared as mutable
 --> src/main.rs:5:3
  |
4 |   let vec = Vec::new();
  |       --- help: consider changing this to be mutable: `mut vec`
5 |   vec.push(1);
  |   ^^^^^^^^^^^ cannot borrow as mutable

Outro

Thank you for reading! Please let me know if you have any suggestions.

Pulling changes from forked repositories

Jacob Asper — Fri, 30 Dec 2022 05:23:37 +0000

Intro
Remotes
- Checking remotes
- Adding new remotes
Fetching changes
Merging changes
Conclusion

Intro

Imagine this—you are working on a feature in an open–source GitHub repo with a few others. You don't have write access, so you will need to make forks. If everyone is comfortable, one person can make a fork and give everyone else write access, but that's not always the easy to coordinate.

Remotes

Your teammate just pushed some changes, how can you pull them into your own fork?

First we need to set up a remote repository, or for short, a remote. This will allow you to interact with other repositories—in this case, your teammates'.

Checking remotes

If you are unsure which remotes you've already added, you can always check with this command

$ git remote -v
origin  https://github.com/20jasper/git-tutorial (fetch)
origin  https://github.com/20jasper/git-tutorial (push)

Note that origin isn't a special keyword—it's just the default name for a repo's main remote

Adding new remotes

Typing out the whole url for a remote every time would be confusing, but luckily, each remote can be given a name just like origin.

Let's say our teammate is called Jimothy, and to keep it simple, let's use jimothy for the name of the remote as well.

$ git remote add jimothy https://github.com/jimothy/git-tutorial

Just to be safe, let's check the remotes.

$ git remote -v
jimothy https://github.com/jimothy/git-tutorial (fetch)
jimothy https://github.com/jimothy/git-tutorial (push)
origin  https://github.com/20jasper/git-tutorial (fetch)
origin  https://github.com/20jasper/git-tutorial (push)

Great—everything worked! Now you just need to fetch and merge the changes and you're set.

Fetching changes

To sync the changes made in a remote, run git fetch <remote>

$ git fetch jimothy
remote: Enumerating objects: 5, done.
remote: Counting objects: 100% (5/5), done.
remote: Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
Unpacking objects: 100% (3/3), 639 bytes | 106.00 KiB/s, done.
From https://github.com/jimothy/git-tutorial
 * [new branch]      main       -> jimothy/main

Merging changes

At this point, both versions can be merged.

$ git merge jimothy/main
Updating 875fc67..b7568a9

Conclusion

Congratulations You have successfully combined both your work and your teammate's!

Implement `Pick` in TypeScript

Jacob Asper — Thu, 22 Dec 2022 00:28:48 +0000

This type challenge is to create your own version of pick (without pick obviously). I decided not to use any utility types

Link to Challenge: https://github.com/type-challenges/type-challenges/blob/main/questions/00004-easy-pick/README.md

Pick
- Table Of Contents
  - Tags
  - Explanation
    - Lookup types
    - Mapped Types
    - Generic Constraints
    - keyof
  - Conclusion
  - Reference

Explanation

We need to create a new object type with only the properties in both Type and Union

type MyPick<Type, Union> = /* ... */

Lookup types

To get the type of the keys (keys are also known as indexed access types or lookup types) in Chair, we can use square bracket notation just like accessing a property or method in a JavaScript object

type Chair = {
    color: string,
    legCount: number,
    isComfortable: boolean
}

Chair["color"] // string
Chair["legCount"] // number

Note that only types can be used for indexing

const key = "color"
Chair[key] // Type "key" cannot be used as an index type

Mapped Types

How can we iterate through the union and create a new object type? The answer is mapped types

For example, we can set each key of Chair to a boolean like this with dynamic keys and the in operator

type ChairKeysUnion = "color" | "legCount" | "isComfortable"

type BooleanChair = {
    [Key in ChairKeysUnion]: boolean
} 
/*
type BooleanChair = {
    color: boolean;
    legCount: boolean;
    isComfortable: boolean;
}
*/

Note that Key in this example is a parameter, so it is just a placeholder name. It could be called Property or Jimothy and work just as well

Generic Constraints

But why can't we just combine mapped types and lookup types to set each property in the union to the appropriate lookup type like this?

type MyPick<Type, Union> = {
    [Key in Union]: Type[Key]
}

At this point, MyPick is not typesafe—it accepts any and all properties in Union. In the case a property doesn't exist in the Type passed to MyPick, it will be on the new object type with a value of unknown

type NewChair = MyPick<Chair, 'color' | 'isComfortable' | 'invalid'>
/*
type NewChair = {
    color: string;
    isComfortable: boolean;
    invalid: unknown;
}*/

keyof

To limit Union to only lookup types in Type, we first need Type's lookup types. To do this, we can use the keyof operator. It takes an object type and returns a string, string union, or number union of the type's keys.

type Chair = {
    color: string,
    legCount: number,
    isComfortable: boolean
}

type ChairIndexUnion = keyof Chair // "color" | "legCount" | "isComfortable"

Now that we have both unions, we can constrain the Union parameter to lookup types in Type with the extends keyword

type MyPick<Type, Union extends keyof Type> = {
    [Key in Union]: Type[Key]
}

type NewChair = MyPick<Chair, 'color' | 'isComfortable' | 'invalid'>
/*
Type '"color" | "isComfortable" | "invalid"' does not satisfy the constraint 'keyof Chair'.
Type '"invalid"' is not assignable to type 'keyof Chair'.
*/

invalid is not in Chair, so the NewChair type is invalid

Conclusion

Congratulations—you now have a typesafe pick function!

Reference

Lookup Types/Indexed Access Types
Mapped Types
- Mapped Types
Generic Constraints
- Generic Constraints
- Using Type Parameters in Generic Constraints

DEV Community: Jacob Asper

Variables in Rust - Rust for TypeScript Developers

Table Of Contents

Naming

Scope

Initialization

Declaration

Redeclaration

Reassignment

Mutability

Outro

Pulling changes from forked repositories

Intro

Remotes

Checking remotes

Adding new remotes

Fetching changes

Merging changes

Conclusion

Implement `Pick` in TypeScript

Table Of Contents

Tags

Explanation

Lookup types

Mapped Types

Generic Constraints

keyof

Conclusion

Reference