Key | Value |
---|---|
FileName | ./usr/share/doc/frown/copyright |
FileSize | 3035 |
MD5 | C6739DE628C2A72DD5B3E720BA5A031A |
SHA-1 | 3559D56E989CBF274D8F615D7288485B77B79D9C |
SHA-256 | D7109992B46E6EF6E161D51FF603C1DD5D21071D7A06617FA58608A89BC37484 |
SSDEEP | 48:E56UkOpgEyvHqonbW0+OdJxJzwhNPPaG7s3Hs3Erm33tqjHv:E56Lf3dqcdJxJzwbaib4jP |
TLSH | T1D651E65F308087778AC126813996AECCF25ED62E39779800345DA34D8F1B92E90F25AA |
hashlookup:parent-total | 7 |
hashlookup:trust | 85 |
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 |