Parents (Total: 7)

The searched file hash is included in 7 parent files which include package known and seen by metalookup. A sample is included below:

Key	Value
FileSize	1268832
MD5	03543E40F344755510468FD252B120C3
PackageDescription	LALR(k) parser generator Frown is an LALR(k) parser generator for Haskell 98 written in Haskell 98. . Its salient features are: - The generated parsers are time and space efficient. On the downside, the parsers are quite large. - Frown generates four different types of parsers. as a common characteristic, the parsers are genuinely functional (ie ‘table-free’); the states of the underlying LR automaton are encoded as mutually recursive functions. Three output formats use a typed stack representation, and one format due to Ross Paterson (code=stackless) works even without a stack. - Encoding states as functions means that each state can be treated individually as opposed to a table-driven approach, which necessitates a uniform treatment of states. For instance, look-ahead is only used when necessary to resolve conflicts. - Frown comes with debugging and tracing facilities; the standard output format due to Doaitse Swierstra (code=standard) may be useful for teaching LR parsing. - Common grammatical patterns such as repetition of symbols can be captured using rule schemata. There are several predefined rule schemata. - Terminal symbols are arbitrary variable-free Haskell patterns or guards. Both terminal and nonterminal symbols may have an arbitrary number of synthesized attributes. - Frown comes with extensive documentation; several example grammars are included. Furthermore, Frown supports the use of monadic lexers, monadic semantic actions, precedences, and associativity, the generation of backtracking parsers, multiple start symbols, error reporting, and a weak form of error correction.
PackageMaintainer	Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
PackageName	frown
PackageSection	misc
PackageVersion	0.6.2.3-5
SHA-1	0D12E43D84F15E1B722EB6EFE4B6802FC8683A14
SHA-256	1A25C36C0CB59F82D4552814498039AE0BA48E41D3453EB5C4DE5A79D48A4E04

Key	Value
FileSize	468612
MD5	7FD0FF60B254A3D3ABE0A38A9F3BC91F
PackageDescription	LALR(k) parser generator -- documentation Frown is an LALR(k) parser generator for Haskell 98 written in Haskell 98. . Its salient features are: - The generated parsers are time and space efficient. On the downside, the parsers are quite large. - Frown generates four different types of parsers. as a common characteristic, the parsers are genuinely functional (ie ‘table-free’); the states of the underlying LR automaton are encoded as mutually recursive functions. Three output formats use a typed stack representation, and one format due to Ross Paterson (code=stackless) works even without a stack. - Encoding states as functions means that each state can be treated individually as opposed to a table-driven approach, which necessitates a uniform treatment of states. For instance, look-ahead is only used when necessary to resolve conflicts. - Frown comes with debugging and tracing facilities; the standard output format due to Doaitse Swierstra (code=standard) may be useful for teaching LR parsing. - Common grammatical patterns such as repetition of symbols can be captured using rule schemata. There are several predefined rule schemata. - Terminal symbols are arbitrary variable-free Haskell patterns or guards. Both terminal and nonterminal symbols may have an arbitrary number of synthesized attributes. - Frown comes with extensive documentation; several example grammars are included. Furthermore, Frown supports the use of monadic lexers, monadic semantic actions, precedences, and associativity, the generation of backtracking parsers, multiple start symbols, error reporting, and a weak form of error correction.
PackageMaintainer	Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
PackageName	frown-doc
PackageSection	doc
PackageVersion	0.6.2.3-5
SHA-1	40A3F919DED8898AC8E551DA3325BE2206CCBBF3
SHA-256	E5999F59150ECE6662AD72D3190784574050B6241142997194A138EF51DF12A8

