This is the Haskell Static Analysis report generated by Stan

## Stan Info

In this section, you can find the general information about the used Stan tool, compile-time and run-time environment variables and settings, including build information, system data and execution configurations.

Stan Version | |

Version | 0.0.1.0 |

Git Revision | UNKNOWN |

Release Date | UNKNOWN |

System Info | |

Operating System | linux |

Architecture | x86_64 |

Compiler | ghc |

Compiler Version | 8.10 |

Environment | |

Environment Variables | STAN_USE_DEFAULT_CONFIG=True |

TOML configuration files | /home/kamil-adam/git/helvm/helct/.stan.toml |

CLI arguments | -s --hide-solution report |

## Project Info

Information about the analysed project

Project name | helct |

Cabal Files | helct.cabal |

HIE Files Directory | .hie |

Files Number | 4 |

## Analysis Info

Summary stats from the static analysis

Modules | 4 |

LoC | 14 |

Extensions | 29 |

SafeHaskell Extensions | 0 |

Available inspections | 44 |

Checked inspections | 44 |

Found Observations | 0 |

Ignored Observations | 0 |

## Static Analysis Summary

Here you can find the overall conclusion based on the various metadata and gathered information during the work of Stan on this project.

#### Project health: 100%

This number was calculated based on the total number of used inspections and the number of triggered inspections in the project. The calculated number also defines the overall project health status.#### The project is healthy

Excellent work! Stan haven't found any vulnerabilities in the code.#### Congratulations! Your project has zero vulnerabilities!

Stan carefully run all configured inspection and found 0 observations and vulnerabilities to the project.

## Observations

Based on the analysis results, Stan found different vulnerabilities distributed among the analysed files. In Stan terminology, we call such vulnerability as Observation. Below you can see the more detailed information about each observation, and find the possible ways to fix them for your project.

## Configurations

This section describes the final Stan configuration that was used on the project and explains how this result was assembled. Stan runtime settings have many parts, and each of them can come from different configuration sources. Stan is using Environment variables, TOML configuration file and CLI arguments to get the final results. If some option is specified through the multiple sources, the most prioritized one is used.

Action | Filter | Scope |
---|

#### Configuration Process Information

Information and warnings that were gathered during the configuration assemble process. This helps to understand how different parts of the configurations were retrieved.

- No TOML value is specified for key: check
- No CLI option specified for: checks
- configChecks is set through the source: TOML
- No TOML value is specified for key: remove
- No CLI option specified for: remove
- configRemoved is set through the source: TOML
- No TOML value is specified for key: ignore
- No CLI option specified for: ignore
- configIgnored is set through the source: TOML

## Report Explained

## Inspections

List of Inspections used for analysing the project

### Inspection STAN-0001

**Partial: base/head**

*Usage of partial function 'head' for lists*

- Partial
- List

#### Possible solutions

- Replace list with 'NonEmpty' from 'Data.List.NonEmpty'
- Use explicit pattern-matching over lists

### Inspection STAN-0002

**Partial: base/tail**

*Usage of partial function 'tail' for lists*

- Partial
- List

#### Possible solutions

- Replace list with 'NonEmpty' from 'Data.List.NonEmpty'
- Use explicit pattern-matching over lists

### Inspection STAN-0003

**Partial: base/init**

*Usage of partial function 'init' for lists*

- Partial
- List

#### Possible solutions

- Replace list with 'NonEmpty' from 'Data.List.NonEmpty'
- Use explicit pattern-matching over lists

### Inspection STAN-0004

**Partial: base/last**

*Usage of partial function 'last' for lists*

- Partial
- List

#### Possible solutions

- Replace list with 'NonEmpty' from 'Data.List.NonEmpty'
- Use explicit pattern-matching over lists

### Inspection STAN-0005

**Partial: base/!!**

*Usage of partial function '!!' for lists*

- Partial
- List

### Inspection STAN-0006

**Partial: base/cycle**

*Usage of partial function 'cycle' for lists*

- Partial
- List

#### Possible solutions

- Replace list with 'NonEmpty' from 'Data.List.NonEmpty'
- Use explicit pattern-matching over lists

### Inspection STAN-0007

**Partial: base/genericIndex**

*Usage of partial function 'genericIndex' for lists*

- Partial
- List

### Inspection STAN-0008

**Partial: base/fromJust**

*Usage of partial function 'fromJust' for 'Maybe'*

- Partial

#### Possible solutions

- Use explicit pattern-matching over Maybe
- Use one of the standard functions: 'maybe', 'fromMaybe'

### Inspection STAN-0009

**Partial: base/read**

*Usage of partial function 'read' for parsing 'String'*

- Partial

#### Possible solutions

- Use 'readMaybe' or 'readEither' to handle failed parsing

