Result for 3559D56E989CBF274D8F615D7288485B77B79D9C

Query result

Key Value
FileName./usr/share/doc/frown/copyright
FileSize3035
MD5C6739DE628C2A72DD5B3E720BA5A031A
SHA-13559D56E989CBF274D8F615D7288485B77B79D9C
SHA-256D7109992B46E6EF6E161D51FF603C1DD5D21071D7A06617FA58608A89BC37484
SSDEEP48:E56UkOpgEyvHqonbW0+OdJxJzwhNPPaG7s3Hs3Erm33tqjHv:E56Lf3dqcdJxJzwbaib4jP
TLSHT1D651E65F308087778AC126813996AECCF25ED62E39779800345DA34D8F1B92E90F25AA
hashlookup:parent-total7
hashlookup:trust85

Network graph view

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
FileSize1268832
MD503543E40F344755510468FD252B120C3
PackageDescriptionLALR(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.
PackageMaintainerUbuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
PackageNamefrown
PackageSectionmisc
PackageVersion0.6.2.3-5
SHA-10D12E43D84F15E1B722EB6EFE4B6802FC8683A14
SHA-2561A25C36C0CB59F82D4552814498039AE0BA48E41D3453EB5C4DE5A79D48A4E04
Key Value
FileSize468612
MD57FD0FF60B254A3D3ABE0A38A9F3BC91F
PackageDescriptionLALR(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.
PackageMaintainerUbuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
PackageNamefrown-doc
PackageSectiondoc
PackageVersion0.6.2.3-5
SHA-140A3F919DED8898AC8E551DA3325BE2206CCBBF3
SHA-256E5999F59150ECE6662AD72D3190784574050B6241142997194A138EF51DF12A8
Key Value
FileSize468756
MD5CB45102A1D0C612E3BFA3A1426FF1638
PackageDescriptionLALR(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.
PackageMaintainerUbuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
PackageNamefrown
PackageSectionmisc
PackageVersion0.6.2.3-5
SHA-120A38B6FA36FDE98B97AB80CC7FEDA511D6C9266
SHA-256C90D267BB41649B0252F98B7B5F4CA7559D053212F701EE12C7A5C8177F85DA1
Key Value
FileSize1812644
MD5D2D31B17E5CE41A43F051DAF08368F44
PackageDescriptionLALR(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.
PackageMaintainerUbuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
PackageNamefrown
PackageSectionmisc
PackageVersion0.6.2.3-5
SHA-1504579914B5BA04C12BE81679DB69CBAE580ADDB
SHA-25698727D874844ECCB1606107FE75EB07909E2607B8924D45478541ED5FEE66276
Key Value
FileSize1163344
MD5AFCF8516E9BA10EF2A759E7C5C15B1BF
PackageDescriptionLALR(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.
PackageMaintainerUbuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
PackageNamefrown
PackageSectionmisc
PackageVersion0.6.2.3-5
SHA-16BF202D782251697D43E412CDE7445FA568D8333
SHA-2562A11763F067EF2633F7F71942651DF283730CBF5C3C03E9B3F3A5BE0B17794E4
Key Value
FileSize1007800
MD531472FDBFD33778219AA5372565123CF
PackageDescriptionLALR(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.
PackageMaintainerUbuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
PackageNamefrown
PackageSectionmisc
PackageVersion0.6.2.3-5
SHA-1B9EE336981057CD51948B12767A0741ADBAF43B1
SHA-2567772121359FE06BF5771839A1DD274CA4ADF0E76DFE37C0918654C277180D466
Key Value
FileSize467216
MD59B8FCB3A0C4E83D3AE089719DCBE8AE5
PackageDescriptionLALR(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.
PackageMaintainerUbuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
PackageNamefrown
PackageSectionmisc
PackageVersion0.6.2.3-5
SHA-132D6B8341B724D2E365B8E432CA6ED6DBB924194
SHA-256698E884D8056127CE11F12DEC77679A94573CBADC2C7125C1EE6E79366B1864D