First of all, it would be better to say "The unit type `()`" rather than "The null arguments `()`".  See the manual for further sample text showing how to refer to the unit type (and value) denoted by `()`.

Second: "typically dropped" is probably poor word choice.  The word "drop" has a certain technical meaning in Rust related to destructors, and I'd prefer to avoid using the word "drop" in other contexts if we can avoid it.  Maybe "are typically omitted" would be a better choice.

Third: There are two separate details here that I think your presentation is conflating:

 1. When an `fn` item has unit as its return type (e.g. `fn (x: int) -> () { ... }`), the return type declaration can be omitted entirely, including the `->` arrow: `fn (x: int) { ... }`.

 2. Return types (be they unit or non-unit) can often inferred on closures.  But I believe that is orthogonal to the point above about how unit is treated for `fn` items.

In your presentation, you mention that `()` is "typically dropped", but then you only provide an example using a closure, not a `fn` item.  This makes it hard for me as a reader to tell whether you are talking about detail 1 or detail 2 described above.

I would either revise the text to say that the types of closures are often inferred (and say nothing about `()`), or, if you insist on including this detail about `()`, then you should include a new definition of `fn fun (x: int) { println!("{}", x) }` that shows `()` being omitted on an `fn` item.