### Inspection STAN-0010

**Partial: base/succ**

*Usage of partial function 'succ' for enumerable types*

- Partial

#### Possible solutions

- Use '(+ 1)' for integral types (but be aware of arithmetic overflow)
- {Extra dependency} Use 'next' from 'Relude.Extra.Enum' in 'relude'

### Inspection STAN-0011

**Partial: base/pred**

*Usage of partial function 'pred' for enumerable types*

- Partial

#### Possible solutions

- Use '(- 1)' for integral types (but be aware of arithmetic overflow)
- {Extra dependency} Use 'prev' from 'Relude.Extra.Enum' in 'relude'

### Inspection STAN-0012

**Partial: base/toEnum**

*Usage of partial function 'toEnum' for enumerable types*

- Partial

#### Possible solutions

- {Extra dependency} Use 'safeToEnum' from 'Relude.Extra.Enum' in 'relude'

### Inspection STAN-0013

**Partial: base/maximum**

*Usage of partial function 'maximum' for *

- Partial

### Inspection STAN-0014

**Partial: base/minimum**

*Usage of partial function 'minimum' for *

- Partial

### Inspection STAN-0015

**Partial: base/maximumBy**

*Usage of partial function 'maximumBy' for *

- Partial

### Inspection STAN-0016

**Partial: base/minimumBy**

*Usage of partial function 'minimumBy' for *

- Partial

### Inspection STAN-0017

**Partial: base/foldl1**

*Usage of partial function 'foldl1' for *

- Partial

### Inspection STAN-0018

**Partial: base/foldl1'**

*Usage of partial function 'foldl1'' for lists*

- Partial
- List

#### Possible solutions

- Replace list with 'NonEmpty' from 'Data.List.NonEmpty'
- Use explicit pattern-matching over lists

### Inspection STAN-0019

**Partial: base/foldr1**

*Usage of partial function 'foldr1' for *

- Partial

### Inspection STAN-0020

**Partial: base/fromList**

*Usage of partial function 'fromList' for *

- Partial

### Inspection STAN-0021

**Partial: base/fromInteger**

*Usage of partial function 'fromInteger' for *

- Partial

### Inspection STAN-0101

**Infinite: base/reverse**

*Usage of the 'reverse' function that hangs on infinite lists*

- Infinite
- List

#### Possible solutions

- Don't use 'reverse' if you expect your function to work with infinite lists
- {Extra dependency} Use the 'slist' library for fast and safe functions on infinite lists

### Inspection STAN-0102

**Infinite: base/isSuffixOf**

*Usage of the 'isSuffixOf' function that hangs on infinite lists*

- Infinite
- List

#### Possible solutions

- Don't use 'isSuffixOf' if you expect your function to work with infinite lists
- {Extra dependency} Use the 'slist' library for fast and safe functions on infinite lists

### Inspection STAN-0103

**Infinite: base/length**

*Usage of the 'length' function that hangs on infinite lists*

- Infinite
- List

#### Possible solutions

- Don't use 'length' if you expect your function to work with infinite lists
- {Extra dependency} Use the 'slist' library for fast and safe functions on infinite lists

### Inspection STAN-0104

**Infinite: base/genericLength**

*Usage of the 'genericLength' function that hangs on infinite lists*

- Infinite
- List

#### Possible solutions

- Don't use 'genericLength' if you expect your function to work with infinite lists
- {Extra dependency} Use the 'slist' library for fast and safe functions on infinite lists

### Inspection STAN-0105

**Infinite: base/sum**

*Usage of the 'sum' function that hangs on infinite lists*

- Infinite
- List

#### Possible solutions

- Don't use 'sum' if you expect your function to work with infinite lists
- {Extra dependency} Use the 'slist' library for fast and safe functions on infinite lists

### Inspection STAN-0106

**Infinite: base/product**

*Usage of the 'product' function that hangs on infinite lists*

- Infinite
- List

#### Possible solutions

- Don't use 'product' if you expect your function to work with infinite lists
- {Extra dependency} Use the 'slist' library for fast and safe functions on infinite lists

### Inspection STAN-0201

**Anti-pattern: [0 .. length xs]**

*Creating a list with wrong number of indices*

- AntiPattern

#### Possible solutions

- Replace '[0 .. length xs]' with '[0 .. length xs - 1]'
- Use 'zip [0 ..] xs` to work with list of pairs: index and element

### Inspection STAN-0202

**Anti-pattern: foldl**

*Usage of space-leaking function 'foldl'*

- SpaceLeak
- AntiPattern

#### Possible solutions

- Replace 'foldl' with 'foldl''
- Use 'foldr (flip . f)` instead of 'foldl f'

### Inspection STAN-0203