Key	Value
FileSize	468756
MD5	CB45102A1D0C612E3BFA3A1426FF1638
PackageDescription	LALR(k) parser generator Frown is an LALR(k) parser generator for Haskell 98 written in Haskell 98. . Its salient features are: - The generated parsers are time and space efficient. On the downside, the parsers are quite large. - Frown generates four different types of parsers. as a common characteristic, the parsers are genuinely functional (ie ‘table-free’); the states of the underlying LR automaton are encoded as mutually recursive functions. Three output formats use a typed stack representation, and one format due to Ross Paterson (code=stackless) works even without a stack. - Encoding states as functions means that each state can be treated individually as opposed to a table-driven approach, which necessitates a uniform treatment of states. For instance, look-ahead is only used when necessary to resolve conflicts. - Frown comes with debugging and tracing facilities; the standard output format due to Doaitse Swierstra (code=standard) may be useful for teaching LR parsing. - Common grammatical patterns such as repetition of symbols can be captured using rule schemata. There are several predefined rule schemata. - Terminal symbols are arbitrary variable-free Haskell patterns or guards. Both terminal and nonterminal symbols may have an arbitrary number of synthesized attributes. - Frown comes with extensive documentation; several example grammars are included. Furthermore, Frown supports the use of monadic lexers, monadic semantic actions, precedences, and associativity, the generation of backtracking parsers, multiple start symbols, error reporting, and a weak form of error correction.
PackageMaintainer	Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
PackageName	frown
PackageSection	misc
PackageVersion	0.6.2.3-5
SHA-1	20A38B6FA36FDE98B97AB80CC7FEDA511D6C9266
SHA-256	C90D267BB41649B0252F98B7B5F4CA7559D053212F701EE12C7A5C8177F85DA1

Key	Value
FileSize	1812644
MD5	D2D31B17E5CE41A43F051DAF08368F44
PackageDescription	LALR(k) parser generator Frown is an LALR(k) parser generator for Haskell 98 written in Haskell 98. . Its salient features are: - The generated parsers are time and space efficient. On the downside, the parsers are quite large. - Frown generates four different types of parsers. as a common characteristic, the parsers are genuinely functional (ie ‘table-free’); the states of the underlying LR automaton are encoded as mutually recursive functions. Three output formats use a typed stack representation, and one format due to Ross Paterson (code=stackless) works even without a stack. - Encoding states as functions means that each state can be treated individually as opposed to a table-driven approach, which necessitates a uniform treatment of states. For instance, look-ahead is only used when necessary to resolve conflicts. - Frown comes with debugging and tracing facilities; the standard output format due to Doaitse Swierstra (code=standard) may be useful for teaching LR parsing. - Common grammatical patterns such as repetition of symbols can be captured using rule schemata. There are several predefined rule schemata. - Terminal symbols are arbitrary variable-free Haskell patterns or guards. Both terminal and nonterminal symbols may have an arbitrary number of synthesized attributes. - Frown comes with extensive documentation; several example grammars are included. Furthermore, Frown supports the use of monadic lexers, monadic semantic actions, precedences, and associativity, the generation of backtracking parsers, multiple start symbols, error reporting, and a weak form of error correction.
PackageMaintainer	Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
PackageName	frown
PackageSection	misc
PackageVersion	0.6.2.3-5
SHA-1	504579914B5BA04C12BE81679DB69CBAE580ADDB
SHA-256	98727D874844ECCB1606107FE75EB07909E2607B8924D45478541ED5FEE66276

Key	Value
FileSize	1163344
MD5	AFCF8516E9BA10EF2A759E7C5C15B1BF
PackageDescription	LALR(k) parser generator Frown is an LALR(k) parser generator for Haskell 98 written in Haskell 98. . Its salient features are: - The generated parsers are time and space efficient. On the downside, the parsers are quite large. - Frown generates four different types of parsers. as a common characteristic, the parsers are genuinely functional (ie ‘table-free’); the states of the underlying LR automaton are encoded as mutually recursive functions. Three output formats use a typed stack representation, and one format due to Ross Paterson (code=stackless) works even without a stack. - Encoding states as functions means that each state can be treated individually as opposed to a table-driven approach, which necessitates a uniform treatment of states. For instance, look-ahead is only used when necessary to resolve conflicts. - Frown comes with debugging and tracing facilities; the standard output format due to Doaitse Swierstra (code=standard) may be useful for teaching LR parsing. - Common grammatical patterns such as repetition of symbols can be captured using rule schemata. There are several predefined rule schemata. - Terminal symbols are arbitrary variable-free Haskell patterns or guards. Both terminal and nonterminal symbols may have an arbitrary number of synthesized attributes. - Frown comes with extensive documentation; several example grammars are included. Furthermore, Frown supports the use of monadic lexers, monadic semantic actions, precedences, and associativity, the generation of backtracking parsers, multiple start symbols, error reporting, and a weak form of error correction.
PackageMaintainer	Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
PackageName	frown
PackageSection	misc
PackageVersion	0.6.2.3-5
SHA-1	6BF202D782251697D43E412CDE7445FA568D8333
SHA-256	2A11763F067EF2633F7F71942651DF283730CBF5C3C03E9B3F3A5BE0B17794E4

