Greetings,

I've been using Fennel for game development lately, and I've found a
technique I like quite a bit.

As a background: in Rust, it's considered idiomatic to shadow a variable
repeatedly as you perform operations on it[0]. For instance, the
following code prints "x: 8":

```rust
fn main() {
    let x = 10;
    let x = x + 2;
    let x = x * 2;
    let x = x / 3;
    println!("x: {}", x);
}
```

This is especially hand in Rust for reasons having to do with Rust's
type system, but there are two other major benefits: you can't
accidentally re-use earlier values, and you don't have to come up with
new names

A similar pattern can be used in Fennel with let:

```fennel
(let [x 1
      x (+ x 2)
      x (* x 2)
      x (/ x 3)]
  (print (.. "x: " x)))
```

I'm using this in https://git.sr.ht/~benaiah/ludum-dare-nov-2018 for
building a shader effect as follows:

```fennel
(let [eff (moonshine 1024 768 moonshine.effects.crt)
      _ (set eff.crt.feather 0.1)
      _ (set eff.crt.distortionFactor [1.13 1.15])
      eff (eff.chain moonshine.effects.vignette)
      _ (set eff.vignette.radius 0.85)
      _ (set eff.vignette.opacity 0.8)
      eff (eff.chain moonshine.effects.fastgaussianblur)
      eff (eff.chain moonshine.effects.filmgrain)
      _ (set eff.filmgrain.size 2)
      _ (set eff.filmgrain.opacity 0.5)]
  eff)
```

I really like this pattern, and I hope others find it helpful as well.

[0]: https://doc.rust-lang.org/stable/book/second-edition/ch03-01-variables-and-mutability.html#shadowing

Regards,
Benaiah Mischenko