**Anti-pattern: Data.ByteString.Char8.pack**

*Usage of 'pack' function that doesn't handle Unicode characters*

- AntiPattern

#### Possible solutions

- Convert to 'Text' and use 'encodeUtf8' from 'Data.Text.Encoding'
- {Extra dependency} Use 'encodeUtf8' from 'relude'
- {Extra dependency} Use the 'utf8-string' package

### Inspection STAN-0204

**Anti-pattern: HashMap size**

*Usage of 'size' or 'length' for 'HashMap' that runs in linear time*

- AntiPattern

#### Possible solutions

- {Extra dependency} Switch to 'Map' from 'containers'

### Inspection STAN-0205

**Anti-pattern: HashSet size**

*Usage of 'size' or 'length' for 'HashSet' that runs in linear time*

- AntiPattern

#### Possible solutions

- {Extra dependency} Switch to 'Set' from 'containers'

### Inspection STAN-0206

**Data types with non-strict fields**

*Defining lazy fields in data types can lead to unexpected space leaks*

- SpaceLeak
- Syntax

#### Possible solutions

- Add '!' before the type, e.g. !Int or !(Maybe Bool)
- Enable the 'StrictData' extension: {-# LANGUAGE StrictData #-}

### Inspection STAN-0207

**Anti-pattern: Foldable methods on possibly error-prone structures**

*Usage of Foldable methods on (,), Maybe, Either*

- AntiPattern

#### Possible solutions

- Use more explicit functions with specific monomorphic types

### Inspection STAN-0208

**Anti-pattern: Slow 'length' for Text**

*Usage of 'length' for 'Text' that runs in linear time*

- AntiPattern

#### Possible solutions

- {Extra dependency} Switch to 'ByteString' from 'bytestring'

### Inspection STAN-0209

**Anti-pattern: Slow 'nub' for lists**

*Usage of 'nub' on lists that runs in quadratic time*

- AntiPattern

#### Possible solutions

- {Extra dependency} Switch list to 'Set' from 'containers'
- {Extra dependency} Use 'ordNub/hashNub/sortNub/unstableNub' from 'relude'
- {Extra dependency} Use 'nubOrd' from 'containers'
- {Extra dependency} Use 'nubOrd' from 'extra'

### Inspection STAN-0210

**Anti-pattern: Slow 'for_' on ranges**

*Usage of 'for_' or 'forM_' on numerical ranges is slow*

- AntiPattern

#### Possible solutions

- {Extra dependency} Use 'loop' library for fast monadic looping

### Inspection STAN-0211

**Anti-pattern: '</>' for URLs**

*Usage of '</>' for URLs results in the errors on Windows*

- AntiPattern

#### Possible solutions

- {Extra dependency} Use type-safe library for URLs
- Concatenate URLs with slashes '/'

### Inspection STAN-0212

**Anti-pattern: unsafe functions**

*Usage of unsafe functions breaks referential transparency*

- Unsafe
- AntiPattern

#### Possible solutions

- Remove 'undefined' or at least replace with 'error' to give better error messages
- Replace 'unsafeCoerce' with 'coerce'
- Rewrite the code to avoid using 'unsafePerformIO' and other unsafe IO functions

### Inspection STAN-0213

**Anti-pattern: Pattern matching on '_'**

*Pattern matching on '_' for sum types can create maintainability issues*

- AntiPattern

#### Possible solutions

- Pattern match on each constructor explicitly
- Add meaningful names to holes, e.g. '_anyOtherFailure'

### Inspection STAN-0214

**Anti-pattern: use 'compare'**

*Usage of multiple comparison operators instead of single 'compare'*

- AntiPattern

#### Possible solutions

- Rewrite code to use single 'compare' instead of many comparison operators

### Inspection STAN-0215

**Anti-pattern: Slashes in paths**

*Usage of '/' or '\' in paths results in the errors on different operation systems*

- AntiPattern

#### Possible solutions

- {Extra dependency} Use '</>' operator from 'filepath'

### Inspection STAN-0301

**Missing fixity declaration for operator**

*Using the implicit default fixity for operator: infixl 9*

- Syntax

#### Possible solutions

- Add 'infix[l|r]' declaration to the operator with explicit precedence

### Inspection STAN-0302

**Big tuples**

*Using tuples of big size (>= 4) can decrease code readability*

- AntiPattern
- Syntax

#### Possible solutions

- Consider defining and using a custom data type to improve code comprehension

## Severity

We are using the following severity system to indicate the observation level

Severity | Description |
---|---|

Style | Code style issues. Usually harmless. |

Performance | Serious defects that could cause slowness and space leaking. |

PotentialBug | Human errors in code. |

Warning | Potential runtime errors on some inputs. |

Error | Dangerous behaviour. |