What does 'Zero Cost Abstraction' mean?

Question

I came across this term when exploring Rust.

I saw different kinds of explanations regarding this and still don't quite get the ideas.

In The Embedded Rust Book , it said

Type states are also an excellent example of Zero Cost Abstractions

• the ability to move certain behaviors to compile time execution or analysis.

These type states contain no actual data, and are instead used as markers.

Since they contain no data, they have no actual representation in memory at runtime:

Does it mean the runtime is faster because there is no memory in runtime?

Appreciate it if anyone can explain it in an easy to understand way.

Answer 1

Zero Cost Abstractions means adding higher-level programming concepts, like generics, collections and so on do not come with a run-time cost, only compiler time cost (the code will be slower to compile). Any operation on zero-cost abstractions is as fast as you would write out matching functionality by hand using lower-level programming concepts (for loops, counters, ifs and so on).

Answer 2

Zero cost abstractions are ones that bear no runtime costs in execution speed or memory usage.

By contrast, virtual methods are a good example of a costly abstraction: in many OO languages the type of the method's caller is determined at runtime which requires maintaining a lookup table (runtime memory usage) and then actually performing the lookup (runtime overhead per method call, likely at least an extra pointer dereference) with the runtime type to determine which version of the method to call. Another good example would be garbage collection: in return for being able to not worry about the details of memory allocation you pay with GC pauses.

Rust though mostly tries to have zero cost abstractions: ones that let you have your cake and eat it too. Ones that compiler can safely and correctly convert to forms that bear no extra indirection/memory usage. In fact, the only thing that I'm aware of (somebody more knowledgeable correct me if I'm wrong) that you really pay for at runtime in Rust is bounds checking.

Answer 3

The concept of zero cost abstractions originally came from the functional world. However, the terminology comes from C++. According to Bjarne Stroustrup,

In general, C++ implementations obey the zero-overhead principle: What you don't use, you don't pay for. And further: What you do use, you couldn't hand code any better.

This quote along with most answers fail to deliver the idea in its entirety because the context in which these were said isn't explicitly stated.

If there was only one programming language in the world: be it Rust or C++, zero-cost abstractions would be indistinguishable from most other compiler optimizations. The implication here is that there are countless other languages that let you do the same things as Rust or C++, but with a nonzero and often runtime-specific cost.