I just wonder how somebody could post such a response:

There isn't in the standard any assertz/1 directive, only
an assertz/1 built-in predicate. A standard compliant version
of that code is:

:- initialization((
assertz(foo(bar)),
assertz(foo(baz))
)).

https://github.com/tau-prolog/tau-prolog/issues/252#issuecomment-860217540

So where does intialization/1 come from? Well its some 70's
nonsense, when compilers were multipass.

The traditional first two passes were scanner and parser.
Sometimes even done by using files. That these two passes
could correspond to two DCGs is a useful insight.

But then, Jan W. C parser collects a list of tokens first:

c99_tokens(List) -->
c99_token(H), !, /* calls token */
( {skip_token(H)}
-> c99_tokens(List)
; {List = [H|T]},
c99_tokens(T)
).

token(T) --> keyword(T), \+ identifier_cont_char(_).
token(T) --> identifier(T).
token(T) --> constant(T).
Etc..

In a “monadic” parser you dont have these two passes, but
nevertheless two DCGs. The passes are interwoven and no
token list is materialized. One can imagine the DCGs have a

‘C’/3 implementation, which call get_code/2 in the case of the
tokenizer and get_token/2 in the case of the parser. The result is
that you can process huge files with little or no memory.

Mostowski Collapse schrieb am Sonntag, 4. Juli 2021 um 09:59:07 UTC+2:
> I just wonder how somebody could post such a response:
>
> There isn't in the standard any assertz/1 directive, only
> an assertz/1 built-in predicate. A standard compliant version
> of that code is:
>
> :- initialization((
> assertz(foo(bar)),
> assertz(foo(baz))
> )).
>
> https://github.com/tau-prolog/tau-prolog/issues/252#issuecomment-860217540
>
> So where does intialization/1 come from? Well its some 70's
> nonsense, when compilers were multipass.

About “Write two DCGs”, the original Modula compiler was
multi pass. There was a scanner which wrote a file with tokens.
Then there was a parser which took this tokens and the next

pass started. Until over christmas Wirth and Gutknecht(*)
wrote a totally new Modula compiler that did everything together.
Or as they describe it:

" During 1984, the author designed a new compiler for Modula-2.
[...] Indeed, compilation time of the compiler itself was reduced
from some 4 minutes to a scant 45 seconds.

[...] Instead of each task constituting a pass - [...] - it constituted a
module with a mostly procedural interface. These modules represented
a scanner, a parser, a code generator, and a handler of symbol files."
http://www.modulaware.com/mdlt52.htm

How do this procedural interface in Prolog? Here is an example:

Monadic Parser in Prolog (Example DIMACS files)
https://stackoverflow.com/a/66800186/502187

Inspired by:

Happy - 2.5. Monadic Parsers
https://www.haskell.org/happy/doc/html/sec-monads.html

Mostowski Collapse schrieb am Sonntag, 4. Juli 2021 um 10:01:24 UTC+2:
> The traditional first two passes were scanner and parser.
> Sometimes even done by using files. That these two passes
> could correspond to two DCGs is a useful insight.
>
> But then, Jan W. C parser collects a list of tokens first:
>
> c99_tokens(List) -->
> c99_token(H), !, /* calls token */
> ( {skip_token(H)}
> -> c99_tokens(List)
> ; {List = [H|T]},
> c99_tokens(T)
> ).
>
> token(T) --> keyword(T), \+ identifier_cont_char(_).
> token(T) --> identifier(T).
> token(T) --> constant(T).
> Etc..
>
> In a “monadic” parser you dont have these two passes, but
> nevertheless two DCGs. The passes are interwoven and no
> token list is materialized. One can imagine the DCGs have a
>
> ‘C’/3 implementation, which call get_code/2 in the case of the
> tokenizer and get_token/2 in the case of the parser. The result is
> that you can process huge files with little or no memory.
> Mostowski Collapse schrieb am Sonntag, 4. Juli 2021 um 09:59:07 UTC+2:
> > I just wonder how somebody could post such a response:
> >
> > There isn't in the standard any assertz/1 directive, only
> > an assertz/1 built-in predicate. A standard compliant version
> > of that code is:
> >
> > :- initialization((
> > assertz(foo(bar)),
> > assertz(foo(baz))
> > )).
> >
> > https://github.com/tau-prolog/tau-prolog/issues/252#issuecomment-860217540
> >
> > So where does intialization/1 come from? Well its some 70's
> > nonsense, when compilers were multipass.