show-prettyprint 0.1.0.0 → 0.1.0.1
raw patch · 3 files changed
+238/−2 lines, 3 filesPVP ok
version bump matches the API change (PVP)
API changes (from Hackage documentation)
Files
- .stylish-haskell.yaml +154/−0
- README.md +81/−0
- show-prettyprint.cabal +3/−2
+ .stylish-haskell.yaml view
@@ -0,0 +1,154 @@+# stylish-haskell configuration file+# ==================================++# The stylish-haskell tool is mainly configured by specifying steps. These steps+# are a list, so they have an order, and one specific step may appear more than+# once (if needed). Each file is processed by these steps in the given order.+steps:+ # Convert some ASCII sequences to their Unicode equivalents. This is disabled+ # by default.+ # - unicode_syntax:+ # # In order to make this work, we also need to insert the UnicodeSyntax+ # # language pragma. If this flag is set to true, we insert it when it's+ # # not already present. You may want to disable it if you configure+ # # language extensions using some other method than pragmas. Default:+ # # true.+ # add_language_pragma: true++ # Import cleanup+ - imports:+ # There are different ways we can align names and lists.+ #+ # - global: Align the import names and import list throughout the entire+ # file.+ #+ # - file: Like global, but don't add padding when there are no qualified+ # imports in the file.+ #+ # - group: Only align the imports per group (a group is formed by adjacent+ # import lines).+ #+ # - none: Do not perform any alignment.+ #+ # Default: global.+ align: group++ # Folowing options affect only import list alignment.+ #+ # List align has following options:+ #+ # - after_alias: Import list is aligned with end of import including+ # 'as' and 'hiding' keywords.+ #+ # > import qualified Data.List as List (concat, foldl, foldr, head,+ # > init, last, length)+ #+ # - with_alias: Import list is aligned with start of alias or hiding.+ #+ # > import qualified Data.List as List (concat, foldl, foldr, head,+ # > init, last, length)+ #+ # - new_line: Import list starts always on new line.+ #+ # > import qualified Data.List as List+ # > (concat, foldl, foldr, head, init, last, length)+ #+ # Default: after alias+ list_align: after_alias++ # Long list align style takes effect when import is too long. This is+ # determined by 'columns' setting.+ #+ # - inline: This option will put as much specs on same line as possible.+ #+ # - new_line: Import list will start on new line.+ #+ # - new_line_multiline: Import list will start on new line when it's+ # short enough to fit to single line. Otherwise it'll be multiline.+ #+ # - multiline: One line per import list entry.+ # Type with contructor list acts like single import.+ #+ # > import qualified Data.Map as M+ # > ( empty+ # > , singleton+ # > , ...+ # > , delete+ # > )+ #+ # Default: inline+ long_list_align: new_line_multiline++ # List padding determines indentation of import list on lines after import.+ # This option affects 'list_align' and 'long_list_align'.+ list_padding: 4++ # Separate lists option affects formating of import list for type+ # or class. The only difference is single space between type and list+ # of constructors, selectors and class functions.+ #+ # - true: There is single space between Foldable type and list of it's+ # functions.+ #+ # > import Data.Foldable (Foldable (fold, foldl, foldMap))+ #+ # - false: There is no space between Foldable type and list of it's+ # functions.+ #+ # > import Data.Foldable (Foldable(fold, foldl, foldMap))+ #+ # Default: true+ separate_lists: true++ # Language pragmas+ - language_pragmas:+ # We can generate different styles of language pragma lists.+ #+ # - vertical: Vertical-spaced language pragmas, one per line.+ #+ # - compact: A more compact style.+ #+ # - compact_line: Similar to compact, but wrap each line with+ # `{-#LANGUAGE #-}'.+ #+ # Default: vertical.+ style: vertical++ # Align affects alignment of closing pragma brackets.+ #+ # - true: Brackets are aligned in same collumn.+ #+ # - false: Brackets are not aligned together. There is only one space+ # between actual import and closing bracket.+ #+ # Default: true+ align: true++ # stylish-haskell can detect redundancy of some language pragmas. If this+ # is set to true, it will remove those redundant pragmas. Default: true.+ remove_redundant: true++ # Align the types in record declarations+ # - records: {}++ # Replace tabs by spaces. This is disabled by default.+ # - tabs:+ # # Number of spaces to use for each tab. Default: 8, as specified by the+ # # Haskell report.+ # spaces: 8++ # Remove trailing whitespace+ - trailing_whitespace: {}++# A common setting is the number of columns (parts of) code will be wrapped+# to. Different steps take this into account. Default: 80.+columns: 80++# Sometimes, language extensions are specified in a cabal file or from the+# command line instead of using language pragmas in the file. stylish-haskell+# needs to be aware of these, so it can parse the file correctly.+#+# No language extensions are enabled by default.+# language_extensions:+ # - TemplateHaskell+ # - QuasiQuotes
+ README.md view
@@ -0,0 +1,81 @@+Prettyprint `Show` output+=========================++Output of nested data structures by `Show` instances is often very hard to read.+This package offers a simple function to insert line breaks and indentation into+that ouput so that the semantics are unchanged, but makes it *much* easier to+read.++The package does not rely on a parser for actual Haskell; instead, it merely+reacts on parentheses, commas and the like. This makes it fairly robust even in+the face of invalid `Show` instances, that may not produce valid Haskell code.++++## Examples++### Artificial++```haskell+Hello Foo ("(Bar", Haha) (Baz (A { foo = C, bar = D, qux = (E,"He)llo World!",G,+ H,[A,B,c,d,e,Fghi]) } ) (B,C) [Baz A1 B2, (Baz A3 (B4)), (Baz A5 (B6)), (Baz+ (A7) B8)]) (Foo) (Bar) (Baz (A) (B))++==>++Hello Foo ("(Bar",Haha)+ (Baz (A {foo = C+ ,bar = D+ ,qux = (E+ ,"He)llo World!"+ ,G+ ,H+ ,[A,B,c,d,e,Fghi])})+ (B,C)+ [Baz A1 B2+ ,(Baz A3 (B4))+ ,(Baz A5 (B6))+ ,(Baz (A7) B8)])+ (Foo)+ (Bar)+ (Baz (A) (B))+```++### Inspired by a real AST++```haskell+Set (fromList [(Name "A string with (parenthesis",Ann (Entry (Quality 1 1)+ (Ann False) (Ann (Map [Ann (Bound (Ann (Id "lorem"))),Ann (Variable+ (Ann (Id "ipsum")))])))),(Name "string",Ann (Entry (Quality 1 1) (Ann+ True) (Ann (Internal (Ann (Reduce (Ann (Id "dolor")) (Ann (Id "sit")))))+ ))),(Name "Another } here",Ann (Entry (Quality 1 1) (Ann (Or [Ann (Not+ (Ann (Is (Ann Flagged) (Ann Type) (Ann (Multi [Ann (Literal (Ann One))+ ]))))),Ann (Is (Ann Flagged) (Ann Type) (Ann (Multi [Ann (Literal (Ann+ Three))]))),Ann (Is (Ann Flagged) (Ann Type) (Ann (Multi [Ann (Literal+ (Ann Two))])))])) (Ann (Internal (Ann (Concat (Ann (Id "amet"))))))))])++==>++Set (fromList [(Name "A string with (parenthesis"+ ,Ann (Entry (Quality 1 1)+ (Ann False)+ (Ann (Map [Ann (Bound (Ann (Id "lorem")))+ ,Ann (Variable (Ann (Id "ipsum")))]))))+ ,(Name "string"+ ,Ann (Entry (Quality 1 1)+ (Ann True)+ (Ann (Internal (Ann (Reduce (Ann (Id "dolor"))+ (Ann (Id "sit"))))))))+ ,(Name "Another } here"+ ,Ann (Entry (Quality 1 1)+ (Ann (Or [Ann (Not (Ann (Is (Ann Flagged)+ (Ann Type)+ (Ann (Multi [Ann (Literal (Ann One))])))))+ ,Ann (Is (Ann Flagged)+ (Ann Type)+ (Ann (Multi [Ann (Literal (Ann Three))])))+ ,Ann (Is (Ann Flagged)+ (Ann Type)+ (Ann (Multi [Ann (Literal (Ann Two))])))]))+ (Ann (Internal (Ann (Concat (Ann (Id "amet"))))))))])+```
show-prettyprint.cabal view
@@ -1,5 +1,5 @@ name: show-prettyprint-version: 0.1.0.0+version: 0.1.0.1 synopsis: Robust prettyprinter for output of auto-generated Show instances description: See README.md@@ -11,7 +11,8 @@ copyright: David Luposchainsky, 2016 category: User Interfaces, Text build-type: Simple--- extra-source-files:+extra-source-files: README.md+ , .stylish-haskell.yaml cabal-version: >=1.10 library