google/ormolu
1
1
Fork 0
mirror of https://github.com/google/ormolu.git synced 2024-12-02 23:43:34 +03:00
Code Issues Projects Releases Wiki Activity

Drop ‘EXAMPLES.md’

Browse Source 
Now we're checking against many concrete examples, so this file can be
dropped.
This commit is contained in:
mrkkrp 2019-07-05 19:11:35 +02:00
parent 7c7edb8a75
commit 693814ca8c
No known key found for this signature in database
GPG Key ID: 8564658B2889FF7C
1 changed files with 0 additions and 296 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

296
EXAMPLES.md
View File

@ -1,296 +0,0 @@
We aim for a format of Haskell code that minimizes the amount of changes
necessary when modifying a line. For instance the indentation of any
given fragment of code should not depend on the length of identifiers.
```Haskell
longFunctionName :: a
-> b
-> c
-> d
-> (a, b, c, d)
```
Renaming the function requires changing all the lines to
```Haskell
f :: a
-> b
-> c
-> d
-> (a, b, c, d)
```
A preferred alternative is to format like
```Haskell
longFunctionName
:: a
-> b
-> c
-> d
-> (a, b, c, d)
```
We are grabbing some inspiration from
[Elm](https://elm-lang.org/docs/style-guide)
and
[Tweag's](https://github.com/tweag/guides/blob/master/style/Haskell.md)
style guides.
The following examples show how a program is formatted in
multiple lines when the user introduces linebreaks. Otherwise,
the programs would be written in one line.
### Function types
```Haskell
functionName
:: (C1, C2, C3)
=> a
-> b
-> c
-> d
-> (a, b, c, d)
```
Context
```Haskell
functionName
:: ( C1
, C2
, C3
, C4
, C5
)
=> a
-> b
-> c
-> d
-> (a, b, c, d)
```
Arguments
```Haskell
functionName
:: (C1, C2, C3, C4, C5)
=> a
-> b
-> (forall a.
(C6, C7)
=> LongDataTypeName
-> a
-> AnotherLongDataTypeName
-> b
-> c
)
-> (c -> d)
-> (a, b, c, d)
```
```Haskell
functionName
:: (C1, C2, C3, C4, C5)
=> a
-> b
-> ( LongDataTypeName
AnotherLongDataTypeName
AnotherLongDataTypeName2
AnotherLongDataTypeName3
-> a
-> AnotherLongDataTypeName4
-> b
-> c
)
-> (c -> d)
-> (a, b, c, d)
```
### Expressions
```Haskell
f x y z =
if x then longFunctionName y else anotherLongFunctionName z
```
A lambda
```Haskell
f =
\(LongPattern x) ->
longFunctionName x
```
Multiple lambdas
```Haskell
f =
\(LongPattern x) ->
\(LongPattern2 y) ->
longFunctionName x
```
Lambda arguments
```Haskell
f xs =
forM xs $
\( LongPattern x
, LongPattern2 y
) ->
longFunctionName x
```
There is a do block. Note the change of indentation in the
body of `forM`.
```Haskell
f xs = do
forM xs $
\( LongPattern x
, LongPattern2 y
) ->
longFunctionName x
```
`if` expression
```Haskell
f x y z =
if x then
longFunctionName x y
else
anotherLongFunctionName x z
```
`if` expression with monadic blocks
```Haskell
f x y z =
if x then do
longFunctionName1 x y
longFunctionName2 x y
else do
anotherLongFunctionName1 x z
anotherLongFunctionName2 x z
```
Monadic blocks
```Haskell
f x y z = do
functionName1 x y
functionName2 x z
```
`case` expression
```Haskell
f x y z = case
Just w -> functionName x y w
Nothing -> functionName x y z
```
Branches of `case` expression
```Haskell
f x y z = case
Just w ->
longFunctionName x y w
Nothing ->
anotherLongFunctionName x y z
```
A list of arguments
```Haskell
f
(LongPattern x)
(AnotherLongPattern y)
=
functionName x y
```
Guards
```Haskell
f x y
| x > y = True
| otherwise = False
```
The right-hand side of guards
```Haskell
f x y
| x > y =
longFunctionName y
| otherwise =
anotherLongFunctionName x
```
Long guards
```Haskell
function x y z w y
| x > y
, y > z
, z > w
, w > z
=
longFunctionName y
| otherwise =
anotherLongFunctionName x
```
### Data type declarations
Declaration
```Haskell
data A
= B
| C
| D
| E
| F
| G
```
TODO: GADTs, record syntax, type families
### Comments
```Haskell
{- When a comment is not preceded with elements on the same line,
they are indented as the elements in the enclosing AST node or
braces/parenthesis/brackets.
If it is between AST nodes, it is indented as the following
node.
If the end-of-file follows, then indent to column 0.
-}
f = g {- When there are preceding elements, keep single-line comments in the same line. -}
h = g
{- Multi-line comments can't be kept on the same line as @h = g@.
Otherwise, changing h or g would change the indentation of all
the comment lines.
-}
data R = R
{- This comment always follows the R constructor -}
{ f1 :: T1
{- A comment not preceded by other elements -}
{- Another comment -}
, f2 :: T2
, f3 :: T3
}
```
```Haskell
{- a comment line -}
f = h
where
h = g
-- indented the same as g
g = False
```
This example
```Haskell
data R = R {- This comment always follows the R constructor -}
{ f1 :: T1, {- An inner comment -} {- Another inner comment -} f2 :: T2, f3 :: T3}
```
is reformatted to
```Haskell
data R = R
{- This comment always follows the R constructor -}
{ f1 :: T1 {- An inner comment -} {- Another inner comment -}
, f2 :: T2
, f3 :: T3
}
```