Stan Report

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
Version0.0.1.0
Git RevisionUNKNOWN
Release DateUNKNOWN
System Info
Operating Systemlinux
Architecturex86_64
Compilerghc
Compiler Version8.10
Environment
Environment VariablesSTAN_USE_DEFAULT_CONFIG=True
TOML configuration files/home/kamil-adam/git/helvm/helms/.stan.toml
CLI arguments-s --hide-solution report

Project Info

Information about the analysed project

Project namehelms
Cabal Fileshelms.cabal
HIE Files Directory.hie
Files Number43

Analysis Info

Summary stats from the static analysis

Modules43
LoC2049
Extensions31
SafeHaskell Extensions0
Available inspections44
Checked inspections44
Found Observations8
Ignored Observations0

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.

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.

📄 hs/src/HelVM/HelMS/Calculus/Lambda.hs

  • ModuleHelVM.HelMS.Calculus.Lambda
    Lines of Code27
    1. Unable to extract extensions

    1. Observations

      IDOBS-STAN-0206-33bV0z-19:9
      SeverityPerformance
      DescriptionDefining lazy fields in data types can lead to unexpected space leaks
      Inspection IDSTAN-0206
      Category
      • SpaceLeak
      • Syntax
      Filehs/src/HelVM/HelMS/Calculus/Lambda.hs
        18 ┃ 
  19 ┃   | App Lambda Lambda
  20 ┃         ^^^^^^

      Possible solutions

      • Add '!' before the type, e.g. !Int or !(Maybe Bool)
      • Enable the 'StrictData' extension: {-# LANGUAGE StrictData #-}
      IDOBS-STAN-0206-33bV0z-19:16
      SeverityPerformance
      DescriptionDefining lazy fields in data types can lead to unexpected space leaks
      Inspection IDSTAN-0206
      Category
      • SpaceLeak
      • Syntax
      Filehs/src/HelVM/HelMS/Calculus/Lambda.hs
        18 ┃ 
  19 ┃   | App Lambda Lambda
  20 ┃                ^^^^^^

      Possible solutions

      • Add '!' before the type, e.g. !Int or !(Maybe Bool)
      • Enable the 'StrictData' extension: {-# LANGUAGE StrictData #-}
      IDOBS-STAN-0206-33bV0z-20:9
      SeverityPerformance
      DescriptionDefining lazy fields in data types can lead to unexpected space leaks
      Inspection IDSTAN-0206
      Category
      • SpaceLeak
      • Syntax
      Filehs/src/HelVM/HelMS/Calculus/Lambda.hs
        19 ┃ 
  20 ┃   | Abs Identifier Lambda
  21 ┃         ^^^^^^^^^^

      Possible solutions

      • Add '!' before the type, e.g. !Int or !(Maybe Bool)
      • Enable the 'StrictData' extension: {-# LANGUAGE StrictData #-}
      IDOBS-STAN-0206-33bV0z-20:20
      SeverityPerformance
      DescriptionDefining lazy fields in data types can lead to unexpected space leaks
      Inspection IDSTAN-0206
      Category
      • SpaceLeak
      • Syntax
      Filehs/src/HelVM/HelMS/Calculus/Lambda.hs
        19 ┃ 
  20 ┃   | Abs Identifier Lambda
  21 ┃                    ^^^^^^

      Possible solutions

      • Add '!' before the type, e.g. !Int or !(Maybe Bool)
      • Enable the 'StrictData' extension: {-# LANGUAGE StrictData #-}
      IDOBS-STAN-0206-33bV0z-21:9
      SeverityPerformance
      DescriptionDefining lazy fields in data types can lead to unexpected space leaks
      Inspection IDSTAN-0206
      Category
      • SpaceLeak
      • Syntax
      Filehs/src/HelVM/HelMS/Calculus/Lambda.hs
        20 ┃ 
  21 ┃   | Var Identifier
  22 ┃         ^^^^^^^^^^

      Possible solutions

      • Add '!' before the type, e.g. !Int or !(Maybe Bool)
      • Enable the 'StrictData' extension: {-# LANGUAGE StrictData #-}
      IDOBS-STAN-0206-33bV0z-22:9
      SeverityPerformance
      DescriptionDefining lazy fields in data types can lead to unexpected space leaks
      Inspection IDSTAN-0206
      Category
      • SpaceLeak
      • Syntax
      Filehs/src/HelVM/HelMS/Calculus/Lambda.hs
        21 ┃ 
  22 ┃   | Nat Natural
  23 ┃         ^^^^^^^

      Possible solutions

      • Add '!' before the type, e.g. !Int or !(Maybe Bool)
      • Enable the 'StrictData' extension: {-# LANGUAGE StrictData #-}
      IDOBS-STAN-0206-33bV0z-23:9
      SeverityPerformance
      DescriptionDefining lazy fields in data types can lead to unexpected space leaks
      Inspection IDSTAN-0206
      Category
      • SpaceLeak
      • Syntax
      Filehs/src/HelVM/HelMS/Calculus/Lambda.hs
        22 ┃ 
  23 ┃   | Com Identifier Lambda
  24 ┃         ^^^^^^^^^^

      Possible solutions

      • Add '!' before the type, e.g. !Int or !(Maybe Bool)
      • Enable the 'StrictData' extension: {-# LANGUAGE StrictData #-}
      IDOBS-STAN-0206-33bV0z-23:20
      SeverityPerformance
      DescriptionDefining lazy fields in data types can lead to unexpected space leaks
      Inspection IDSTAN-0206
      Category
      • SpaceLeak
      • Syntax
      Filehs/src/HelVM/HelMS/Calculus/Lambda.hs
        22 ┃ 
  23 ┃   | Com Identifier Lambda
  24 ┃                    ^^^^^^

      Possible solutions

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

    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.

    ActionFilterScope

    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

    Warning
    • 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

    Warning
    • 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

    Warning
    • 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

    Warning
    • 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

    Warning
    • Partial
    • List

    Inspection STAN-0006

    Partial: base/cycle

    Usage of partial function 'cycle' for lists

    Warning
    • 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

    Warning
    • Partial
    • List

    Inspection STAN-0008

    Partial: base/fromJust

    Usage of partial function 'fromJust' for 'Maybe'

    Warning
    • 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'

    Warning
    • 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

    Warning
    • 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

    Warning
    • 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

    Warning
    • 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

    Warning
    • Partial

    Inspection STAN-0014

    Partial: base/minimum

    Usage of partial function 'minimum' for

    Warning
    • Partial

    Inspection STAN-0015

    Partial: base/maximumBy

    Usage of partial function 'maximumBy' for

    Warning
    • Partial

    Inspection STAN-0016

    Partial: base/minimumBy

    Usage of partial function 'minimumBy' for

    Warning
    • Partial

    Inspection STAN-0017

    Partial: base/foldl1

    Usage of partial function 'foldl1' for

    Warning
    • Partial

    Inspection STAN-0018

    Partial: base/foldl1'

    Usage of partial function 'foldl1'' for lists

    Warning
    • 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

    Warning
    • Partial

    Inspection STAN-0020

    Partial: base/fromList

    Usage of partial function 'fromList' for

    Warning
    • Partial

    Inspection STAN-0021

    Partial: base/fromInteger

    Usage of partial function 'fromInteger' for

    Warning
    • Partial

    Inspection STAN-0101

    Infinite: base/reverse

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

    PotentialBug
    • 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

    PotentialBug
    • 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

    PotentialBug
    • 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

    PotentialBug
    • 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

    PotentialBug
    • 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

    PotentialBug
    • 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

    PotentialBug
    • 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'

    Error
    • 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

    Error
    • 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

    Performance
    • 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

    Performance
    • 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

    Performance
    • 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

    PotentialBug
    • 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

    Performance
    • 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

    Performance
    • 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

    Performance
    • 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

    Error
    • 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

    Error
    • 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

    Warning
    • 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'

    Performance
    • 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

    Error
    • 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

    Style
    • 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

    Style
    • 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

    SeverityDescription
    StyleCode style issues. Usually harmless.
    PerformanceSerious defects that could cause slowness and space leaking.
    PotentialBugHuman errors in code.
    WarningPotential runtime errors on some inputs.
    ErrorDangerous behaviour.