Key	Value
FileSize	1007800
MD5	31472FDBFD33778219AA5372565123CF
PackageDescription	LALR(k) parser generator Frown is an LALR(k) parser generator for Haskell 98 written in Haskell 98. . Its salient features are: - The generated parsers are time and space efficient. On the downside, the parsers are quite large. - Frown generates four different types of parsers. as a common characteristic, the parsers are genuinely functional (ie ‘table-free’); the states of the underlying LR automaton are encoded as mutually recursive functions. Three output formats use a typed stack representation, and one format due to Ross Paterson (code=stackless) works even without a stack. - Encoding states as functions means that each state can be treated individually as opposed to a table-driven approach, which necessitates a uniform treatment of states. For instance, look-ahead is only used when necessary to resolve conflicts. - Frown comes with debugging and tracing facilities; the standard output format due to Doaitse Swierstra (code=standard) may be useful for teaching LR parsing. - Common grammatical patterns such as repetition of symbols can be captured using rule schemata. There are several predefined rule schemata. - Terminal symbols are arbitrary variable-free Haskell patterns or guards. Both terminal and nonterminal symbols may have an arbitrary number of synthesized attributes. - Frown comes with extensive documentation; several example grammars are included. Furthermore, Frown supports the use of monadic lexers, monadic semantic actions, precedences, and associativity, the generation of backtracking parsers, multiple start symbols, error reporting, and a weak form of error correction.
PackageMaintainer	Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
PackageName	frown
PackageSection	misc
PackageVersion	0.6.2.3-5
SHA-1	B9EE336981057CD51948B12767A0741ADBAF43B1
SHA-256	7772121359FE06BF5771839A1DD274CA4ADF0E76DFE37C0918654C277180D466

Key	Value
FileSize	467216
MD5	9B8FCB3A0C4E83D3AE089719DCBE8AE5
PackageDescription	LALR(k) parser generator Frown is an LALR(k) parser generator for Haskell 98 written in Haskell 98. . Its salient features are: - The generated parsers are time and space efficient. On the downside, the parsers are quite large. - Frown generates four different types of parsers. as a common characteristic, the parsers are genuinely functional (ie ‘table-free’); the states of the underlying LR automaton are encoded as mutually recursive functions. Three output formats use a typed stack representation, and one format due to Ross Paterson (code=stackless) works even without a stack. - Encoding states as functions means that each state can be treated individually as opposed to a table-driven approach, which necessitates a uniform treatment of states. For instance, look-ahead is only used when necessary to resolve conflicts. - Frown comes with debugging and tracing facilities; the standard output format due to Doaitse Swierstra (code=standard) may be useful for teaching LR parsing. - Common grammatical patterns such as repetition of symbols can be captured using rule schemata. There are several predefined rule schemata. - Terminal symbols are arbitrary variable-free Haskell patterns or guards. Both terminal and nonterminal symbols may have an arbitrary number of synthesized attributes. - Frown comes with extensive documentation; several example grammars are included. Furthermore, Frown supports the use of monadic lexers, monadic semantic actions, precedences, and associativity, the generation of backtracking parsers, multiple start symbols, error reporting, and a weak form of error correction.
PackageMaintainer	Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
PackageName	frown
PackageSection	misc
PackageVersion	0.6.2.3-5
SHA-1	32D6B8341B724D2E365B8E432CA6ED6DBB924194
SHA-256	698E884D8056127CE11F12DEC77679A94573CBADC2C7125C1EE6E79366B1864D