Parents (Total: 16)

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

Key	Value
FileSize	678834
MD5	D2B11E538B9C8B1111732A7549AE9995
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 MOTU Developers <ubuntu-motu@lists.ubuntu.com>
PackageName	frown-doc
PackageSection	doc
PackageVersion	0.6.1-9
SHA-1	48EBA95007969C96A2ACC21B718517183C7BFB53
SHA-256	FC88943F03DE0C948E0B1094E3BA746DD900A0153410573B22087C9D2E15BCB2

Key	Value
FileSize	453168
MD5	C4FD0A99F9A7C27EF93E122AC9354216
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 MOTU Developers <ubuntu-motu@lists.ubuntu.com>
PackageName	frown
PackageSection	devel
PackageVersion	0.6.1-9
SHA-1	4C40AC3CCC170F3F3EFE463A0245882C8AF2232D
SHA-256	BEA4D7B86495AAA0D84528ED146A9146FB444C6B4C2DB7AE36A838B962DB4905

Key	Value
FileSize	678872
MD5	AB5763FC268F7D46DBE060FEE4CDE820
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 MOTU Developers <ubuntu-motu@lists.ubuntu.com>
PackageName	frown-doc
PackageSection	doc
PackageVersion	0.6.1-9
SHA-1	5848C784343DA272D59627AF3150854FD6F46781
SHA-256	678C16A16B512473D0FA06ECC267E80CA2858E38BC04040EE184B2BA5B6C52D5

Key	Value
FileSize	678802
MD5	51EF32B17420C684DD28702795E68235
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	Arjan Oosting <arjan@debian.org>
PackageName	frown-doc
PackageSection	doc
PackageVersion	0.6.1-9
SHA-1	5D0F6B6677E1B01C5CC70800E225C83423CE057C
SHA-256	8D6F7212957B4FAC3EA51D242FD91A885C247A022B3FC82045CE5BF1126AAAC1

Key	Value
FileSize	678860
MD5	4518711CE5E76361C52273A42F443BD9
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 MOTU Developers <ubuntu-motu@lists.ubuntu.com>
PackageName	frown-doc
PackageSection	doc
PackageVersion	0.6.1-9
SHA-1	63E495F86DA9E2902AC4BB5611FC86B481C6FA8D
SHA-256	E24F0D9F34BA70E803143D5FB60C685F3EE546A01F1F25DD6BCAA5DC532CF141

Key	Value
FileSize	1171682
MD5	0073158DF4E8CED38B04B7FFD7D18534
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 MOTU Developers <ubuntu-motu@lists.ubuntu.com>
PackageName	frown
PackageSection	devel
PackageVersion	0.6.1-9
SHA-1	74EC07F07A54B6DD8A67446E4C4D71FC11355887
SHA-256	BBFCA87DC375C0D821C1326DCA5C303F3BE5CF4C7A9DE22208FF80591E2E7433

Key	Value
FileSize	453574
MD5	FBB90BDE909D8EC3169C2F604251728C
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 MOTU Developers <ubuntu-motu@lists.ubuntu.com>
PackageName	frown
PackageSection	devel
PackageVersion	0.6.1-9
SHA-1	930D2A4B22887F5385F04263C7C6BF0103C6856B
SHA-256	0EE4D95FD7F7C93B8DE848FFF9A0D6ACA0DD36264629936D9526BAF5CE05087C

Key	Value
FileSize	678848
MD5	18CA180578BA11FAC5648100E47F47AA
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 MOTU Developers <ubuntu-motu@lists.ubuntu.com>
PackageName	frown-doc
PackageSection	doc
PackageVersion	0.6.1-9
SHA-1	9A33F46C0DBFDBE3E181D3364DD871EF603DF5CA
SHA-256	8B579909B0FCCCB05F778333B5AA3F76B1D2CE97CBA0FF09E6507C8FA24884BF

Key	Value
FileSize	1460344
MD5	DDC80AF8E17F282BADFE3F273D03011A
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	Arjan Oosting <arjan@debian.org>
PackageName	frown
PackageSection	devel
PackageVersion	0.6.1-9
SHA-1	A2E8913202CF68BA89BEB59BEA6C71C79ED4319F
SHA-256	4F18A8CA49604D8ED96B00EDA7F99CED66812653CBFEFCD44B6A471A32201977

Key	Value
FileSize	678886
MD5	4CE30AEE0CDBC36C25CA8134FA07368B
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 MOTU Developers <ubuntu-motu@lists.ubuntu.com>
PackageName	frown-doc
PackageSection	doc
PackageVersion	0.6.1-9
SHA-1	A52115B6557C2AF18B421CCDCA7A58DA513ADA34
SHA-256	8652A752F08494DE4800D20F9D3FFAEB3A88A30D257F41EF652C2E3EC2B49D41