Parents (Total: 34)

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

Key	Value
FileSize	572580
MD5	3FC381C9804951FF92637636B5453721
PackageDescription	LALR(k) parser generator for Haskell 98 Frown is inspired by the parser generator Happy and uses a syntax quite simular as the syntax used by Happy. Happy only handles LALR(1) grammars while Frown can use more extensive LALR(k) grammars and the parsers generated by Frown are also faster than the parsers generated by Happy. . The salient features of Frown 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, 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	devel
PackageVersion	0.6.1-13
SHA-1	12F301697E0A6A3E52D95651719CAB2FAABF89B0
SHA-256	AE0DABE5510D63424985FA3EB45968E73E96FE760B07BF9614820E6E47267369

Key	Value
FileSize	553488
MD5	55996637474BB80E78AB8175E0982433
PackageDescription	LALR(k) parser generator for Haskell 98 Frown is inspired by the parser generator Happy and uses a syntax quite simular as the syntax used by Happy. Happy only handles LALR(1) grammars while Frown can use more extensive LALR(k) grammars and the parsers generated by Frown are also faster than the parsers generated by Happy. . The salient features of Frown 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, 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	devel
PackageVersion	0.6.1-14
SHA-1	1BA3D0377879CA330EB35A6CDA528ED098B5F8B4
SHA-256	2E7B2C5B271BF606F804F09FDC00F3F1925A204168F54C052FBE7ED4DC2EC391

Key	Value
FileSize	574162
MD5	0711B884DB63543E50F38482115E4B33
PackageDescription	LALR(k) parser generator for Haskell 98 Frown is inspired by the parser generator Happy and uses a syntax quite simular as the syntax used by Happy. Happy only handles LALR(1) grammars while Frown can use more extensive LALR(k) grammars and the parsers generated by Frown are also faster than the parsers generated by Happy. . The salient features of Frown 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, 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	devel
PackageVersion	0.6.1-14
SHA-1	1C296A1F160C3F2DD5DF813EE55FD9DA4D08EF0E
SHA-256	A0B5CBC37CC766D7301491E652ADFA8C806EE8766A76F89352A234828550A4EB

Key	Value
FileSize	563396
MD5	5180FE28B5F47328886488547BF2785A
PackageDescription	Manual of the frown parser generator for Haskell 98 The manual and examples of the frown LALR(k) parser generator. , Frown is inspired by the parser generator Happy and uses a syntax quite simular as the syntax used by Happy. Happy only handles LALR(1) grammars while Frown can use more extensive LALR(k) grammars and the parsers generated by Frown are also faster than the parsers generated by Happy. . The salient features of Frown 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, 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.1-12
SHA-1	1D40ADBA5EC953E0BCE1590136FD2CA275DB1C62
SHA-256	B919057C84A5A8CE102391CD36B6583B25E51B4421A2D6C3AF74BBE6F887071E

Key	Value
FileSize	1463000
MD5	F0A050E57DC142D5C4C7242AAFA1C4A7
PackageDescription	LALR(k) parser generator for Haskell 98 Frown is inspired by the parser generator Happy and uses a syntax quite simular as the syntax used by Happy. Happy only handles LALR(1) grammars while Frown can use more extensive LALR(k) grammars and the parsers generated by Frown are also faster than the parsers generated by Happy. . The salient features of Frown 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, 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	devel
PackageVersion	0.6.1-12
SHA-1	260A3D213381C5D5675C8627E7FBE03DEB58FEB7
SHA-256	C323D4BE0250D19643600BB9B2E067DAFBDF45E10FEE96D93100F2D864F49CA7

Key	Value
FileSize	556204
MD5	C6D9369AC3CDDFE5A18B760630D2F903
PackageDescription	LALR(k) parser generator for Haskell 98 Frown is inspired by the parser generator Happy and uses a syntax quite simular as the syntax used by Happy. Happy only handles LALR(1) grammars while Frown can use more extensive LALR(k) grammars and the parsers generated by Frown are also faster than the parsers generated by Happy. . The salient features of Frown 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, 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	devel
PackageVersion	0.6.1-11
SHA-1	2CAB2F5B27E2DAFDC9A0E21080FE06069341B738
SHA-256	15AF4FC78AF86D6571ACEF1FD2DEC9A768A98DEE8C45570F8057C11183E730C6

Key	Value
FileSize	553660
MD5	B16F712CE20BAFD72B4EC830EB301C5C
PackageDescription	LALR(k) parser generator for Haskell 98 Frown is inspired by the parser generator Happy and uses a syntax quite simular as the syntax used by Happy. Happy only handles LALR(1) grammars while Frown can use more extensive LALR(k) grammars and the parsers generated by Frown are also faster than the parsers generated by Happy. . The salient features of Frown 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, 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	devel
PackageVersion	0.6.1-13
SHA-1	35C87FD44E90BBD841AC19531D436C80B43FBFCB
SHA-256	08BE6971243B113055CA9170B496F74D043EE118F64F274E23F34D15A0B54CED

Key	Value
FileSize	564000
MD5	C09319D36FAD4BD1A1944694463E1BEA
PackageDescription	Manual of the frown parser generator for Haskell 98 The manual and examples of the frown LALR(k) parser generator. , Frown is inspired by the parser generator Happy and uses a syntax quite simular as the syntax used by Happy. Happy only handles LALR(1) grammars while Frown can use more extensive LALR(k) grammars and the parsers generated by Frown are also faster than the parsers generated by Happy. . The salient features of Frown 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, 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.1-13
SHA-1	364C97306A4F546CDF35907BD9F334F0AD8F4B62
SHA-256	1B5EC951566D57B4839A2C12337EC9D4FCA7FDE198CB41D7583C51DDE8B67BD1

Key	Value
FileSize	1465900
MD5	363C557A82D88E38AA5C361C1198ED09
PackageDescription	LALR(k) parser generator for Haskell 98 Frown is inspired by the parser generator Happy and uses a syntax quite simular as the syntax used by Happy. Happy only handles LALR(1) grammars while Frown can use more extensive LALR(k) grammars and the parsers generated by Frown are also faster than the parsers generated by Happy. . The salient features of Frown 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, 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	devel
PackageVersion	0.6.1-14
SHA-1	4469A65C7E488A37AC39421F17E45177B4417C00
SHA-256	EBB0A3C36DA46828EB29F514B2C929E4D77122A1EDF32187BFE7DE3D0271D8F8

Key	Value
FileSize	543914
MD5	7634D19593D4D203236C084DB5D946FC
PackageDescription	Manual of the frown parser generator for Haskell 98 The manual and examples of the frown LALR(k) parser generator. . Frown is inspired by the parser generator Happy and uses a syntax quite simular as the syntax used by Happy. Happy only handles LALR(1) grammars while Frown can use more extensive LALR(k) grammars and the parsers generated by Frown are also faster than the parsers generated by Happy. . The salient features of Frown 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, 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.1-14
SHA-1	4CD838C52831675A627E55C86CCF0235FCAFAABF
SHA-256	8D6AC933C52C2796BC765B7E65020151BA083331B20DBD01EAA0D5874008DC21