Parents (Total: 11)

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

Key	Value
FileSize	1487124
MD5	804A341F9408F196A37BB0CCF77219DC
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	Debian Haskell Group <pkg-haskell-maintainers@lists.alioth.debian.org>
PackageName	frown
PackageSection	misc
PackageVersion	0.6.2.3-4
SHA-1	342C9A5B58D00E7FC6B693A608908B73C5CE1E0D
SHA-256	1F12FCF579372D3B274FB6B7045E65693ECCFA839C5DEF44CEE129796B32D7B1

Key	Value
FileSize	1519102
MD5	A19177E3BC67021B89ADC5489AC1DBEB
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	Debian Haskell Group <pkg-haskell-maintainers@lists.alioth.debian.org>
PackageName	frown
PackageSection	misc
PackageVersion	0.6.2.3-4
SHA-1	18AA4C17FE10252F4F5A2C202581280E1D9F9CC3
SHA-256	4D24C3FFCA9FEE249A1E89B7B5113A4AC2F7E88088B4BE1D72D68F480BF7AF21

Key	Value
FileSize	1537480
MD5	B5128F0EE6DDFC976365312367590CA4
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	Debian Haskell Group <pkg-haskell-maintainers@lists.alioth.debian.org>
PackageName	frown
PackageSection	misc
PackageVersion	0.6.2.3-4
SHA-1	36CC12D7D9EDFF5147FA2A6278DD125BD8F70E93
SHA-256	A1A4B5ECB36C513E4D5D8AD756C9168620169D5F942D5DF08E63A98F5A3DB2A4

Key	Value
FileSize	548510
MD5	7ED02551E1E9BE327748F5AD0B932AA2
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	Debian Haskell Group <pkg-haskell-maintainers@lists.alioth.debian.org>
PackageName	frown
PackageSection	misc
PackageVersion	0.6.2.3-4
SHA-1	D80D9C8F585CFFE5691B773CEB2673F3AADD54FA
SHA-256	90DF2104E47FC39D2CC35DC61BEE3380278A7C161C1C5ADE97780A6D804A75D2

Key	Value
FileSize	1477762
MD5	C563D949A7CCC4B57028204FB32357D3
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	Debian Haskell Group <pkg-haskell-maintainers@lists.alioth.debian.org>
PackageName	frown
PackageSection	misc
PackageVersion	0.6.2.3-4
SHA-1	FBEB8192E1A2E3694E2E7DA46F88F87BC147A795
SHA-256	18FEAE9EC7B62981428DE5E87B41406A5E24E061A8A196E46112DA34ACEB5975

Key	Value
FileSize	1596456
MD5	E4551EC205392D5D2273B84E1FF944B5
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	Debian Haskell Group <pkg-haskell-maintainers@lists.alioth.debian.org>
PackageName	frown
PackageSection	misc
PackageVersion	0.6.2.3-4
SHA-1	D3A47E54AAFBDA186F098F15910B2CBF3F4A5167
SHA-256	E0D9F7B79F36FBA8EECB941A5AF87D7CFD15341BF9DD8A6A3B67B46162E6FD5E

Key	Value
FileSize	1684890
MD5	9AA61FFADEC189191B878C78B904580C
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	Debian Haskell Group <pkg-haskell-maintainers@lists.alioth.debian.org>
PackageName	frown
PackageSection	misc
PackageVersion	0.6.2.3-4
SHA-1	55563C7EA048934C438AAF24C3B956C8E07E092A
SHA-256	DCFE72789E6884EF087EAA532E75ECDFA195FAFACDE7CA6C838D02FF230F5EA1

Key	Value
FileSize	2839900
MD5	D3D6C7268CB95442F84A7D92DFA76EF8
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	Debian Haskell Group <pkg-haskell-maintainers@lists.alioth.debian.org>
PackageName	frown
PackageSection	misc
PackageVersion	0.6.2.3-4
SHA-1	D2161F26546D4B0562A43E2B16B6E8C0E6126F00
SHA-256	424E759A9CF54075A7745C63CF0F52E69180CBDCEEA4124887173C021EE65B89

Key	Value
FileSize	473930
MD5	11378650F304E73E79824CC5E73452BC
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	Debian Haskell Group <pkg-haskell-maintainers@lists.alioth.debian.org>
PackageName	frown-doc
PackageSection	doc
PackageVersion	0.6.2.3-4
SHA-1	617FAD99BD624CFCD1DDCBE2F7F8A8C275D9BC6D
SHA-256	A64696946F5D493ED38EDDB4592163411B8E015336DA9ADEE412FC644E56E53D

Key	Value
FileSize	545892
MD5	5E2D46359BFCE216B2DF71382056F263
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	Debian Haskell Group <pkg-haskell-maintainers@lists.alioth.debian.org>
PackageName	frown
PackageSection	misc
PackageVersion	0.6.2.3-4
SHA-1	596BA775B6BF02CD41FD2CC7FA5467F4AEAD298F
SHA-256	D94356DC98930B5F375791458D073FB837FFEB2F8CDE0D7DE7F6F0F3B81E4450

Key	Value
FileSize	1486406
MD5	0A6CC6B36391D376C6083F81FF7961F7
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	Debian Haskell Group <pkg-haskell-maintainers@lists.alioth.debian.org>
PackageName	frown
PackageSection	misc
PackageVersion	0.6.2.3-4
SHA-1	9D676023CE14DB86D8B3073D9B723CB4D86DD559
SHA-256	28B0AC52B37DE35C373A871F017B47BBD12AE0348B2E4DDF47F023CB69552D87