# use pushdown in a sentence.

It's a *pushdown* stack of consolidated tabs.

Which is basically an artificial *pushdown* of car prices.

I always thought I was playing more like a *pushdown* automata than a Turing machine.

For finite-state and *pushdown* automata, derivatives and continuations are two sides of the same coin.

C macros are not Turing complete, they're a *pushdown* automaton.

You can only imperfectly emulate anything more than a regular language in a finite reality (since a *pushdown* automaton has an infinite stack).

I've seen the "*pushdown*" and find it's a great cue for taking a break from the computer.

The grammar itself is context-free and LL(k) and the implementation is trivial once you understand what *pushdown* automatons are (automata theory, right after finite-state machines).

Perl regular expressions probably accept more than just context-free grammars since the language that accepts prime numbers is not Context-Free, you can't build a *pushdown* automaton for such a language, there is a relatively trivial proof of this using the pumping lemma for context-free languages.

For those interested in symbolically manipulating [1] state machines (NFAs), *pushdown* automata (PDAs), and context-free grammars (CFGs), take a look at .

Interestingly, any physical, finite machine can be modelled as a finite state automaton (which is even more limited than a *pushdown* automaton) with a large enough state space.

The C preprocessor is a *pushdown* automaton, which if you add fixpoints (unbounded recursion) becomes a bounded storage machine.

I'm working on an open-source framework, and a series of command line tools built on top of the framework, for symbolically manipulating context-free grammars, non-deterministic *pushdown* automata, and non-deterministic finite automata.

Although there are some details about what kind of *pushdown* are supported by the FDWs (for example: to do a WHERE key=x, a non-toy Redis FDW should push the equality predicate to redis), it's no faster nor slower than calling a C function a bunch of times.