From 715d39a51e7d3c47f2dfec57280a75a1b14039e5 Mon Sep 17 00:00:00 2001 From: Kamil Adam Date: Wed, 14 Sep 2022 11:34:40 +0200 Subject: [PATCH] Init --- .github/ISSUE_TEMPLATE/bug_report.md | 38 + .github/ISSUE_TEMPLATE/feature_request.md | 20 + .github/workflows/codacy.yml | 60 + .github/workflows/greetings.yml | 16 + .github/workflows/haskell.yml | 43 + .github/workflows/jekyll.yml | 20 + .github/workflows/label.yml | 22 + .github/workflows/manual.yml | 30 + .github/workflows/stale.yml | 30 + .gitignore | 15 + .hlint.yaml | 3298 +++++++++++++++++ .idea/.gitignore | 3 + .idea/codeStyles/Project.xml | 7 + .idea/codeStyles/codeStyleConfig.xml | 5 + .idea/encodings.xml | 4 + .idea/heltc.iml | 14 + .idea/misc.xml | 6 + .idea/modules.xml | 8 + .idea/sbt.xml | 7 + .idea/thriftCompiler.xml | 6 + .idea/vcs.xml | 6 + .stan.toml | 0 .stylish-haskell.yaml | 359 ++ .travis.yml | 1 + Makefile | 84 + README.md | 2 - Setup.hs | 2 + cabal.project | 7 + docs/Gemfile | 17 + docs/README.md | 27 + docs/_config.yml | 147 + docs/assets/android-chrome-192x192.png | Bin 0 -> 7701 bytes docs/assets/android-chrome-512x512.png | Bin 0 -> 22148 bytes docs/assets/apple-touch-icon.png | Bin 0 -> 7088 bytes docs/assets/favicon-16x16.png | Bin 0 -> 455 bytes docs/assets/favicon-32x32.png | Bin 0 -> 932 bytes docs/assets/favicon.ico | Bin 0 -> 15406 bytes docs/assets/site.webmanifest | 1 + docs/developers/ARCHITECTURE.md | 5 + docs/developers/BUGS.md | 11 + docs/developers/CHANGELOG.md | 7 + docs/developers/CODE_OF_CONDUCT.md | 8 + docs/developers/CONTRIBUTING.md | 18 + docs/developers/ROADMAP.md | 10 + docs/favicon.ico | Bin 0 -> 15406 bytes docs/license/LICENSE | 6 + docs/license/LICENSE-APACHE | 201 + LICENSE => docs/license/LICENSE-MIT | 2 +- docs/reports/heltc-test/hpc_index.html | 12 + docs/reports/heltc-test/hpc_index_alt.html | 12 + docs/reports/heltc-test/hpc_index_exp.html | 12 + docs/reports/heltc-test/hpc_index_fun.html | 12 + docs/reports/heltc/HelVM-HelTC-HelTC.html | 1 + docs/reports/heltc/doc-index.html | 1 + docs/reports/heltc/haddock-bundle.min.js | 2 + docs/reports/heltc/heltc.haddock | Bin 0 -> 135 bytes docs/reports/heltc/index.html | 1 + docs/reports/heltc/linuwial.css | 877 +++++ docs/reports/heltc/meta.json | 1 + docs/reports/heltc/quick-jump.css | 222 ++ docs/reports/heltc/synopsis.png | Bin 0 -> 11327 bytes docs/reports/stan.html | 16 + docs/users/AUTHORS.md | 6 + docs/users/FAQ.md | 9 + docs/users/INSTALL.md | 44 + docs/users/NEWS.md | 11 + docs/users/THANKS.md | 5 + docs/users/TODO.md | 11 + heltc.cabal | 162 + hlint.sh | 3 + hs/app/AppOptions.hs | 1 + hs/app/Main.hs | 4 + hs/benchmark/Main.hs | 17 + hs/src/HelVM/HelTC/HelTC.hs | 2 + .../HelVM/HelTC/Assemblers/Expectations.hs | 34 + hs/test/Main.hs | 10 + hs/test/Spec.hs | 1 + report.sh | 8 + stan.sh | 7 + 79 files changed, 6074 insertions(+), 3 deletions(-) create mode 100644 .github/ISSUE_TEMPLATE/bug_report.md create mode 100644 .github/ISSUE_TEMPLATE/feature_request.md create mode 100644 .github/workflows/codacy.yml create mode 100644 .github/workflows/greetings.yml create mode 100644 .github/workflows/haskell.yml create mode 100644 .github/workflows/jekyll.yml create mode 100644 .github/workflows/label.yml create mode 100644 .github/workflows/manual.yml create mode 100644 .github/workflows/stale.yml create mode 100644 .hlint.yaml create mode 100644 .idea/.gitignore create mode 100644 .idea/codeStyles/Project.xml create mode 100644 .idea/codeStyles/codeStyleConfig.xml create mode 100644 .idea/encodings.xml create mode 100644 .idea/heltc.iml create mode 100644 .idea/misc.xml create mode 100644 .idea/modules.xml create mode 100644 .idea/sbt.xml create mode 100644 .idea/thriftCompiler.xml create mode 100644 .idea/vcs.xml create mode 100644 .stan.toml create mode 100644 .stylish-haskell.yaml create mode 100644 .travis.yml create mode 100644 Makefile delete mode 100644 README.md create mode 100644 Setup.hs create mode 100644 cabal.project create mode 100644 docs/Gemfile create mode 100644 docs/README.md create mode 100644 docs/_config.yml create mode 100644 docs/assets/android-chrome-192x192.png create mode 100644 docs/assets/android-chrome-512x512.png create mode 100644 docs/assets/apple-touch-icon.png create mode 100644 docs/assets/favicon-16x16.png create mode 100644 docs/assets/favicon-32x32.png create mode 100644 docs/assets/favicon.ico create mode 100644 docs/assets/site.webmanifest create mode 100644 docs/developers/ARCHITECTURE.md create mode 100644 docs/developers/BUGS.md create mode 100644 docs/developers/CHANGELOG.md create mode 100644 docs/developers/CODE_OF_CONDUCT.md create mode 100644 docs/developers/CONTRIBUTING.md create mode 100644 docs/developers/ROADMAP.md create mode 100644 docs/favicon.ico create mode 100644 docs/license/LICENSE create mode 100644 docs/license/LICENSE-APACHE rename LICENSE => docs/license/LICENSE-MIT (95%) create mode 100644 docs/reports/heltc-test/hpc_index.html create mode 100644 docs/reports/heltc-test/hpc_index_alt.html create mode 100644 docs/reports/heltc-test/hpc_index_exp.html create mode 100644 docs/reports/heltc-test/hpc_index_fun.html create mode 100644 docs/reports/heltc/HelVM-HelTC-HelTC.html create mode 100644 docs/reports/heltc/doc-index.html create mode 100644 docs/reports/heltc/haddock-bundle.min.js create mode 100644 docs/reports/heltc/heltc.haddock create mode 100644 docs/reports/heltc/index.html create mode 100644 docs/reports/heltc/linuwial.css create mode 100644 docs/reports/heltc/meta.json create mode 100644 docs/reports/heltc/quick-jump.css create mode 100644 docs/reports/heltc/synopsis.png create mode 100644 docs/reports/stan.html create mode 100644 docs/users/AUTHORS.md create mode 100644 docs/users/FAQ.md create mode 100644 docs/users/INSTALL.md create mode 100644 docs/users/NEWS.md create mode 100644 docs/users/THANKS.md create mode 100644 docs/users/TODO.md create mode 100644 heltc.cabal create mode 100755 hlint.sh create mode 100644 hs/app/AppOptions.hs create mode 100644 hs/app/Main.hs create mode 100644 hs/benchmark/Main.hs create mode 100644 hs/src/HelVM/HelTC/HelTC.hs create mode 100644 hs/test/HelVM/HelTC/Assemblers/Expectations.hs create mode 100644 hs/test/Main.hs create mode 100644 hs/test/Spec.hs create mode 100755 report.sh create mode 100755 stan.sh diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md new file mode 100644 index 0000000..dd84ea7 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -0,0 +1,38 @@ +--- +name: Bug report +about: Create a report to help us improve +title: '' +labels: '' +assignees: '' + +--- + +**Describe the bug** +A clear and concise description of what the bug is. + +**To Reproduce** +Steps to reproduce the behavior: +1. Go to '...' +2. Click on '....' +3. Scroll down to '....' +4. See error + +**Expected behavior** +A clear and concise description of what you expected to happen. + +**Screenshots** +If applicable, add screenshots to help explain your problem. + +**Desktop (please complete the following information):** + - OS: [e.g. iOS] + - Browser [e.g. chrome, safari] + - Version [e.g. 22] + +**Smartphone (please complete the following information):** + - Device: [e.g. iPhone6] + - OS: [e.g. iOS8.1] + - Browser [e.g. stock browser, safari] + - Version [e.g. 22] + +**Additional context** +Add any other context about the problem here. diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md new file mode 100644 index 0000000..bbcbbe7 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature_request.md @@ -0,0 +1,20 @@ +--- +name: Feature request +about: Suggest an idea for this project +title: '' +labels: '' +assignees: '' + +--- + +**Is your feature request related to a problem? Please describe.** +A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] + +**Describe the solution you'd like** +A clear and concise description of what you want to happen. + +**Describe alternatives you've considered** +A clear and concise description of any alternative solutions or features you've considered. + +**Additional context** +Add any other context or screenshots about the feature request here. diff --git a/.github/workflows/codacy.yml b/.github/workflows/codacy.yml new file mode 100644 index 0000000..7a846cc --- /dev/null +++ b/.github/workflows/codacy.yml @@ -0,0 +1,60 @@ +# This workflow uses actions that are not certified by GitHub. +# They are provided by a third-party and are governed by +# separate terms of service, privacy policy, and support +# documentation. + +# This workflow checks out code, performs a Codacy security scan +# and integrates the results with the +# GitHub Advanced Security code scanning feature. For more information on +# the Codacy security scan action usage and parameters, see +# https://github.com/codacy/codacy-analysis-cli-action. +# For more information on Codacy Analysis CLI in general, see +# https://github.com/codacy/codacy-analysis-cli. + +name: Codacy Security Scan + +on: + push: + branches: [ master ] + pull_request: + # The branches below must be a subset of the branches above + branches: [ master ] + schedule: + - cron: '36 4 * * 2' + +permissions: + contents: read + +jobs: + codacy-security-scan: + permissions: + contents: read # for actions/checkout to fetch code + security-events: write # for github/codeql-action/upload-sarif to upload SARIF results + name: Codacy Security Scan + runs-on: ubuntu-latest + steps: + # Checkout the repository to the GitHub Actions runner + - name: Checkout code + uses: actions/checkout@v3 + + # Execute Codacy Analysis CLI and generate a SARIF output with the security issues identified during the analysis + - name: Run Codacy Analysis CLI + uses: codacy/codacy-analysis-cli-action@d840f886c4bd4edc059706d09c6a1586111c540b + with: + # Check https://github.com/codacy/codacy-analysis-cli#project-token to get your project token from your Codacy repository + # You can also omit the token and run the tools that support default configurations + project-token: ${{ secrets.CODACY_PROJECT_TOKEN }} + verbose: true + output: results.sarif + format: sarif + # Adjust severity of non-security issues + gh-code-scanning-compat: true + # Force 0 exit code to allow SARIF file generation + # This will handover control about PR rejection to the GitHub side + max-allowed-issues: 2147483647 + + # Upload the SARIF file generated in the previous step + - name: Upload SARIF results file + uses: github/codeql-action/upload-sarif@v2 + with: + sarif_file: results.sarif diff --git a/.github/workflows/greetings.yml b/.github/workflows/greetings.yml new file mode 100644 index 0000000..18ba13f --- /dev/null +++ b/.github/workflows/greetings.yml @@ -0,0 +1,16 @@ +name: Greetings + +on: [pull_request_target, issues] + +jobs: + greeting: + runs-on: ubuntu-latest + permissions: + issues: write + pull-requests: write + steps: + - uses: actions/first-interaction@v1 + with: + repo-token: ${{ secrets.GITHUB_TOKEN }} + issue-message: 'Message that will be displayed on users first issue' + pr-message: 'Message that will be displayed on users first pull request' diff --git a/.github/workflows/haskell.yml b/.github/workflows/haskell.yml new file mode 100644 index 0000000..25f7fa6 --- /dev/null +++ b/.github/workflows/haskell.yml @@ -0,0 +1,43 @@ +name: Haskell CI + +on: + push: + branches: [ master ] + pull_request: + branches: [ master ] + +permissions: + contents: read + +jobs: + build: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v3 + - uses: actions/setup-haskell@v1 + with: + ghc-version: '8.10.3' + cabal-version: '3.2' + + - name: Cache + uses: actions/cache@v3 + env: + cache-name: cache-cabal + with: + path: ~/.cabal + key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/*.cabal') }}-${{ hashFiles('**/cabal.project') }} + restore-keys: | + ${{ runner.os }}-build-${{ env.cache-name }}- + ${{ runner.os }}-build- + ${{ runner.os }}- + + - name: Install dependencies + run: | + cabal update + cabal build --only-dependencies --enable-tests --enable-benchmarks + - name: Build + run: cabal build --enable-tests --enable-benchmarks all + - name: Run tests + run: cabal test all diff --git a/.github/workflows/jekyll.yml b/.github/workflows/jekyll.yml new file mode 100644 index 0000000..5732d6d --- /dev/null +++ b/.github/workflows/jekyll.yml @@ -0,0 +1,20 @@ +name: Jekyll site CI + +on: + push: + branches: [ master ] + pull_request: + branches: [ master ] + +jobs: + build: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v3 + - name: Build the site in the jekyll/builder container + run: | + docker run \ + -v ${{ github.workspace }}:/srv/jekyll -v ${{ github.workspace }}/_site:/srv/jekyll/_site \ + jekyll/builder:latest /bin/bash -c "chmod -R 777 /srv/jekyll && jekyll build --future" diff --git a/.github/workflows/label.yml b/.github/workflows/label.yml new file mode 100644 index 0000000..a8a1bd7 --- /dev/null +++ b/.github/workflows/label.yml @@ -0,0 +1,22 @@ +# This workflow will triage pull requests and apply a label based on the +# paths that are modified in the pull request. +# +# To use this workflow, you will need to set up a .github/labeler.yml +# file with configuration. For more information, see: +# https://github.com/actions/labeler + +name: Labeler +on: [pull_request] + +jobs: + label: + + runs-on: ubuntu-latest + permissions: + contents: read + pull-requests: write + + steps: + - uses: actions/labeler@v4 + with: + repo-token: "${{ secrets.GITHUB_TOKEN }}" diff --git a/.github/workflows/manual.yml b/.github/workflows/manual.yml new file mode 100644 index 0000000..47f24e1 --- /dev/null +++ b/.github/workflows/manual.yml @@ -0,0 +1,30 @@ +# This is a basic workflow that is manually triggered + +name: Manual workflow + +# Controls when the action will run. Workflow runs when manually triggered using the UI +# or API. +on: + workflow_dispatch: + # Inputs the workflow accepts. + inputs: + name: + # Friendly description to be shown in the UI instead of 'name' + description: 'Person to greet' + # Default value if no value is explicitly provided + default: 'World' + # Input has to be provided for the workflow to run + required: true + +# A workflow run is made up of one or more jobs that can run sequentially or in parallel +jobs: + # This workflow contains a single job called "greet" + greet: + # The type of runner that the job will run on + runs-on: ubuntu-latest + + # Steps represent a sequence of tasks that will be executed as part of the job + steps: + # Runs a single command using the runners shell + - name: Send greeting + run: echo "Hello ${{ github.event.inputs.name }}" diff --git a/.github/workflows/stale.yml b/.github/workflows/stale.yml new file mode 100644 index 0000000..51f7955 --- /dev/null +++ b/.github/workflows/stale.yml @@ -0,0 +1,30 @@ +# This workflow warns and then closes issues and PRs that have had no activity for a specified amount of time. +# +# You can adjust the behavior by modifying this file. +# For more information, see: +# https://github.com/actions/stale +name: Mark stale issues and pull requests + +on: + schedule: + - cron: '37 8 * * *' + +jobs: + stale: + + runs-on: ubuntu-latest + permissions: + issues: write + pull-requests: write + + steps: + - uses: actions/stale@v5 + with: + repo-token: ${{ secrets.GITHUB_TOKEN }} + days-before-stale: 365 + days-before-close: 365 + stale-issue-message: 'Stale issue message' + stale-pr-message: 'Stale pull request message' + stale-issue-label: 'no-issue-activity' + stale-pr-label: 'no-pr-activity' + operations-per-run: 1 diff --git a/.gitignore b/.gitignore index 4c9e245..5ca1ccd 100644 --- a/.gitignore +++ b/.gitignore @@ -21,3 +21,18 @@ cabal.project.local cabal.project.local~ .HTF/ .ghc.environment.* + +.idea +*.iml +.gradle +build/ +gradle/ + +Gemfile.lock +_site + +.hlint-*/ +out/ + +/stan.html +*.tix diff --git a/.hlint.yaml b/.hlint.yaml new file mode 100644 index 0000000..695f4b0 --- /dev/null +++ b/.hlint.yaml @@ -0,0 +1,3298 @@ +- arguments: + - "-XConstraintKinds" + - "-XDeriveGeneric" + - "-XGeneralizedNewtypeDeriving" + - "-XLambdaCase" + - "-XOverloadedStrings" + - "-XRecordWildCards" + - "-XScopedTypeVariables" + - "-XStandaloneDeriving" + - "-XTupleSections" + - "-XTypeApplications" + - "-XViewPatterns" +- ignore: + name: Use head +- ignore: + name: Use Foldable.forM_ +- hint: + lhs: "pure ()" + note: "Use 'pass'" + rhs: pass +- hint: + lhs: "return ()" + note: "Use 'pass'" + rhs: pass +- hint: + lhs: "(: [])" + note: "Use `one`" + rhs: one +- hint: + lhs: "(:| [])" + note: "Use `one`" + rhs: one +- hint: + lhs: Data.Sequence.singleton + note: "Use `one`" + rhs: one +- hint: + lhs: Data.Text.singleton + note: "Use `one`" + rhs: one +- hint: + lhs: Data.Text.Lazy.singleton + note: "Use `one`" + rhs: one +- hint: + lhs: Data.ByteString.singleton + note: "Use `one`" + rhs: one +- hint: + lhs: Data.ByteString.Lazy.singleton + note: "Use `one`" + rhs: one +- hint: + lhs: Data.Map.singleton + note: "Use `one`" + rhs: one +- hint: + lhs: Data.Map.Strict.singleton + note: "Use `one`" + rhs: one +- hint: + lhs: Data.HashMap.Strict.singleton + note: "Use `one`" + rhs: one +- hint: + lhs: Data.HashMap.Lazy.singleton + note: "Use `one`" + rhs: one +- hint: + lhs: Data.IntMap.singleton + note: "Use `one`" + rhs: one +- hint: + lhs: Data.IntMap.Strict.singleton + note: "Use `one`" + rhs: one +- hint: + lhs: Data.Set.singleton + note: "Use `one`" + rhs: one +- hint: + lhs: Data.HashSet.singleton + note: "Use `one`" + rhs: one +- hint: + lhs: Data.IntSet.singleton + note: "Use `one`" + rhs: one +- warn: + lhs: Control.Exception.evaluate + rhs: evaluateWHNF +- warn: + lhs: "Control.Exception.evaluate (force x)" + rhs: evaluateNF x +- warn: + lhs: "Control.Exception.evaluate (x `deepseq` ())" + rhs: evaluateNF_ x +- warn: + lhs: "void (evaluateWHNF x)" + rhs: evaluateWHNF_ x +- warn: + lhs: "void (evaluateNF x)" + rhs: evaluateNF_ x +- hint: + lhs: Control.Exception.throw + note: "Use 'impureThrow'" + rhs: impureThrow +- warn: + lhs: Data.Text.IO.readFile + rhs: readFileText +- warn: + lhs: Data.Text.IO.writeFile + rhs: writeFileText +- warn: + lhs: Data.Text.IO.appendFile + rhs: appendFileText +- warn: + lhs: Data.Text.Lazy.IO.readFile + rhs: readFileLText +- warn: + lhs: Data.Text.Lazy.IO.writeFile + rhs: writeFileLText +- warn: + lhs: Data.Text.Lazy.IO.appendFile + rhs: appendFileLText +- warn: + lhs: Data.ByteString.readFile + rhs: readFileBS +- warn: + lhs: Data.ByteString.writeFile + rhs: writeFileBS +- warn: + lhs: Data.ByteString.appendFile + rhs: appendFileBS +- warn: + lhs: Data.ByteString.Lazy.readFile + rhs: readFileLBS +- warn: + lhs: Data.ByteString.Lazy.writeFile + rhs: writeFileLBS +- warn: + lhs: Data.ByteString.Lazy.appendFile + rhs: appendFileLBS +- hint: + lhs: "foldl' (flip f)" + note: "Use 'flipfoldl''" + rhs: "flipfoldl' f" +- warn: + lhs: "foldl' (+) 0" + rhs: sum +- warn: + lhs: "foldl' (*) 1" + rhs: product +- hint: + lhs: "fmap and (sequence s)" + note: Applying this hint would mean that some actions that were being executed previously would no longer be executed. + rhs: andM s +- hint: + lhs: "and <$> sequence s" + note: Applying this hint would mean that some actions that were being executed previously would no longer be executed. + rhs: andM s +- hint: + lhs: "fmap or (sequence s)" + note: Applying this hint would mean that some actions that were being executed previously would no longer be executed. + rhs: orM s +- hint: + lhs: "or <$> sequence s" + note: Applying this hint would mean that some actions that were being executed previously would no longer be executed. + rhs: orM s +- hint: + lhs: "fmap and (mapM f s)" + note: Applying this hint would mean that some actions that were being executed previously would no longer be executed. + rhs: allM f s +- hint: + lhs: "and <$> mapM f s" + note: Applying this hint would mean that some actions that were being executed previously would no longer be executed. + rhs: allM f s +- hint: + lhs: "fmap or (mapM f s)" + note: Applying this hint would mean that some actions that were being executed previously would no longer be executed. + rhs: anyM f s +- hint: + lhs: "or <$> mapM f s" + note: Applying this hint would mean that some actions that were being executed previously would no longer be executed. + rhs: anyM f s +- warn: + lhs: "getAlt (foldMap (Alt . f) xs)" + rhs: asumMap xs +- warn: + lhs: "getAlt . foldMap (Alt . f)" + rhs: asumMap +- hint: + lhs: "foldr (\\x acc -> f x <|> acc) empty" + note: "Use 'asumMap'" + rhs: asumMap f +- hint: + lhs: "asum (map f xs)" + note: "Use 'asumMap'" + rhs: asumMap f xs +- warn: + lhs: "map fst &&& map snd" + rhs: unzip +- hint: + lhs: "fmap (fmap f) x" + note: "Use '(<<$>>)'" + rhs: "f <<$>> x" +- hint: + lhs: "(\\f -> f x) <$> ff" + note: Use flap operator + rhs: "ff ?? x" +- hint: + lhs: "fmap (\\f -> f x) ff" + note: Use flap operator + rhs: "ff ?? x" +- hint: + lhs: "fmap ($ x) ff" + note: Use flap operator + rhs: "ff ?? x" +- hint: + lhs: "($ x) <$> ff" + note: Use flap operator + rhs: "ff ?? x" +- warn: + lhs: "fmap f (nonEmpty x)" + rhs: viaNonEmpty f x +- warn: + lhs: fmap f . nonEmpty + rhs: viaNonEmpty f +- warn: + lhs: "f <$> nonEmpty x" + rhs: viaNonEmpty f x +- warn: + lhs: partitionEithers . map f + rhs: partitionWith f +- warn: + lhs: partitionEithers $ map f x + rhs: partitionWith f x +- warn: + lhs: "f >>= guard" + rhs: guardM f +- warn: + lhs: guard =<< f + rhs: guardM f +- warn: + lhs: forever + note: "'forever' is loosely typed and may hide errors" + rhs: infinitely +- warn: + lhs: "whenM (not <$> x)" + rhs: unlessM x +- warn: + lhs: "unlessM (not <$> x)" + rhs: whenM x +- warn: + lhs: "either (const True) (const False)" + rhs: isLeft +- warn: + lhs: "either (const False) (const True)" + rhs: isRight +- warn: + lhs: "either id (const a)" + rhs: fromLeft a +- warn: + lhs: "either (const b) id" + rhs: fromRight b +- warn: + lhs: "either Just (const Nothing)" + rhs: leftToMaybe +- warn: + lhs: "either (const Nothing) Just" + rhs: rightToMaybe +- warn: + lhs: "maybe (Left l) Right" + rhs: maybeToRight l +- warn: + lhs: "maybe (Right r) Left" + rhs: maybeToLeft r +- warn: + lhs: "case m of Just x -> f x; Nothing -> pure ()" + rhs: whenJust m f +- warn: + lhs: "case m of Just x -> f x; Nothing -> return ()" + rhs: whenJust m f +- warn: + lhs: "case m of Just x -> f x; Nothing -> pass" + rhs: whenJust m f +- warn: + lhs: "case m of Nothing -> pure () ; Just x -> f x" + rhs: whenJust m f +- warn: + lhs: "case m of Nothing -> return (); Just x -> f x" + rhs: whenJust m f +- warn: + lhs: "case m of Nothing -> pass ; Just x -> f x" + rhs: whenJust m f +- warn: + lhs: "maybe (pure ()) f m" + rhs: whenJust m f +- warn: + lhs: "maybe (return ()) f m" + rhs: whenJust m f +- warn: + lhs: maybe pass f m + rhs: whenJust m f +- warn: + lhs: "m >>= \\a -> whenJust a f" + rhs: whenJustM m f +- warn: + lhs: "m >>= \\case Just x -> f x; Nothing -> pure ()" + rhs: whenJustM m f +- warn: + lhs: "m >>= \\case Just x -> f x; Nothing -> return ()" + rhs: whenJustM m f +- warn: + lhs: "m >>= \\case Just x -> f x; Nothing -> pass" + rhs: whenJustM m f +- warn: + lhs: "m >>= \\case Nothing -> pure () ; Just x -> f x" + rhs: whenJustM m f +- warn: + lhs: "m >>= \\case Nothing -> return (); Just x -> f x" + rhs: whenJustM m f +- warn: + lhs: "m >>= \\case Nothing -> pass ; Just x -> f x" + rhs: whenJustM m f +- warn: + lhs: "maybe (pure ()) f =<< m" + rhs: whenJustM m f +- warn: + lhs: "maybe (return ()) f =<< m" + rhs: whenJustM m f +- warn: + lhs: maybe pass f =<< m + rhs: whenJustM m f +- warn: + lhs: "m >>= maybe (pure ()) f" + rhs: whenJustM m f +- warn: + lhs: "m >>= maybe (return ()) f" + rhs: whenJustM m f +- warn: + lhs: "m >>= maybe pass f" + rhs: whenJustM m f +- warn: + lhs: "case m of Just _ -> pure () ; Nothing -> x" + rhs: whenNothing_ m x +- warn: + lhs: "case m of Just _ -> return (); Nothing -> x" + rhs: whenNothing_ m x +- warn: + lhs: "case m of Just _ -> pass ; Nothing -> x" + rhs: whenNothing_ m x +- warn: + lhs: "case m of Nothing -> x; Just _ -> pure ()" + rhs: whenNothing_ m x +- warn: + lhs: "case m of Nothing -> x; Just _ -> return ()" + rhs: whenNothing_ m x +- warn: + lhs: "case m of Nothing -> x; Just _ -> pass" + rhs: whenNothing_ m x +- warn: + lhs: "maybe x (\\_ -> pure () ) m" + rhs: whenNothing_ m x +- warn: + lhs: "maybe x (\\_ -> return () ) m" + rhs: whenNothing_ m x +- warn: + lhs: "maybe x (\\_ -> pass ) m" + rhs: whenNothing_ m x +- warn: + lhs: "maybe x (const (pure () )) m" + rhs: whenNothing_ m x +- warn: + lhs: "maybe x (const (return ())) m" + rhs: whenNothing_ m x +- warn: + lhs: "maybe x (const pass) m" + rhs: whenNothing_ m x +- warn: + lhs: "m >>= \\a -> whenNothing_ a x" + rhs: whenNothingM_ m x +- warn: + lhs: "m >>= \\case Just _ -> pure () ; Nothing -> x" + rhs: whenNothingM_ m x +- warn: + lhs: "m >>= \\case Just _ -> return (); Nothing -> x" + rhs: whenNothingM_ m x +- warn: + lhs: "m >>= \\case Just _ -> pass ; Nothing -> x" + rhs: whenNothingM_ m x +- warn: + lhs: "m >>= \\case Nothing -> x; Just _ -> pure ()" + rhs: whenNothingM_ m x +- warn: + lhs: "m >>= \\case Nothing -> x; Just _ -> return ()" + rhs: whenNothingM_ m x +- warn: + lhs: "m >>= \\case Nothing -> x; Just _ -> pass" + rhs: whenNothingM_ m x +- warn: + lhs: "maybe x (\\_ -> pure () ) =<< m" + rhs: whenNothingM_ m x +- warn: + lhs: "maybe x (\\_ -> return () ) =<< m" + rhs: whenNothingM_ m x +- warn: + lhs: "maybe x (\\_ -> pass ) =<< m" + rhs: whenNothingM_ m x +- warn: + lhs: "maybe x (const (pure () )) =<< m" + rhs: whenNothingM_ m x +- warn: + lhs: "maybe x (const (return ())) =<< m" + rhs: whenNothingM_ m x +- warn: + lhs: "maybe x (const pass) =<< m" + rhs: whenNothingM_ m x +- warn: + lhs: "m >>= maybe x (\\_ -> pure ())" + rhs: whenNothingM_ m x +- warn: + lhs: "m >>= maybe x (\\_ -> return ())" + rhs: whenNothingM_ m x +- warn: + lhs: "m >>= maybe x (\\_ -> pass)" + rhs: whenNothingM_ m x +- warn: + lhs: "m >>= maybe x (const (pure ()) )" + rhs: whenNothingM_ m x +- warn: + lhs: "m >>= maybe x (const (return ()))" + rhs: whenNothingM_ m x +- warn: + lhs: "m >>= maybe x (const pass)" + rhs: whenNothingM_ m x +- warn: + lhs: "whenLeft ()" + rhs: whenLeft_ +- warn: + lhs: "case m of Left x -> f x; Right _ -> pure ()" + rhs: whenLeft_ m f +- warn: + lhs: "case m of Left x -> f x; Right _ -> return ()" + rhs: whenLeft_ m f +- warn: + lhs: "case m of Left x -> f x; Right _ -> pass" + rhs: whenLeft_ m f +- warn: + lhs: "case m of Right _ -> pure () ; Left x -> f x" + rhs: whenLeft_ m f +- warn: + lhs: "case m of Right _ -> return (); Left x -> f x" + rhs: whenLeft_ m f +- warn: + lhs: "case m of Right _ -> pass ; Left x -> f x" + rhs: whenLeft_ m f +- warn: + lhs: "either f (\\_ -> pure () ) m" + rhs: whenLeft_ m f +- warn: + lhs: "either f (\\_ -> return () ) m" + rhs: whenLeft_ m f +- warn: + lhs: "either f (\\_ -> pass ) m" + rhs: whenLeft_ m f +- warn: + lhs: "either f (const (pure () )) m" + rhs: whenLeft_ m f +- warn: + lhs: "either f (const (return ())) m" + rhs: whenLeft_ m f +- warn: + lhs: "either f (const pass) m" + rhs: whenLeft_ m f +- warn: + lhs: "m >>= \\a -> whenLeft_ a f" + rhs: whenLeftM_ m f +- warn: + lhs: "m >>= \\case Left x -> f x; Right _ -> pure ()" + rhs: whenLeftM_ m f +- warn: + lhs: "m >>= \\case Left x -> f x; Right _ -> return ()" + rhs: whenLeftM_ m f +- warn: + lhs: "m >>= \\case Left x -> f x; Right _ -> pass" + rhs: whenLeftM_ m f +- warn: + lhs: "m >>= \\case Right _ -> pure () ; Left x -> f x" + rhs: whenLeftM_ m f +- warn: + lhs: "m >>= \\case Right _ -> return (); Left x -> f x" + rhs: whenLeftM_ m f +- warn: + lhs: "m >>= \\case Right _ -> pass ; Left x -> f x" + rhs: whenLeftM_ m f +- warn: + lhs: "either f (\\_ -> pure () ) =<< m" + rhs: whenLeftM_ m f +- warn: + lhs: "either f (\\_ -> return () ) =<< m" + rhs: whenLeftM_ m f +- warn: + lhs: "either f (\\_ -> pass ) =<< m" + rhs: whenLeftM_ m f +- warn: + lhs: "either f (const (pure () )) =<< m" + rhs: whenLeftM_ m f +- warn: + lhs: "either f (const (return ())) =<< m" + rhs: whenLeftM_ m f +- warn: + lhs: "either f (const pass) =<< m" + rhs: whenLeftM_ m f +- warn: + lhs: "m >>= either f (\\_ -> pure ())" + rhs: whenLeftM_ m f +- warn: + lhs: "m >>= either f (\\_ -> return ())" + rhs: whenLeftM_ m f +- warn: + lhs: "m >>= either f (\\_ -> pass)" + rhs: whenLeftM_ m f +- warn: + lhs: "m >>= either f (const (pure ()) )" + rhs: whenLeftM_ m f +- warn: + lhs: "m >>= either f (const (return ()))" + rhs: whenLeftM_ m f +- warn: + lhs: "m >>= either f (const pass)" + rhs: whenLeftM_ m f +- warn: + lhs: "whenRight ()" + rhs: whenRight_ +- warn: + lhs: "case m of Right x -> f x; Left _ -> pure ()" + rhs: whenRight_ m f +- warn: + lhs: "case m of Right x -> f x; Left _ -> return ()" + rhs: whenRight_ m f +- warn: + lhs: "case m of Right x -> f x; Left _ -> pass" + rhs: whenRight_ m f +- warn: + lhs: "case m of Left _ -> pure () ; Right x -> f x" + rhs: whenRight_ m f +- warn: + lhs: "case m of Left _ -> return (); Right x -> f x" + rhs: whenRight_ m f +- warn: + lhs: "case m of Left _ -> pass ; Right x -> f x" + rhs: whenRight_ m f +- warn: + lhs: "either (\\_ -> pure () ) f m" + rhs: whenRight_ m f +- warn: + lhs: "either (\\_ -> return () ) f m" + rhs: whenRight_ m f +- warn: + lhs: "either (\\_ -> pass ) f m" + rhs: whenRight_ m f +- warn: + lhs: "either (const (pure () )) f m" + rhs: whenRight_ m f +- warn: + lhs: "either (const (return ())) f m" + rhs: whenRight_ m f +- warn: + lhs: "either (const pass) f m" + rhs: whenRight_ m f +- warn: + lhs: "m >>= \\a -> whenRight_ a f" + rhs: whenRightM_ m f +- warn: + lhs: "m >>= \\case Right x -> f x; Left _ -> pure () " + rhs: whenRightM_ m f +- warn: + lhs: "m >>= \\case Right x -> f x; Left _ -> return ()" + rhs: whenRightM_ m f +- warn: + lhs: "m >>= \\case Right x -> f x; Left _ -> pass" + rhs: whenRightM_ m f +- warn: + lhs: "m >>= \\case Left _ -> pure () ; Right x -> f x" + rhs: whenRightM_ m f +- warn: + lhs: "m >>= \\case Left _ -> return (); Right x -> f x" + rhs: whenRightM_ m f +- warn: + lhs: "m >>= \\case Left _ -> pass ; Right x -> f x" + rhs: whenRightM_ m f +- warn: + lhs: "either (\\_ -> pure () ) f =<< m" + rhs: whenRightM_ m f +- warn: + lhs: "either (\\_ -> return () ) f =<< m" + rhs: whenRightM_ m f +- warn: + lhs: "either (\\_ -> pass ) f =<< m" + rhs: whenRightM_ m f +- warn: + lhs: "either (const (pure () )) f =<< m" + rhs: whenRightM_ m f +- warn: + lhs: "either (const (return ())) f =<< m" + rhs: whenRightM_ m f +- warn: + lhs: "either (const pass) f =<< m" + rhs: whenRightM_ m f +- warn: + lhs: "m >>= either (\\_ -> pure ()) f" + rhs: whenRightM_ m f +- warn: + lhs: "m >>= either (\\_ -> return ()) f" + rhs: whenRightM_ m f +- warn: + lhs: "m >>= either (\\_ -> pass) f" + rhs: whenRightM_ m f +- warn: + lhs: "m >>= either (const (pure ()) ) f" + rhs: whenRightM_ m f +- warn: + lhs: "m >>= either (const (return ())) f" + rhs: whenRightM_ m f +- warn: + lhs: "m >>= either (const pass) f" + rhs: whenRightM_ m f +- warn: + lhs: "case m of Left x -> f x; Right _ -> pure d " + rhs: whenLeft d m f +- warn: + lhs: "case m of Left x -> f x; Right _ -> return d" + rhs: whenLeft d m f +- warn: + lhs: "case m of Right _ -> pure d ; Left x -> f x" + rhs: whenLeft d m f +- warn: + lhs: "case m of Right _ -> return d; Left x -> f x" + rhs: whenLeft d m f +- warn: + lhs: "either f (\\_ -> pure d ) m" + rhs: whenLeft d m f +- warn: + lhs: "either f (\\_ -> return d ) m" + rhs: whenLeft d m f +- warn: + lhs: "either f (const (pure d )) m" + rhs: whenLeft d m f +- warn: + lhs: "either f (const (return d)) m" + rhs: whenLeft d m f +- warn: + lhs: "m >>= \\a -> whenLeft d a f" + rhs: whenLeftM d m f +- warn: + lhs: "m >>= \\case Left x -> f x; Right _ -> pure d" + rhs: whenLeftM d m f +- warn: + lhs: "m >>= \\case Left x -> f x; Right _ -> return d" + rhs: whenLeftM d m f +- warn: + lhs: "m >>= \\case Right _ -> pure d ; Left x -> f x" + rhs: whenLeftM d m f +- warn: + lhs: "m >>= \\case Right _ -> return d; Left x -> f x" + rhs: whenLeftM d m f +- warn: + lhs: "either f (\\_ -> pure d ) =<< m" + rhs: whenLeftM d m f +- warn: + lhs: "either f (\\_ -> return d ) =<< m" + rhs: whenLeftM d m f +- warn: + lhs: "either f (const (pure d )) =<< m" + rhs: whenLeftM d m f +- warn: + lhs: "either f (const (return d)) =<< m" + rhs: whenLeftM d m f +- warn: + lhs: "m >>= either f (\\_ -> pure d)" + rhs: whenLeftM d m f +- warn: + lhs: "m >>= either f (\\_ -> return d)" + rhs: whenLeftM d m f +- warn: + lhs: "m >>= either f (const (pure d))" + rhs: whenLeftM d m f +- warn: + lhs: "m >>= either f (const (return d))" + rhs: whenLeftM d m f +- warn: + lhs: "case m of Right x -> f x; Left _ -> pure d" + rhs: whenRight d m f +- warn: + lhs: "case m of Right x -> f x; Left _ -> return d" + rhs: whenRight d m f +- warn: + lhs: "case m of Left _ -> pure d ; Right x -> f x" + rhs: whenRight d m f +- warn: + lhs: "case m of Left _ -> return d; Right x -> f x" + rhs: whenRight d m f +- warn: + lhs: "either (\\_ -> pure d ) f m" + rhs: whenRight d m f +- warn: + lhs: "either (\\_ -> return d ) f m" + rhs: whenRight d m f +- warn: + lhs: "either (const (pure d )) f m" + rhs: whenRight d m f +- warn: + lhs: "either (const (return d)) f m" + rhs: whenRight d m f +- warn: + lhs: "m >>= \\a -> whenRight d a f" + rhs: whenRightM d m f +- warn: + lhs: "m >>= \\case Right x -> f x; Left _ -> pure d" + rhs: whenRightM d m f +- warn: + lhs: "m >>= \\case Right x -> f x; Left _ -> return d" + rhs: whenRightM d m f +- warn: + lhs: "m >>= \\case Left _ -> pure d ; Right x -> f x" + rhs: whenRightM d m f +- warn: + lhs: "m >>= \\case Left _ -> return d; Right x -> f x" + rhs: whenRightM d m f +- warn: + lhs: "either (\\_ -> pure d ) f =<< m" + rhs: whenRightM d m f +- warn: + lhs: "either (\\_ -> return d ) f =<< m" + rhs: whenRightM d m f +- warn: + lhs: "either (const (pure d )) f =<< m" + rhs: whenRightM d m f +- warn: + lhs: "either (const (return d)) f =<< m" + rhs: whenRightM d m f +- warn: + lhs: "m >>= either (\\_ -> pure d) f" + rhs: whenRightM d m f +- warn: + lhs: "m >>= either (\\_ -> return d) f" + rhs: whenRightM d m f +- warn: + lhs: "m >>= either (const (pure d) ) f" + rhs: whenRightM d m f +- warn: + lhs: "m >>= either (const (return d)) f" + rhs: whenRightM d m f +- warn: + lhs: "case m of [] -> return (); (x:xs) -> f (x :| xs)" + rhs: whenNotNull m f +- warn: + lhs: "case m of [] -> pure () ; (x:xs) -> f (x :| xs)" + rhs: whenNotNull m f +- warn: + lhs: "case m of [] -> pass ; (x:xs) -> f (x :| xs)" + rhs: whenNotNull m f +- warn: + lhs: "case m of (x:xs) -> f (x :| xs); [] -> return ()" + rhs: whenNotNull m f +- warn: + lhs: "case m of (x:xs) -> f (x :| xs); [] -> pure () " + rhs: whenNotNull m f +- warn: + lhs: "case m of (x:xs) -> f (x :| xs); [] -> pass " + rhs: whenNotNull m f +- warn: + lhs: "m >>= \\case [] -> pass ; (x:xs) -> f (x :| xs)" + rhs: whenNotNullM m f +- warn: + lhs: "m >>= \\case [] -> pure () ; (x:xs) -> f (x :| xs)" + rhs: whenNotNullM m f +- warn: + lhs: "m >>= \\case [] -> return (); (x:xs) -> f (x :| xs)" + rhs: whenNotNullM m f +- warn: + lhs: "m >>= \\case (x:xs) -> f (x :| xs); [] -> pass " + rhs: whenNotNullM m f +- warn: + lhs: "m >>= \\case (x:xs) -> f (x :| xs); [] -> pure () " + rhs: whenNotNullM m f +- warn: + lhs: "m >>= \\case (x:xs) -> f (x :| xs); [] -> return ()" + rhs: whenNotNullM m f +- warn: + lhs: mapMaybe leftToMaybe + rhs: lefts +- warn: + lhs: mapMaybe rightToMaybe + rhs: rights +- warn: + lhs: flip runReaderT + rhs: usingReaderT +- warn: + lhs: flip runReader + rhs: usingReader +- warn: + lhs: flip runStateT + rhs: usingStateT +- warn: + lhs: flip runState + rhs: usingState +- warn: + lhs: "fst <$> usingStateT s st" + rhs: evaluatingStateT s st +- warn: + lhs: "fst (usingState s st)" + rhs: evaluatingState s st +- warn: + lhs: "snd <$> usingStateT s st" + rhs: executingStateT s st +- warn: + lhs: "snd (usingState s st)" + rhs: executingState s st +- warn: + lhs: "MaybeT (pure m)" + rhs: hoistMaybe m +- warn: + lhs: "MaybeT (return m)" + rhs: hoistMaybe m +- warn: + lhs: MaybeT . pure + rhs: hoistMaybe +- warn: + lhs: MaybeT . return + rhs: hoistMaybe +- warn: + lhs: "ExceptT (pure m)" + rhs: hoistEither m +- warn: + lhs: "ExceptT (return m)" + rhs: hoistEither m +- warn: + lhs: ExceptT . pure + rhs: hoistEither +- warn: + lhs: ExceptT . return + rhs: hoistEither +- warn: + lhs: fromMaybe mempty + rhs: maybeToMonoid +- warn: + lhs: "m ?: mempty" + rhs: maybeToMonoid m +- warn: + lhs: "Data.Map.toAscList (Data.Map.fromList x)" + rhs: sortWith fst x +- warn: + lhs: "Data.Map.toDescList (Data.Map.fromList x)" + rhs: "sortWith (Down . fst) x" +- warn: + lhs: "Data.Set.toList (Data.Set.fromList l)" + rhs: sortNub l +- warn: + lhs: "Data.Set.assocs (Data.Set.fromList l)" + rhs: sortNub l +- warn: + lhs: "Data.Set.toAscList (Data.Set.fromList l)" + rhs: sortNub l +- warn: + lhs: "Data.HashSet.toList (Data.HashSet.fromList l)" + rhs: unstableNub l +- warn: + lhs: nub + note: "'nub' is O(n^2), 'ordNub' is O(n log n)" + rhs: ordNub +- warn: + lhs: "sortBy (comparing f)" + note: "If the function you are using for 'comparing' is slow, use 'sortOn' instead of 'sortWith', because 'sortOn' caches applications the function and 'sortWith' doesn't." + rhs: sortWith f +- warn: + lhs: sortOn fst + note: "'sortWith' will be faster here because it doesn't do caching" + rhs: sortWith fst +- warn: + lhs: sortOn snd + note: "'sortWith' will be faster here because it doesn't do caching" + rhs: sortWith snd +- warn: + lhs: "sortOn (Down . fst)" + note: "'sortWith' will be faster here because it doesn't do caching" + rhs: "sortWith (Down . fst)" +- warn: + lhs: "sortOn (Down . snd)" + note: "'sortWith' will be faster here because it doesn't do caching" + rhs: "sortWith (Down . snd)" +- warn: + lhs: Data.Text.IO.putStr + rhs: putText +- warn: + lhs: Data.Text.IO.putStrLn + rhs: putTextLn +- warn: + lhs: Data.Text.Lazy.IO.putStr + rhs: putLText +- warn: + lhs: Data.Text.Lazy.IO.putStrLn + rhs: putLTextLn +- warn: + lhs: Data.ByteString.Char8.putStr + rhs: putBS +- warn: + lhs: Data.ByteString.Char8.putStrLn + rhs: putBSLn +- warn: + lhs: Data.ByteString.Lazy.Char8.putStr + rhs: putLBS +- warn: + lhs: Data.ByteString.Lazy.Char8.putStrLn + rhs: putLBSLn +- warn: + lhs: Data.Text.Lazy.Text + rhs: LText +- warn: + lhs: Data.ByteString.Lazy.ByteString + rhs: LByteString +- warn: + lhs: Data.ByteString.UTF8.fromString + rhs: encodeUtf8 +- warn: + lhs: Data.ByteString.UTF8.toString + rhs: decodeUtf8 +- warn: + lhs: Data.Text.Encoding.encodeUtf8 + rhs: encodeUtf8 +- warn: + lhs: Data.Text.Encoding.decodeUtf8 + rhs: decodeUtf8 +- warn: + lhs: "Data.ByteString.Lazy.toStrict (encodeUtf8 x)" + rhs: encodeUtf8 x +- warn: + lhs: "toStrict (encodeUtf8 x)" + rhs: encodeUtf8 x +- warn: + lhs: "decodeUtf8 (Data.ByteString.Lazy.fromStrict x)" + rhs: decodeUtf8 x +- warn: + lhs: "decodeUtf8 (fromStrict x)" + rhs: decodeUtf8 x +- warn: + lhs: Data.ByteString.Lazy.UTF8.fromString + rhs: encodeUtf8 +- warn: + lhs: Data.ByteString.Lazy.UTF8.toString + rhs: decodeUtf8 +- warn: + lhs: "Data.ByteString.Lazy.fromStrict (Data.Text.Encoding.encodeUtf8 x)" + rhs: encodeUtf8 x +- warn: + lhs: "Data.ByteString.Lazy.fromStrict (encodeUtf8 x)" + rhs: encodeUtf8 x +- warn: + lhs: "Data.Text.Encoding.decodeUtf8 (Data.ByteString.Lazy.toStrict x)" + rhs: decodeUtf8 x +- warn: + lhs: "Data.Text.Encoding.decodeUtf8 (toStrict x)" + rhs: decodeUtf8 x +- warn: + lhs: "decodeUtf8 (Data.ByteString.Lazy.toStrict x)" + rhs: decodeUtf8 x +- warn: + lhs: "decodeUtf8 (toStrict x)" + rhs: decodeUtf8 x +- warn: + lhs: Data.Text.pack + rhs: toText +- warn: + lhs: Data.Text.unpack + rhs: toString +- warn: + lhs: Data.Text.Lazy.pack + rhs: toLText +- warn: + lhs: Data.Text.Lazy.unpack + rhs: toString +- warn: + lhs: Data.Text.Lazy.toStrict + rhs: toText +- warn: + lhs: Data.Text.Lazy.fromStrict + rhs: toLText +- warn: + lhs: "Data.Text.pack (show x)" + rhs: show x +- warn: + lhs: "Data.Text.Lazy.pack (show x)" + rhs: show x +- warn: + lhs: Data.ByteString.Lazy.fromStrict + rhs: fromStrict +- warn: + lhs: Data.ByteString.Lazy.toStrict + rhs: toStrict +- warn: + lhs: Data.Text.Lazy.fromStrict + rhs: fromStrict +- warn: + lhs: Data.Text.Lazy.toStrict + rhs: toStrict +- warn: + lhs: Control.Applicative.Alternative + name: "Use 'Alternative' from Relude" + note: "'Alternative' is already exported from Relude" + rhs: Alternative +- warn: + lhs: Control.Applicative.empty + name: "Use 'empty' from Relude" + note: "'empty' is already exported from Relude" + rhs: empty +- warn: + lhs: "(Control.Applicative.<|>)" + name: "Use '<|>' from Relude" + note: "Operator '(<|>)' is already exported from Relude" + rhs: "(<|>)" +- warn: + lhs: Control.Applicative.some + name: "Use 'some' from Relude" + note: "'some' is already exported from Relude" + rhs: some +- warn: + lhs: Control.Applicative.many + name: "Use 'many' from Relude" + note: "'many' is already exported from Relude" + rhs: many +- warn: + lhs: Control.Applicative.Const + name: "Use 'Const' from Relude" + note: "'Const' is already exported from Relude" + rhs: Const +- warn: + lhs: Control.Applicative.getConst + name: "Use 'getConst' from Relude" + note: "'getConst' is already exported from Relude" + rhs: getConst +- warn: + lhs: Control.Applicative.ZipList + name: "Use 'ZipList' from Relude" + note: "'ZipList' is already exported from Relude" + rhs: ZipList +- warn: + lhs: Control.Applicative.getZipList + name: "Use 'getZipList' from Relude" + note: "'getZipList' is already exported from Relude" + rhs: getZipList +- warn: + lhs: Control.Applicative.liftA2 + name: "Use 'liftA2' from Relude" + note: "'liftA2' is already exported from Relude" + rhs: liftA2 +- warn: + lhs: Control.Applicative.liftA3 + name: "Use 'liftA3' from Relude" + note: "'liftA3' is already exported from Relude" + rhs: liftA3 +- warn: + lhs: Control.Applicative.optional + name: "Use 'optional' from Relude" + note: "'optional' is already exported from Relude" + rhs: optional +- warn: + lhs: "(Control.Applicative.<**>)" + name: "Use '<**>' from Relude" + note: "Operator '(<**>)' is already exported from Relude" + rhs: "(<**>)" +- warn: + lhs: Data.Bits.xor + name: "Use 'xor' from Relude" + note: "'xor' is already exported from Relude" + rhs: xor +- warn: + lhs: Data.Char.chr + name: "Use 'chr' from Relude" + note: "'chr' is already exported from Relude" + rhs: chr +- warn: + lhs: Data.Int.Int8 + name: "Use 'Int8' from Relude" + note: "'Int8' is already exported from Relude" + rhs: Int8 +- warn: + lhs: Data.Int.Int16 + name: "Use 'Int16' from Relude" + note: "'Int16' is already exported from Relude" + rhs: Int16 +- warn: + lhs: Data.Int.Int32 + name: "Use 'Int32' from Relude" + note: "'Int32' is already exported from Relude" + rhs: Int32 +- warn: + lhs: Data.Int.Int64 + name: "Use 'Int64' from Relude" + note: "'Int64' is already exported from Relude" + rhs: Int64 +- warn: + lhs: Data.Word.Word8 + name: "Use 'Word8' from Relude" + note: "'Word8' is already exported from Relude" + rhs: Word8 +- warn: + lhs: Data.Word.Word16 + name: "Use 'Word16' from Relude" + note: "'Word16' is already exported from Relude" + rhs: Word16 +- warn: + lhs: Data.Word.Word32 + name: "Use 'Word32' from Relude" + note: "'Word32' is already exported from Relude" + rhs: Word32 +- warn: + lhs: Data.Word.Word64 + name: "Use 'Word64' from Relude" + note: "'Word64' is already exported from Relude" + rhs: Word64 +- warn: + lhs: Data.Word.byteSwap16 + name: "Use 'byteSwap16' from Relude" + note: "'byteSwap16' is already exported from Relude" + rhs: byteSwap16 +- warn: + lhs: Data.Word.byteSwap32 + name: "Use 'byteSwap32' from Relude" + note: "'byteSwap32' is already exported from Relude" + rhs: byteSwap32 +- warn: + lhs: Data.Word.byteSwap64 + name: "Use 'byteSwap64' from Relude" + note: "'byteSwap64' is already exported from Relude" + rhs: byteSwap64 +- warn: + lhs: Numeric.Natural.Natural + name: "Use 'Natural' from Relude" + note: "'Natural' is already exported from Relude" + rhs: Natural +- warn: + lhs: System.IO.IOMode + name: "Use 'IOMode' from Relude" + note: "'IOMode' is already exported from Relude" + rhs: IOMode +- warn: + lhs: System.IO.ReadMode + name: "Use 'ReadMode' from Relude" + note: "'ReadMode' is already exported from Relude" + rhs: ReadMode +- warn: + lhs: System.IO.WriteMode + name: "Use 'WriteMode' from Relude" + note: "'WriteMode' is already exported from Relude" + rhs: WriteMode +- warn: + lhs: System.IO.AppendMode + name: "Use 'AppendMode' from Relude" + note: "'AppendMode' is already exported from Relude" + rhs: AppendMode +- warn: + lhs: System.IO.ReadWriteMode + name: "Use 'ReadWriteMode' from Relude" + note: "'ReadWriteMode' is already exported from Relude" + rhs: ReadWriteMode +- warn: + lhs: Data.Ord.Down + name: "Use 'Down' from Relude" + note: "'Down' is already exported from Relude" + rhs: Down +- warn: + lhs: Data.Ord.comparing + name: "Use 'comparing' from Relude" + note: "'comparing' is already exported from Relude" + rhs: comparing +- warn: + lhs: Data.Coerce.Coercible + name: "Use 'Coercible' from Relude" + note: "'Coercible' is already exported from Relude" + rhs: Coercible +- warn: + lhs: Data.Coerce.coerce + name: "Use 'coerce' from Relude" + note: "'coerce' is already exported from Relude" + rhs: coerce +- warn: + lhs: Data.Kind.Constraint + name: "Use 'Constraint' from Relude" + note: "'Constraint' is already exported from Relude" + rhs: Constraint +- warn: + lhs: Data.Kind.Type + name: "Use 'Type' from Relude" + note: "'Type' is already exported from Relude" + rhs: Type +- warn: + lhs: Data.Typeable.Typeable + name: "Use 'Typeable' from Relude" + note: "'Typeable' is already exported from Relude" + rhs: Typeable +- warn: + lhs: Data.Proxy.Proxy + name: "Use 'Proxy' from Relude" + note: "'Proxy' is already exported from Relude" + rhs: Proxy +- warn: + lhs: Data.Typeable.Typeable + name: "Use 'Typeable' from Relude" + note: "'Typeable' is already exported from Relude" + rhs: Typeable +- warn: + lhs: Data.Void.Void + name: "Use 'Void' from Relude" + note: "'Void' is already exported from Relude" + rhs: Void +- warn: + lhs: Data.Void.absurd + name: "Use 'absurd' from Relude" + note: "'absurd' is already exported from Relude" + rhs: absurd +- warn: + lhs: Data.Void.vacuous + name: "Use 'vacuous' from Relude" + note: "'vacuous' is already exported from Relude" + rhs: vacuous +- warn: + lhs: Data.Base.maxInt + name: "Use 'maxInt' from Relude" + note: "'maxInt' is already exported from Relude" + rhs: maxInt +- warn: + lhs: Data.Base.minInt + name: "Use 'minInt' from Relude" + note: "'minInt' is already exported from Relude" + rhs: minInt +- warn: + lhs: Data.Base.ord + name: "Use 'ord' from Relude" + note: "'ord' is already exported from Relude" + rhs: ord +- warn: + lhs: GHC.Enum.boundedEnumFrom + name: "Use 'boundedEnumFrom' from Relude" + note: "'boundedEnumFrom' is already exported from Relude" + rhs: boundedEnumFrom +- warn: + lhs: GHC.Enum.boundedEnumFromThen + name: "Use 'boundedEnumFromThen' from Relude" + note: "'boundedEnumFromThen' is already exported from Relude" + rhs: boundedEnumFromThen +- warn: + lhs: GHC.Generics.Generic + name: "Use 'Generic' from Relude" + note: "'Generic' is already exported from Relude" + rhs: Generic +- warn: + lhs: GHC.Real.Ratio + name: "Use 'Ratio' from Relude" + note: "'Ratio' is already exported from Relude" + rhs: Ratio +- warn: + lhs: GHC.Real.Rational + name: "Use 'Rational' from Relude" + note: "'Rational' is already exported from Relude" + rhs: Rational +- warn: + lhs: GHC.Real.denominator + name: "Use 'denominator' from Relude" + note: "'denominator' is already exported from Relude" + rhs: denominator +- warn: + lhs: GHC.Real.numerator + name: "Use 'numerator' from Relude" + note: "'numerator' is already exported from Relude" + rhs: numerator +- warn: + lhs: GHC.TypeNats.CmpNat + name: "Use 'CmpNat' from Relude" + note: "'CmpNat' is already exported from Relude" + rhs: CmpNat +- warn: + lhs: GHC.TypeNats.KnownNat + name: "Use 'KnownNat' from Relude" + note: "'KnownNat' is already exported from Relude" + rhs: KnownNat +- warn: + lhs: GHC.TypeNats.Nat + name: "Use 'Nat' from Relude" + note: "'Nat' is already exported from Relude" + rhs: Nat +- warn: + lhs: GHC.TypeNats.SomeNat + name: "Use 'SomeNat' from Relude" + note: "'SomeNat' is already exported from Relude" + rhs: SomeNat +- warn: + lhs: GHC.TypeNats.natVal + name: "Use 'natVal' from Relude" + note: "'natVal' is already exported from Relude" + rhs: natVal +- warn: + lhs: GHC.TypeNats.someNatVal + name: "Use 'someNatVal' from Relude" + note: "'someNatVal' is already exported from Relude" + rhs: someNatVal +- warn: + lhs: GHC.TypeLits.CmpNat + name: "Use 'CmpNat' from Relude" + note: "'CmpNat' is already exported from Relude" + rhs: CmpNat +- warn: + lhs: GHC.TypeLits.KnownNat + name: "Use 'KnownNat' from Relude" + note: "'KnownNat' is already exported from Relude" + rhs: KnownNat +- warn: + lhs: GHC.TypeLits.Nat + name: "Use 'Nat' from Relude" + note: "'Nat' is already exported from Relude" + rhs: Nat +- warn: + lhs: GHC.TypeLits.SomeNat + name: "Use 'SomeNat' from Relude" + note: "'SomeNat' is already exported from Relude" + rhs: SomeNat +- warn: + lhs: GHC.TypeLits.natVal + name: "Use 'natVal' from Relude" + note: "'natVal' is already exported from Relude" + rhs: natVal +- warn: + lhs: GHC.TypeLits.someNatVal + name: "Use 'someNatVal' from Relude" + note: "'someNatVal' is already exported from Relude" + rhs: someNatVal +- warn: + lhs: GHC.ExecutionStack.getStackTrace + name: "Use 'getStackTrace' from Relude" + note: "'getStackTrace' is already exported from Relude" + rhs: getStackTrace +- warn: + lhs: GHC.ExecutionStack.showStackTrace + name: "Use 'showStackTrace' from Relude" + note: "'showStackTrace' is already exported from Relude" + rhs: showStackTrace +- warn: + lhs: GHC.OverloadedLabels.IsLabel + name: "Use 'IsLabel' from Relude" + note: "'IsLabel' is already exported from Relude" + rhs: IsLabel +- warn: + lhs: GHC.OverloadedLabels.fromLabel + name: "Use 'fromLabel' from Relude" + note: "'fromLabel' is already exported from Relude" + rhs: fromLabel +- warn: + lhs: GHC.Stack.CallStack + name: "Use 'CallStack' from Relude" + note: "'CallStack' is already exported from Relude" + rhs: CallStack +- warn: + lhs: GHC.Stack.HasCallStack + name: "Use 'HasCallStack' from Relude" + note: "'HasCallStack' is already exported from Relude" + rhs: HasCallStack +- warn: + lhs: GHC.Stack.callStack + name: "Use 'callStack' from Relude" + note: "'callStack' is already exported from Relude" + rhs: callStack +- warn: + lhs: GHC.Stack.currentCallStack + name: "Use 'currentCallStack' from Relude" + note: "'currentCallStack' is already exported from Relude" + rhs: currentCallStack +- warn: + lhs: GHC.Stack.getCallStack + name: "Use 'getCallStack' from Relude" + note: "'getCallStack' is already exported from Relude" + rhs: getCallStack +- warn: + lhs: GHC.Stack.prettyCallStack + name: "Use 'prettyCallStack' from Relude" + note: "'prettyCallStack' is already exported from Relude" + rhs: prettyCallStack +- warn: + lhs: GHC.Stack.prettySrcLoc + name: "Use 'prettySrcLoc' from Relude" + note: "'prettySrcLoc' is already exported from Relude" + rhs: prettySrcLoc +- warn: + lhs: GHC.Stack.withFrozenCallStack + name: "Use 'withFrozenCallStack' from Relude" + note: "'withFrozenCallStack' is already exported from Relude" + rhs: withFrozenCallStack +- warn: + lhs: Data.Bifoldable.Bifoldable + name: "Use 'Bifoldable' from Relude" + note: "'Bifoldable' is already exported from Relude" + rhs: Bifoldable +- warn: + lhs: Data.Bifoldable.bifold + name: "Use 'bifold' from Relude" + note: "'bifold' is already exported from Relude" + rhs: bifold +- warn: + lhs: Data.Bifoldable.bifoldMap + name: "Use 'bifoldMap' from Relude" + note: "'bifoldMap' is already exported from Relude" + rhs: bifoldMap +- warn: + lhs: Data.Bifoldable.bifoldr + name: "Use 'bifoldr' from Relude" + note: "'bifoldr' is already exported from Relude" + rhs: bifoldr +- warn: + lhs: Data.Bifoldable.bifoldl + name: "Use 'bifoldl' from Relude" + note: "'bifoldl' is already exported from Relude" + rhs: bifoldl +- warn: + lhs: "Data.Bifoldable.bifoldl'" + name: "Use 'bifoldl'' from Relude" + note: "'bifoldl'' is already exported from Relude" + rhs: "bifoldl'" +- warn: + lhs: Data.Bifoldable.bifoldlM + name: "Use 'bifoldlM' from Relude" + note: "'bifoldlM' is already exported from Relude" + rhs: bifoldlM +- warn: + lhs: "Data.Bifoldable.bifoldr'" + name: "Use 'bifoldr'' from Relude" + note: "'bifoldr'' is already exported from Relude" + rhs: "bifoldr'" +- warn: + lhs: Data.Bifoldable.bifoldrM + name: "Use 'bifoldrM' from Relude" + note: "'bifoldrM' is already exported from Relude" + rhs: bifoldrM +- warn: + lhs: Data.Bifoldable.bitraverse_ + name: "Use 'bitraverse_' from Relude" + note: "'bitraverse_' is already exported from Relude" + rhs: bitraverse_ +- warn: + lhs: Data.Bifoldable.bifor_ + name: "Use 'bifor_' from Relude" + note: "'bifor_' is already exported from Relude" + rhs: bifor_ +- warn: + lhs: Data.Bifoldable.biasum + name: "Use 'biasum' from Relude" + note: "'biasum' is already exported from Relude" + rhs: biasum +- warn: + lhs: Data.Bifoldable.bisequence_ + name: "Use 'bisequence_' from Relude" + note: "'bisequence_' is already exported from Relude" + rhs: bisequence_ +- warn: + lhs: Data.Bifoldable.biList + name: "Use 'biList' from Relude" + note: "'biList' is already exported from Relude" + rhs: biList +- warn: + lhs: Data.Bifoldable.binull + name: "Use 'binull' from Relude" + note: "'binull' is already exported from Relude" + rhs: binull +- warn: + lhs: Data.Bifoldable.bilength + name: "Use 'bilength' from Relude" + note: "'bilength' is already exported from Relude" + rhs: bilength +- warn: + lhs: Data.Bifoldable.bielem + name: "Use 'bielem' from Relude" + note: "'bielem' is already exported from Relude" + rhs: bielem +- warn: + lhs: Data.Bifoldable.biand + name: "Use 'biand' from Relude" + note: "'biand' is already exported from Relude" + rhs: biand +- warn: + lhs: Data.Bifoldable.bior + name: "Use 'bior' from Relude" + note: "'bior' is already exported from Relude" + rhs: bior +- warn: + lhs: Data.Bifoldable.biany + name: "Use 'biany' from Relude" + note: "'biany' is already exported from Relude" + rhs: biany +- warn: + lhs: Data.Bifoldable.biall + name: "Use 'biall' from Relude" + note: "'biall' is already exported from Relude" + rhs: biall +- warn: + lhs: Data.Bifoldable.bifind + name: "Use 'bifind' from Relude" + note: "'bifind' is already exported from Relude" + rhs: bifind +- warn: + lhs: Data.Bitraversable.Bitraversable + name: "Use 'Bitraversable' from Relude" + note: "'Bitraversable' is already exported from Relude" + rhs: Bitraversable +- warn: + lhs: Data.Bitraversable.bitraverse + name: "Use 'bitraverse' from Relude" + note: "'bitraverse' is already exported from Relude" + rhs: bitraverse +- warn: + lhs: Data.Bitraversable.bisequence + name: "Use 'bisequence' from Relude" + note: "'bisequence' is already exported from Relude" + rhs: bisequence +- warn: + lhs: Data.Bitraversable.bifor + name: "Use 'bifor' from Relude" + note: "'bifor' is already exported from Relude" + rhs: bifor +- warn: + lhs: Data.Bitraversable.bimapDefault + name: "Use 'bimapDefault' from Relude" + note: "'bimapDefault' is already exported from Relude" + rhs: bimapDefault +- warn: + lhs: Data.Bitraversable.bifoldMapDefault + name: "Use 'bifoldMapDefault' from Relude" + note: "'bifoldMapDefault' is already exported from Relude" + rhs: bifoldMapDefault +- warn: + lhs: Control.Monad.guard + name: "Use 'guard' from Relude" + note: "'guard' is already exported from Relude" + rhs: guard +- warn: + lhs: Control.Monad.unless + name: "Use 'unless' from Relude" + note: "'unless' is already exported from Relude" + rhs: unless +- warn: + lhs: Control.Monad.when + name: "Use 'when' from Relude" + note: "'when' is already exported from Relude" + rhs: when +- warn: + lhs: Data.Bool.bool + name: "Use 'bool' from Relude" + note: "'bool' is already exported from Relude" + rhs: bool +- warn: + lhs: Data.Hashable.Hashable + name: "Use 'Hashable' from Relude" + note: "'Hashable' is already exported from Relude" + rhs: Hashable +- warn: + lhs: Data.Hashable.hashWithSalt + name: "Use 'hashWithSalt' from Relude" + note: "'hashWithSalt' is already exported from Relude" + rhs: hashWithSalt +- warn: + lhs: Data.HashMap.Strict.HashMap + name: "Use 'HashMap' from Relude" + note: "'HashMap' is already exported from Relude" + rhs: HashMap +- warn: + lhs: Data.HashSet.HashSet + name: "Use 'HashSet' from Relude" + note: "'HashSet' is already exported from Relude" + rhs: HashSet +- warn: + lhs: Data.IntMap.Strict.IntMap + name: "Use 'IntMap' from Relude" + note: "'IntMap' is already exported from Relude" + rhs: IntMap +- warn: + lhs: Data.IntSet.IntSet + name: "Use 'IntSet' from Relude" + note: "'IntSet' is already exported from Relude" + rhs: IntSet +- warn: + lhs: Data.Map.Strict.Map + name: "Use 'Map' from Relude" + note: "'Map' is already exported from Relude" + rhs: Map +- warn: + lhs: Data.Sequence.Sequence + name: "Use 'Sequence' from Relude" + note: "'Sequence' is already exported from Relude" + rhs: Sequence +- warn: + lhs: Data.Set.Set + name: "Use 'Set' from Relude" + note: "'Set' is already exported from Relude" + rhs: Set +- warn: + lhs: Data.Tuple.swap + name: "Use 'swap' from Relude" + note: "'swap' is already exported from Relude" + rhs: swap +- warn: + lhs: Data.Vector.Vector + name: "Use 'Vector' from Relude" + note: "'Vector' is already exported from Relude" + rhs: Vector +- warn: + lhs: GHC.Exts.IsList + name: "Use 'IsList' from Relude" + note: "'IsList' is already exported from Relude" + rhs: IsList +- warn: + lhs: GHC.Exts.fromList + name: "Use 'fromList' from Relude" + note: "'fromList' is already exported from Relude" + rhs: fromList +- warn: + lhs: GHC.Exts.fromListN + name: "Use 'fromListN' from Relude" + note: "'fromListN' is already exported from Relude" + rhs: fromListN +- warn: + lhs: Debug.Trace.trace + name: "Use 'trace' from Relude" + note: "'trace' is already exported from Relude" + rhs: trace +- warn: + lhs: Debug.Trace.traceShow + name: "Use 'traceShow' from Relude" + note: "'traceShow' is already exported from Relude" + rhs: traceShow +- warn: + lhs: Debug.Trace.traceShowId + name: "Use 'traceShowId' from Relude" + note: "'traceShowId' is already exported from Relude" + rhs: traceShowId +- warn: + lhs: Debug.Trace.traceShowM + name: "Use 'traceShowM' from Relude" + note: "'traceShowM' is already exported from Relude" + rhs: traceShowM +- warn: + lhs: Debug.Trace.traceM + name: "Use 'traceM' from Relude" + note: "'traceM' is already exported from Relude" + rhs: traceM +- warn: + lhs: Debug.Trace.traceId + name: "Use 'traceId' from Relude" + note: "'traceId' is already exported from Relude" + rhs: traceId +- warn: + lhs: Control.DeepSeq.NFData + name: "Use 'NFData' from Relude" + note: "'NFData' is already exported from Relude" + rhs: NFData +- warn: + lhs: Control.DeepSeq.rnf + name: "Use 'rnf' from Relude" + note: "'rnf' is already exported from Relude" + rhs: rnf +- warn: + lhs: Control.DeepSeq.deepseq + name: "Use 'deepseq' from Relude" + note: "'deepseq' is already exported from Relude" + rhs: deepseq +- warn: + lhs: Control.DeepSeq.force + name: "Use 'force' from Relude" + note: "'force' is already exported from Relude" + rhs: force +- warn: + lhs: "(Control.DeepSeq.$!!)" + name: "Use '$!!' from Relude" + note: "Operator '($!!)' is already exported from Relude" + rhs: "($!!)" +- warn: + lhs: Control.Exception.Exception + name: "Use 'Exception' from Relude" + note: "'Exception' is already exported from Relude" + rhs: Exception +- warn: + lhs: Control.Exception.SomeException + name: "Use 'SomeException' from Relude" + note: "'SomeException' is already exported from Relude" + rhs: SomeException +- warn: + lhs: Control.Exception.toException + name: "Use 'toException' from Relude" + note: "'toException' is already exported from Relude" + rhs: toException +- warn: + lhs: Control.Exception.fromException + name: "Use 'fromException' from Relude" + note: "'fromException' is already exported from Relude" + rhs: fromException +- warn: + lhs: Control.Exception.displayException + name: "Use 'displayException' from Relude" + note: "'displayException' is already exported from Relude" + rhs: displayException +- warn: + lhs: Data.Foldable.asum + name: "Use 'asum' from Relude" + note: "'asum' is already exported from Relude" + rhs: asum +- warn: + lhs: Data.Foldable.find + name: "Use 'find' from Relude" + note: "'find' is already exported from Relude" + rhs: find +- warn: + lhs: Data.Foldable.find + name: "Use 'find' from Relude" + note: "'find' is already exported from Relude" + rhs: find +- warn: + lhs: Data.Foldable.fold + name: "Use 'fold' from Relude" + note: "'fold' is already exported from Relude" + rhs: fold +- warn: + lhs: "Data.Foldable.foldl'" + name: "Use 'foldl'' from Relude" + note: "'foldl'' is already exported from Relude" + rhs: "foldl'" +- warn: + lhs: Data.Foldable.forM_ + name: "Use 'forM_' from Relude" + note: "'forM_' is already exported from Relude" + rhs: forM_ +- warn: + lhs: Data.Foldable.for_ + name: "Use 'for_' from Relude" + note: "'for_' is already exported from Relude" + rhs: for_ +- warn: + lhs: Data.Foldable.sequenceA_ + name: "Use 'sequenceA_' from Relude" + note: "'sequenceA_' is already exported from Relude" + rhs: sequenceA_ +- warn: + lhs: Data.Foldable.toList + name: "Use 'toList' from Relude" + note: "'toList' is already exported from Relude" + rhs: toList +- warn: + lhs: Data.Foldable.traverse_ + name: "Use 'traverse_' from Relude" + note: "'traverse_' is already exported from Relude" + rhs: traverse_ +- warn: + lhs: Data.Traversable.forM + name: "Use 'forM' from Relude" + note: "'forM' is already exported from Relude" + rhs: forM +- warn: + lhs: Data.Traversable.mapAccumL + name: "Use 'mapAccumL' from Relude" + note: "'mapAccumL' is already exported from Relude" + rhs: mapAccumL +- warn: + lhs: Data.Traversable.mapAccumR + name: "Use 'mapAccumR' from Relude" + note: "'mapAccumR' is already exported from Relude" + rhs: mapAccumR +- warn: + lhs: "(Control.Arrow.&&&)" + name: "Use '&&&' from Relude" + note: "Operator '(&&&)' is already exported from Relude" + rhs: "(&&&)" +- warn: + lhs: "(Control.Category.>>>)" + name: "Use '>>>' from Relude" + note: "Operator '(>>>)' is already exported from Relude" + rhs: "(>>>)" +- warn: + lhs: "(Control.Category.<<<)" + name: "Use '<<<' from Relude" + note: "Operator '(<<<)' is already exported from Relude" + rhs: "(<<<)" +- warn: + lhs: Data.Function.fix + name: "Use 'fix' from Relude" + note: "'fix' is already exported from Relude" + rhs: fix +- warn: + lhs: Data.Function.on + name: "Use 'on' from Relude" + note: "'on' is already exported from Relude" + rhs: 'on' +- warn: + lhs: Data.Bifunctor.Bifunctor + name: "Use 'Bifunctor' from Relude" + note: "'Bifunctor' is already exported from Relude" + rhs: Bifunctor +- warn: + lhs: Data.Bifunctor.bimap + name: "Use 'bimap' from Relude" + note: "'bimap' is already exported from Relude" + rhs: bimap +- warn: + lhs: Data.Bifunctor.first + name: "Use 'first' from Relude" + note: "'first' is already exported from Relude" + rhs: first +- warn: + lhs: Data.Bifunctor.second + name: "Use 'second' from Relude" + note: "'second' is already exported from Relude" + rhs: second +- warn: + lhs: Data.Functor.void + name: "Use 'void' from Relude" + note: "'void' is already exported from Relude" + rhs: void +- warn: + lhs: "(Data.Functor.$>)" + name: "Use '$>' from Relude" + note: "Operator '($>)' is already exported from Relude" + rhs: "($>)" +- warn: + lhs: "(Data.Functor.<&>)" + name: "Use '<&>' from Relude" + note: "Operator '(<&>)' is already exported from Relude" + rhs: "(<&>)" +- warn: + lhs: Data.Functor.Compose.Compose + name: "Use 'Compose' from Relude" + note: "'Compose' is already exported from Relude" + rhs: Compose +- warn: + lhs: Data.Functor.Compose.getCompose + name: "Use 'getCompose' from Relude" + note: "'getCompose' is already exported from Relude" + rhs: getCompose +- warn: + lhs: Data.Functor.Identity.Identity + name: "Use 'Identity' from Relude" + note: "'Identity' is already exported from Relude" + rhs: Identity +- warn: + lhs: Data.Functor.Identity.runIdentity + name: "Use 'runIdentity' from Relude" + note: "'runIdentity' is already exported from Relude" + rhs: runIdentity +- warn: + lhs: Control.Concurrent.MVar.MVar + name: "Use 'MVar' from Relude" + note: "'MVar' is already exported from Relude" + rhs: MVar +- warn: + lhs: Control.Concurrent.MVar.newEmptyMVar + name: "Use 'newEmptyMVar' from Relude" + note: "'newEmptyMVar' is already exported from Relude" + rhs: newEmptyMVar +- warn: + lhs: Control.Concurrent.MVar.newMVar + name: "Use 'newMVar' from Relude" + note: "'newMVar' is already exported from Relude" + rhs: newMVar +- warn: + lhs: Control.Concurrent.MVar.putMVar + name: "Use 'putMVar' from Relude" + note: "'putMVar' is already exported from Relude" + rhs: putMVar +- warn: + lhs: Control.Concurrent.MVar.readMVar + name: "Use 'readMVar' from Relude" + note: "'readMVar' is already exported from Relude" + rhs: readMVar +- warn: + lhs: Control.Concurrent.MVar.swapMVar + name: "Use 'swapMVar' from Relude" + note: "'swapMVar' is already exported from Relude" + rhs: swapMVar +- warn: + lhs: Control.Concurrent.MVar.takeMVar + name: "Use 'takeMVar' from Relude" + note: "'takeMVar' is already exported from Relude" + rhs: takeMVar +- warn: + lhs: Control.Concurrent.MVar.tryPutMVar + name: "Use 'tryPutMVar' from Relude" + note: "'tryPutMVar' is already exported from Relude" + rhs: tryPutMVar +- warn: + lhs: Control.Concurrent.MVar.tryReadMVar + name: "Use 'tryReadMVar' from Relude" + note: "'tryReadMVar' is already exported from Relude" + rhs: tryReadMVar +- warn: + lhs: Control.Concurrent.MVar.tryTakeMVar + name: "Use 'tryTakeMVar' from Relude" + note: "'tryTakeMVar' is already exported from Relude" + rhs: tryTakeMVar +- warn: + lhs: Control.Monad.STM.STM + name: "Use 'STM' from Relude" + note: "'STM' is already exported from Relude" + rhs: STM +- warn: + lhs: Control.Monad.STM.atomically + name: "Use 'atomically' from Relude" + note: "'atomically' is already exported from Relude" + rhs: atomically +- warn: + lhs: Control.Monad.STM.throwSTM + name: "Use 'throwSTM' from Relude" + note: "'throwSTM' is already exported from Relude" + rhs: throwSTM +- warn: + lhs: Control.Monad.STM.catchSTM + name: "Use 'catchSTM' from Relude" + note: "'catchSTM' is already exported from Relude" + rhs: catchSTM +- warn: + lhs: Control.Concurrent.STM.TVar.TVar + name: "Use 'TVar' from Relude" + note: "'TVar' is already exported from Relude" + rhs: TVar +- warn: + lhs: Control.Concurrent.STM.TVar.newTVarIO + name: "Use 'newTVarIO' from Relude" + note: "'newTVarIO' is already exported from Relude" + rhs: newTVarIO +- warn: + lhs: Control.Concurrent.STM.TVar.readTVarIO + name: "Use 'readTVarIO' from Relude" + note: "'readTVarIO' is already exported from Relude" + rhs: readTVarIO +- warn: + lhs: "Control.Concurrent.STM.TVar.modifyTVar'" + name: "Use 'modifyTVar'' from Relude" + note: "'modifyTVar'' is already exported from Relude" + rhs: "modifyTVar'" +- warn: + lhs: Control.Concurrent.STM.TVar.newTVar + name: "Use 'newTVar' from Relude" + note: "'newTVar' is already exported from Relude" + rhs: newTVar +- warn: + lhs: Control.Concurrent.STM.TVar.readTVar + name: "Use 'readTVar' from Relude" + note: "'readTVar' is already exported from Relude" + rhs: readTVar +- warn: + lhs: Control.Concurrent.STM.TVar.writeTVar + name: "Use 'writeTVar' from Relude" + note: "'writeTVar' is already exported from Relude" + rhs: writeTVar +- warn: + lhs: Control.Concurrent.STM.TMVar.TMVar + name: "Use 'TMVar' from Relude" + note: "'TMVar' is already exported from Relude" + rhs: TMVar +- warn: + lhs: Control.Concurrent.STM.TMVar.newTMVar + name: "Use 'newTMVar' from Relude" + note: "'newTMVar' is already exported from Relude" + rhs: newTMVar +- warn: + lhs: Control.Concurrent.STM.TMVar.newEmptyTMVar + name: "Use 'newEmptyTMVar' from Relude" + note: "'newEmptyTMVar' is already exported from Relude" + rhs: newEmptyTMVar +- warn: + lhs: Control.Concurrent.STM.TMVar.newTMVarIO + name: "Use 'newTMVarIO' from Relude" + note: "'newTMVarIO' is already exported from Relude" + rhs: newTMVarIO +- warn: + lhs: Control.Concurrent.STM.TMVar.newEmptyTMVarIO + name: "Use 'newEmptyTMVarIO' from Relude" + note: "'newEmptyTMVarIO' is already exported from Relude" + rhs: newEmptyTMVarIO +- warn: + lhs: Control.Concurrent.STM.TMVar.takeTMVar + name: "Use 'takeTMVar' from Relude" + note: "'takeTMVar' is already exported from Relude" + rhs: takeTMVar +- warn: + lhs: Control.Concurrent.STM.TMVar.putTMVar + name: "Use 'putTMVar' from Relude" + note: "'putTMVar' is already exported from Relude" + rhs: putTMVar +- warn: + lhs: Control.Concurrent.STM.TMVar.readTMVar + name: "Use 'readTMVar' from Relude" + note: "'readTMVar' is already exported from Relude" + rhs: readTMVar +- warn: + lhs: Control.Concurrent.STM.TMVar.tryReadTMVar + name: "Use 'tryReadTMVar' from Relude" + note: "'tryReadTMVar' is already exported from Relude" + rhs: tryReadTMVar +- warn: + lhs: Control.Concurrent.STM.TMVar.swapTMVar + name: "Use 'swapTMVar' from Relude" + note: "'swapTMVar' is already exported from Relude" + rhs: swapTMVar +- warn: + lhs: Control.Concurrent.STM.TMVar.tryTakeTMVar + name: "Use 'tryTakeTMVar' from Relude" + note: "'tryTakeTMVar' is already exported from Relude" + rhs: tryTakeTMVar +- warn: + lhs: Control.Concurrent.STM.TMVar.tryPutTMVar + name: "Use 'tryPutTMVar' from Relude" + note: "'tryPutTMVar' is already exported from Relude" + rhs: tryPutTMVar +- warn: + lhs: Control.Concurrent.STM.TMVar.isEmptyTMVar + name: "Use 'isEmptyTMVar' from Relude" + note: "'isEmptyTMVar' is already exported from Relude" + rhs: isEmptyTMVar +- warn: + lhs: Control.Concurrent.STM.TMVar.mkWeakTMVar + name: "Use 'mkWeakTMVar' from Relude" + note: "'mkWeakTMVar' is already exported from Relude" + rhs: mkWeakTMVar +- warn: + lhs: Data.IORef.IORef + name: "Use 'IORef' from Relude" + note: "'IORef' is already exported from Relude" + rhs: IORef +- warn: + lhs: Data.IORef.atomicModifyIORef + name: "Use 'atomicModifyIORef' from Relude" + note: "'atomicModifyIORef' is already exported from Relude" + rhs: atomicModifyIORef +- warn: + lhs: "Data.IORef.atomicModifyIORef'" + name: "Use 'atomicModifyIORef'' from Relude" + note: "'atomicModifyIORef'' is already exported from Relude" + rhs: "atomicModifyIORef'" +- warn: + lhs: Data.IORef.atomicWriteIORef + name: "Use 'atomicWriteIORef' from Relude" + note: "'atomicWriteIORef' is already exported from Relude" + rhs: atomicWriteIORef +- warn: + lhs: Data.IORef.modifyIORef + name: "Use 'modifyIORef' from Relude" + note: "'modifyIORef' is already exported from Relude" + rhs: modifyIORef +- warn: + lhs: "Data.IORef.modifyIORef'" + name: "Use 'modifyIORef'' from Relude" + note: "'modifyIORef'' is already exported from Relude" + rhs: "modifyIORef'" +- warn: + lhs: Data.IORef.newIORef + name: "Use 'newIORef' from Relude" + note: "'newIORef' is already exported from Relude" + rhs: newIORef +- warn: + lhs: Data.IORef.readIORef + name: "Use 'readIORef' from Relude" + note: "'readIORef' is already exported from Relude" + rhs: readIORef +- warn: + lhs: Data.IORef.writeIORef + name: "Use 'writeIORef' from Relude" + note: "'writeIORef' is already exported from Relude" + rhs: writeIORef +- warn: + lhs: "atomicModifyIORef ref (\\a -> (f a, ()))" + rhs: atomicModifyIORef_ ref f +- warn: + lhs: "atomicModifyIORef ref $ \\a -> (f a, ())" + rhs: atomicModifyIORef_ ref f +- warn: + lhs: "atomicModifyIORef' ref $ \\a -> (f a, ())" + rhs: "atomicModifyIORef'_ ref f" +- warn: + lhs: "atomicModifyIORef' ref (\\a -> (f a, ()))" + rhs: "atomicModifyIORef'_ ref f" +- warn: + lhs: Data.Text.IO.getLine + name: "Use 'getLine' from Relude" + note: "'getLine' is already exported from Relude" + rhs: getLine +- warn: + lhs: System.IO.hFlush + name: "Use 'hFlush' from Relude" + note: "'hFlush' is already exported from Relude" + rhs: hFlush +- warn: + lhs: System.IO.hIsEOF + name: "Use 'hIsEOF' from Relude" + note: "'hIsEOF' is already exported from Relude" + rhs: hIsEOF +- warn: + lhs: System.IO.hSetBuffering + name: "Use 'hSetBuffering' from Relude" + note: "'hSetBuffering' is already exported from Relude" + rhs: hSetBuffering +- warn: + lhs: System.IO.hGetBuffering + name: "Use 'hGetBuffering' from Relude" + note: "'hGetBuffering' is already exported from Relude" + rhs: hGetBuffering +- warn: + lhs: System.IO.Handle + name: "Use 'Handle' from Relude" + note: "'Handle' is already exported from Relude" + rhs: Handle +- warn: + lhs: System.IO.stdin + name: "Use 'stdin' from Relude" + note: "'stdin' is already exported from Relude" + rhs: stdin +- warn: + lhs: System.IO.stdout + name: "Use 'stdout' from Relude" + note: "'stdout' is already exported from Relude" + rhs: stdout +- warn: + lhs: System.IO.stderr + name: "Use 'stderr' from Relude" + note: "'stderr' is already exported from Relude" + rhs: stderr +- warn: + lhs: System.IO.withFile + name: "Use 'withFile' from Relude" + note: "'withFile' is already exported from Relude" + rhs: withFile +- warn: + lhs: System.IO.BufferMode + name: "Use 'BufferMode' from Relude" + note: "'BufferMode' is already exported from Relude" + rhs: BufferMode +- warn: + lhs: System.Environment.getArgs + name: "Use 'getArgs' from Relude" + note: "'getArgs' is already exported from Relude" + rhs: getArgs +- warn: + lhs: System.Environment.lookupEnv + name: "Use 'lookupEnv' from Relude" + note: "'lookupEnv' is already exported from Relude" + rhs: lookupEnv +- warn: + lhs: Data.List.genericDrop + name: "Use 'genericDrop' from Relude" + note: "'genericDrop' is already exported from Relude" + rhs: genericDrop +- warn: + lhs: Data.List.genericLength + name: "Use 'genericLength' from Relude" + note: "'genericLength' is already exported from Relude" + rhs: genericLength +- warn: + lhs: Data.List.genericReplicate + name: "Use 'genericReplicate' from Relude" + note: "'genericReplicate' is already exported from Relude" + rhs: genericReplicate +- warn: + lhs: Data.List.genericSplitAt + name: "Use 'genericSplitAt' from Relude" + note: "'genericSplitAt' is already exported from Relude" + rhs: genericSplitAt +- warn: + lhs: Data.List.genericTake + name: "Use 'genericTake' from Relude" + note: "'genericTake' is already exported from Relude" + rhs: genericTake +- warn: + lhs: Data.List.group + name: "Use 'group' from Relude" + note: "'group' is already exported from Relude" + rhs: group +- warn: + lhs: Data.List.inits + name: "Use 'inits' from Relude" + note: "'inits' is already exported from Relude" + rhs: inits +- warn: + lhs: Data.List.intercalate + name: "Use 'intercalate' from Relude" + note: "'intercalate' is already exported from Relude" + rhs: intercalate +- warn: + lhs: Data.List.intersperse + name: "Use 'intersperse' from Relude" + note: "'intersperse' is already exported from Relude" + rhs: intersperse +- warn: + lhs: Data.List.isPrefixOf + name: "Use 'isPrefixOf' from Relude" + note: "'isPrefixOf' is already exported from Relude" + rhs: isPrefixOf +- warn: + lhs: Data.List.permutations + name: "Use 'permutations' from Relude" + note: "'permutations' is already exported from Relude" + rhs: permutations +- warn: + lhs: "Data.List.scanl'" + name: "Use 'scanl'' from Relude" + note: "'scanl'' is already exported from Relude" + rhs: "scanl'" +- warn: + lhs: Data.List.sort + name: "Use 'sort' from Relude" + note: "'sort' is already exported from Relude" + rhs: sort +- warn: + lhs: Data.List.sortBy + name: "Use 'sortBy' from Relude" + note: "'sortBy' is already exported from Relude" + rhs: sortBy +- warn: + lhs: Data.List.sortOn + name: "Use 'sortOn' from Relude" + note: "'sortOn' is already exported from Relude" + rhs: sortOn +- warn: + lhs: Data.List.subsequences + name: "Use 'subsequences' from Relude" + note: "'subsequences' is already exported from Relude" + rhs: subsequences +- warn: + lhs: Data.List.tails + name: "Use 'tails' from Relude" + note: "'tails' is already exported from Relude" + rhs: tails +- warn: + lhs: Data.List.transpose + name: "Use 'transpose' from Relude" + note: "'transpose' is already exported from Relude" + rhs: transpose +- warn: + lhs: Data.List.uncons + name: "Use 'uncons' from Relude" + note: "'uncons' is already exported from Relude" + rhs: uncons +- warn: + lhs: Data.List.unfoldr + name: "Use 'unfoldr' from Relude" + note: "'unfoldr' is already exported from Relude" + rhs: unfoldr +- warn: + lhs: Data.List.NonEmpty.NonEmpty + name: "Use 'NonEmpty' from Relude" + note: "'NonEmpty' is already exported from Relude" + rhs: NonEmpty +- warn: + lhs: "(Data.List.NonEmpty.:|)" + name: "Use ':|' from Relude" + note: "Operator '(:|)' is already exported from Relude" + rhs: "(:|)" +- warn: + lhs: Data.List.NonEmpty.nonEmpty + name: "Use 'nonEmpty' from Relude" + note: "'nonEmpty' is already exported from Relude" + rhs: nonEmpty +- warn: + lhs: Data.List.NonEmpty.head + name: "Use 'head' from Relude" + note: "'head' is already exported from Relude" + rhs: head +- warn: + lhs: Data.List.NonEmpty.init + name: "Use 'init' from Relude" + note: "'init' is already exported from Relude" + rhs: init +- warn: + lhs: Data.List.NonEmpty.last + name: "Use 'last' from Relude" + note: "'last' is already exported from Relude" + rhs: last +- warn: + lhs: Data.List.NonEmpty.tail + name: "Use 'tail' from Relude" + note: "'tail' is already exported from Relude" + rhs: tail +- warn: + lhs: GHC.Exts.sortWith + name: "Use 'sortWith' from Relude" + note: "'sortWith' is already exported from Relude" + rhs: sortWith +- warn: + lhs: Control.Monad.Except.ExceptT + name: "Use 'ExceptT' from Relude" + note: "'ExceptT' is already exported from Relude" + rhs: ExceptT +- warn: + lhs: Control.Monad.Except.runExceptT + name: "Use 'runExceptT' from Relude" + note: "'runExceptT' is already exported from Relude" + rhs: runExceptT +- warn: + lhs: Control.Monad.Reader.MonadReader + name: "Use 'MonadReader' from Relude" + note: "'MonadReader' is already exported from Relude" + rhs: MonadReader +- warn: + lhs: Control.Monad.Reader.Reader + name: "Use 'Reader' from Relude" + note: "'Reader' is already exported from Relude" + rhs: Reader +- warn: + lhs: Control.Monad.Reader.ReaderT + name: "Use 'ReaderT' from Relude" + note: "'ReaderT' is already exported from Relude" + rhs: ReaderT +- warn: + lhs: Control.Monad.Reader.runReaderT + name: "Use 'runReaderT' from Relude" + note: "'runReaderT' is already exported from Relude" + rhs: runReaderT +- warn: + lhs: Control.Monad.Reader.ask + name: "Use 'ask' from Relude" + note: "'ask' is already exported from Relude" + rhs: ask +- warn: + lhs: Control.Monad.Reader.asks + name: "Use 'asks' from Relude" + note: "'asks' is already exported from Relude" + rhs: asks +- warn: + lhs: Control.Monad.Reader.local + name: "Use 'local' from Relude" + note: "'local' is already exported from Relude" + rhs: local +- warn: + lhs: Control.Monad.Reader.reader + name: "Use 'reader' from Relude" + note: "'reader' is already exported from Relude" + rhs: reader +- warn: + lhs: Control.Monad.Reader.runReader + name: "Use 'runReader' from Relude" + note: "'runReader' is already exported from Relude" + rhs: runReader +- warn: + lhs: Control.Monad.Reader.withReader + name: "Use 'withReader' from Relude" + note: "'withReader' is already exported from Relude" + rhs: withReader +- warn: + lhs: Control.Monad.Reader.withReaderT + name: "Use 'withReaderT' from Relude" + note: "'withReaderT' is already exported from Relude" + rhs: withReaderT +- warn: + lhs: Control.Monad.State.Strict.MonadState + name: "Use 'MonadState' from Relude" + note: "'MonadState' is already exported from Relude" + rhs: MonadState +- warn: + lhs: Control.Monad.State.Strict.State + name: "Use 'State' from Relude" + note: "'State' is already exported from Relude" + rhs: State +- warn: + lhs: Control.Monad.State.Strict.StateT + name: "Use 'StateT' from Relude" + note: "'StateT' is already exported from Relude" + rhs: StateT +- warn: + lhs: Control.Monad.State.Strict.runStateT + name: "Use 'runStateT' from Relude" + note: "'runStateT' is already exported from Relude" + rhs: runStateT +- warn: + lhs: Control.Monad.State.Strict.evalState + name: "Use 'evalState' from Relude" + note: "'evalState' is already exported from Relude" + rhs: evalState +- warn: + lhs: Control.Monad.State.Strict.evalStateT + name: "Use 'evalStateT' from Relude" + note: "'evalStateT' is already exported from Relude" + rhs: evalStateT +- warn: + lhs: Control.Monad.State.Strict.execState + name: "Use 'execState' from Relude" + note: "'execState' is already exported from Relude" + rhs: execState +- warn: + lhs: Control.Monad.State.Strict.execStateT + name: "Use 'execStateT' from Relude" + note: "'execStateT' is already exported from Relude" + rhs: execStateT +- warn: + lhs: Control.Monad.State.Strict.get + name: "Use 'get' from Relude" + note: "'get' is already exported from Relude" + rhs: get +- warn: + lhs: Control.Monad.State.Strict.gets + name: "Use 'gets' from Relude" + note: "'gets' is already exported from Relude" + rhs: gets +- warn: + lhs: Control.Monad.State.Strict.modify + name: "Use 'modify' from Relude" + note: "'modify' is already exported from Relude" + rhs: modify +- warn: + lhs: "Control.Monad.State.Strict.modify'" + name: "Use 'modify'' from Relude" + note: "'modify'' is already exported from Relude" + rhs: "modify'" +- warn: + lhs: Control.Monad.State.Strict.put + name: "Use 'put' from Relude" + note: "'put' is already exported from Relude" + rhs: put +- warn: + lhs: Control.Monad.State.Strict.runState + name: "Use 'runState' from Relude" + note: "'runState' is already exported from Relude" + rhs: runState +- warn: + lhs: Control.Monad.State.Strict.state + name: "Use 'state' from Relude" + note: "'state' is already exported from Relude" + rhs: state +- warn: + lhs: Control.Monad.State.Strict.withState + name: "Use 'withState' from Relude" + note: "'withState' is already exported from Relude" + rhs: withState +- warn: + lhs: Control.Monad.Trans.MonadIO + name: "Use 'MonadIO' from Relude" + note: "'MonadIO' is already exported from Relude" + rhs: MonadIO +- warn: + lhs: Control.Monad.Trans.MonadTrans + name: "Use 'MonadTrans' from Relude" + note: "'MonadTrans' is already exported from Relude" + rhs: MonadTrans +- warn: + lhs: Control.Monad.Trans.lift + name: "Use 'lift' from Relude" + note: "'lift' is already exported from Relude" + rhs: lift +- warn: + lhs: Control.Monad.Trans.liftIO + name: "Use 'liftIO' from Relude" + note: "'liftIO' is already exported from Relude" + rhs: liftIO +- warn: + lhs: Control.Monad.Trans.Identity.IdentityT + name: "Use 'IdentityT' from Relude" + note: "'IdentityT' is already exported from Relude" + rhs: IdentityT +- warn: + lhs: Control.Monad.Trans.Identity.runIdentityT + name: "Use 'runIdentityT' from Relude" + note: "'runIdentityT' is already exported from Relude" + rhs: runIdentityT +- warn: + lhs: Control.Monad.Trans.Maybe.MaybeT + name: "Use 'MaybeT' from Relude" + note: "'MaybeT' is already exported from Relude" + rhs: MaybeT +- warn: + lhs: Control.Monad.Trans.Maybe.maybeToExceptT + name: "Use 'maybeToExceptT' from Relude" + note: "'maybeToExceptT' is already exported from Relude" + rhs: maybeToExceptT +- warn: + lhs: Control.Monad.Trans.Maybe.exceptToMaybeT + name: "Use 'exceptToMaybeT' from Relude" + note: "'exceptToMaybeT' is already exported from Relude" + rhs: exceptToMaybeT +- warn: + lhs: Control.Monad.MonadPlus + name: "Use 'MonadPlus' from Relude" + note: "'MonadPlus' is already exported from Relude" + rhs: MonadPlus +- warn: + lhs: Control.Monad.mzero + name: "Use 'mzero' from Relude" + note: "'mzero' is already exported from Relude" + rhs: mzero +- warn: + lhs: Control.Monad.mplus + name: "Use 'mplus' from Relude" + note: "'mplus' is already exported from Relude" + rhs: mplus +- warn: + lhs: Control.Monad.filterM + name: "Use 'filterM' from Relude" + note: "'filterM' is already exported from Relude" + rhs: filterM +- warn: + lhs: Control.Monad.forever + name: "Use 'forever' from Relude" + note: "'forever' is already exported from Relude" + rhs: forever +- warn: + lhs: Control.Monad.join + name: "Use 'join' from Relude" + note: "'join' is already exported from Relude" + rhs: join +- warn: + lhs: Control.Monad.mapAndUnzipM + name: "Use 'mapAndUnzipM' from Relude" + note: "'mapAndUnzipM' is already exported from Relude" + rhs: mapAndUnzipM +- warn: + lhs: Control.Monad.mfilter + name: "Use 'mfilter' from Relude" + note: "'mfilter' is already exported from Relude" + rhs: mfilter +- warn: + lhs: Control.Monad.replicateM + name: "Use 'replicateM' from Relude" + note: "'replicateM' is already exported from Relude" + rhs: replicateM +- warn: + lhs: Control.Monad.replicateM_ + name: "Use 'replicateM_' from Relude" + note: "'replicateM_' is already exported from Relude" + rhs: replicateM_ +- warn: + lhs: Control.Monad.zipWithM + name: "Use 'zipWithM' from Relude" + note: "'zipWithM' is already exported from Relude" + rhs: zipWithM +- warn: + lhs: Control.Monad.zipWithM_ + name: "Use 'zipWithM_' from Relude" + note: "'zipWithM_' is already exported from Relude" + rhs: zipWithM_ +- warn: + lhs: "(Control.Monad.<$!>)" + name: "Use '<$!>' from Relude" + note: "Operator '(<$!>)' is already exported from Relude" + rhs: "(<$!>)" +- warn: + lhs: "(Control.Monad.<=<)" + name: "Use '<=<' from Relude" + note: "Operator '(<=<)' is already exported from Relude" + rhs: "(<=<)" +- warn: + lhs: "(Control.Monad.=<<)" + name: "Use '=<<' from Relude" + note: "Operator '(=<<)' is already exported from Relude" + rhs: "(=<<)" +- warn: + lhs: "(Control.Monad.>=>)" + name: "Use '>=>' from Relude" + note: "Operator '(>=>)' is already exported from Relude" + rhs: "(>=>)" +- warn: + lhs: Control.Monad.Fail.MonadFail + name: "Use 'MonadFail' from Relude" + note: "'MonadFail' is already exported from Relude" + rhs: MonadFail +- warn: + lhs: Data.Maybe.catMaybes + name: "Use 'catMaybes' from Relude" + note: "'catMaybes' is already exported from Relude" + rhs: catMaybes +- warn: + lhs: Data.Maybe.fromMaybe + name: "Use 'fromMaybe' from Relude" + note: "'fromMaybe' is already exported from Relude" + rhs: fromMaybe +- warn: + lhs: Data.Maybe.isJust + name: "Use 'isJust' from Relude" + note: "'isJust' is already exported from Relude" + rhs: isJust +- warn: + lhs: Data.Maybe.isNothing + name: "Use 'isNothing' from Relude" + note: "'isNothing' is already exported from Relude" + rhs: isNothing +- warn: + lhs: Data.Maybe.listToMaybe + name: "Use 'listToMaybe' from Relude" + note: "'listToMaybe' is already exported from Relude" + rhs: listToMaybe +- warn: + lhs: Data.Maybe.mapMaybe + name: "Use 'mapMaybe' from Relude" + note: "'mapMaybe' is already exported from Relude" + rhs: mapMaybe +- warn: + lhs: Data.Maybe.maybeToList + name: "Use 'maybeToList' from Relude" + note: "'maybeToList' is already exported from Relude" + rhs: maybeToList +- warn: + lhs: Data.Either.isLeft + name: "Use 'isLeft' from Relude" + note: "'isLeft' is already exported from Relude" + rhs: isLeft +- warn: + lhs: Data.Either.isRight + name: "Use 'isRight' from Relude" + note: "'isRight' is already exported from Relude" + rhs: isRight +- warn: + lhs: Data.Either.lefts + name: "Use 'lefts' from Relude" + note: "'lefts' is already exported from Relude" + rhs: lefts +- warn: + lhs: Data.Either.partitionEithers + name: "Use 'partitionEithers' from Relude" + note: "'partitionEithers' is already exported from Relude" + rhs: partitionEithers +- warn: + lhs: Data.Either.rights + name: "Use 'rights' from Relude" + note: "'rights' is already exported from Relude" + rhs: rights +- warn: + lhs: Data.Monoid.All + name: "Use 'All' from Relude" + note: "'All' is already exported from Relude" + rhs: All +- warn: + lhs: Data.Monoid.getAll + name: "Use 'getAll' from Relude" + note: "'getAll' is already exported from Relude" + rhs: getAll +- warn: + lhs: Data.Monoid.Alt + name: "Use 'Alt' from Relude" + note: "'Alt' is already exported from Relude" + rhs: Alt +- warn: + lhs: Data.Monoid.getAlt + name: "Use 'getAlt' from Relude" + note: "'getAlt' is already exported from Relude" + rhs: getAlt +- warn: + lhs: Data.Monoid.Any + name: "Use 'Any' from Relude" + note: "'Any' is already exported from Relude" + rhs: Any +- warn: + lhs: Data.Monoid.getAny + name: "Use 'getAny' from Relude" + note: "'getAny' is already exported from Relude" + rhs: getAny +- warn: + lhs: Data.Monoid.Ap + name: "Use 'Ap' from Relude" + note: "'Ap' is already exported from Relude" + rhs: Ap +- warn: + lhs: Data.Monoid.getAp + name: "Use 'getAp' from Relude" + note: "'getAp' is already exported from Relude" + rhs: getAp +- warn: + lhs: Data.Monoid.Dual + name: "Use 'Dual' from Relude" + note: "'Dual' is already exported from Relude" + rhs: Dual +- warn: + lhs: Data.Monoid.getDual + name: "Use 'getDual' from Relude" + note: "'getDual' is already exported from Relude" + rhs: getDual +- warn: + lhs: Data.Monoid.Endo + name: "Use 'Endo' from Relude" + note: "'Endo' is already exported from Relude" + rhs: Endo +- warn: + lhs: Data.Monoid.appEndo + name: "Use 'appEndo' from Relude" + note: "'appEndo' is already exported from Relude" + rhs: appEndo +- warn: + lhs: Data.Monoid.First + name: "Use 'First' from Relude" + note: "'First' is already exported from Relude" + rhs: First +- warn: + lhs: Data.Monoid.getFirst + name: "Use 'getFirst' from Relude" + note: "'getFirst' is already exported from Relude" + rhs: getFirst +- warn: + lhs: Data.Monoid.Last + name: "Use 'Last' from Relude" + note: "'Last' is already exported from Relude" + rhs: Last +- warn: + lhs: Data.Monoid.getLast + name: "Use 'getLast' from Relude" + note: "'getLast' is already exported from Relude" + rhs: getLast +- warn: + lhs: Data.Monoid.Product + name: "Use 'Product' from Relude" + note: "'Product' is already exported from Relude" + rhs: Product +- warn: + lhs: Data.Monoid.getProduct + name: "Use 'getProduct' from Relude" + note: "'getProduct' is already exported from Relude" + rhs: getProduct +- warn: + lhs: Data.Monoid.Sum + name: "Use 'Sum' from Relude" + note: "'Sum' is already exported from Relude" + rhs: Sum +- warn: + lhs: Data.Monoid.getSum + name: "Use 'getSum' from Relude" + note: "'getSum' is already exported from Relude" + rhs: getSum +- warn: + lhs: Data.Semigroup.Option + name: "Use 'Option' from Relude" + note: "'Option' is already exported from Relude" + rhs: Option +- warn: + lhs: Data.Semigroup.getOption + name: "Use 'getOption' from Relude" + note: "'getOption' is already exported from Relude" + rhs: getOption +- warn: + lhs: Data.Semigroup.Semigroup + name: "Use 'Semigroup' from Relude" + note: "'Semigroup' is already exported from Relude" + rhs: Semigroup +- warn: + lhs: Data.Semigroup.sconcat + name: "Use 'sconcat' from Relude" + note: "'sconcat' is already exported from Relude" + rhs: sconcat +- warn: + lhs: Data.Semigroup.stimes + name: "Use 'stimes' from Relude" + note: "'stimes' is already exported from Relude" + rhs: stimes +- warn: + lhs: "(Data.Semigroup.<>)" + name: "Use '<>' from Relude" + note: "Operator '(<>)' is already exported from Relude" + rhs: "(<>)" +- warn: + lhs: Data.Semigroup.WrappedMonoid + name: "Use 'WrappedMonoid' from Relude" + note: "'WrappedMonoid' is already exported from Relude" + rhs: WrappedMonoid +- warn: + lhs: Data.Semigroup.cycle1 + name: "Use 'cycle1' from Relude" + note: "'cycle1' is already exported from Relude" + rhs: cycle1 +- warn: + lhs: Data.Semigroup.mtimesDefault + name: "Use 'mtimesDefault' from Relude" + note: "'mtimesDefault' is already exported from Relude" + rhs: mtimesDefault +- warn: + lhs: Data.Semigroup.stimesIdempotent + name: "Use 'stimesIdempotent' from Relude" + note: "'stimesIdempotent' is already exported from Relude" + rhs: stimesIdempotent +- warn: + lhs: Data.Semigroup.stimesIdempotentMonoid + name: "Use 'stimesIdempotentMonoid' from Relude" + note: "'stimesIdempotentMonoid' is already exported from Relude" + rhs: stimesIdempotentMonoid +- warn: + lhs: Data.Semigroup.stimesMonoid + name: "Use 'stimesMonoid' from Relude" + note: "'stimesMonoid' is already exported from Relude" + rhs: stimesMonoid +- warn: + lhs: Data.ByteString.ByteString + name: "Use 'ByteString' from Relude" + note: "'ByteString' is already exported from Relude" + rhs: ByteString +- warn: + lhs: Data.ByteString.Short.ShortByteString + name: "Use 'ShortByteString' from Relude" + note: "'ShortByteString' is already exported from Relude" + rhs: ShortByteString +- warn: + lhs: Data.ByteString.Short.toShort + name: "Use 'toShort' from Relude" + note: "'toShort' is already exported from Relude" + rhs: toShort +- warn: + lhs: Data.ByteString.Short.fromShort + name: "Use 'fromShort' from Relude" + note: "'fromShort' is already exported from Relude" + rhs: fromShort +- warn: + lhs: Data.String.IsString + name: "Use 'IsString' from Relude" + note: "'IsString' is already exported from Relude" + rhs: IsString +- warn: + lhs: Data.String.fromString + name: "Use 'fromString' from Relude" + note: "'fromString' is already exported from Relude" + rhs: fromString +- warn: + lhs: Data.Text.Text + name: "Use 'Text' from Relude" + note: "'Text' is already exported from Relude" + rhs: Text +- warn: + lhs: Data.Text.lines + name: "Use 'lines' from Relude" + note: "'lines' is already exported from Relude" + rhs: lines +- warn: + lhs: Data.Text.unlines + name: "Use 'unlines' from Relude" + note: "'unlines' is already exported from Relude" + rhs: unlines +- warn: + lhs: Data.Text.words + name: "Use 'words' from Relude" + note: "'words' is already exported from Relude" + rhs: words +- warn: + lhs: Data.Text.unwords + name: "Use 'unwords' from Relude" + note: "'unwords' is already exported from Relude" + rhs: unwords +- warn: + lhs: "Data.Text.Encoding.decodeUtf8'" + name: "Use 'decodeUtf8'' from Relude" + note: "'decodeUtf8'' is already exported from Relude" + rhs: "decodeUtf8'" +- warn: + lhs: Data.Text.Encoding.decodeUtf8With + name: "Use 'decodeUtf8With' from Relude" + note: "'decodeUtf8With' is already exported from Relude" + rhs: decodeUtf8With +- warn: + lhs: Data.Text.Encoding.Error.OnDecodeError + name: "Use 'OnDecodeError' from Relude" + note: "'OnDecodeError' is already exported from Relude" + rhs: OnDecodeError +- warn: + lhs: Data.Text.Encoding.Error.OnError + name: "Use 'OnError' from Relude" + note: "'OnError' is already exported from Relude" + rhs: OnError +- warn: + lhs: Data.Text.Encoding.Error.UnicodeException + name: "Use 'UnicodeException' from Relude" + note: "'UnicodeException' is already exported from Relude" + rhs: UnicodeException +- warn: + lhs: Data.Text.Encoding.Error.lenientDecode + name: "Use 'lenientDecode' from Relude" + note: "'lenientDecode' is already exported from Relude" + rhs: lenientDecode +- warn: + lhs: Data.Text.Encoding.Error.strictDecode + name: "Use 'strictDecode' from Relude" + note: "'strictDecode' is already exported from Relude" + rhs: strictDecode +- warn: + lhs: Text.Read.Read + name: "Use 'Read' from Relude" + note: "'Read' is already exported from Relude" + rhs: Read +- warn: + lhs: Text.Read.readMaybe + name: "Use 'readMaybe' from Relude" + note: "'readMaybe' is already exported from Relude" + rhs: readMaybe +- warn: + lhs: "(liftIO (newEmptyMVar ))" + name: "'liftIO' is not needed" + note: "If you import 'newEmptyMVar' from Relude, it's already lifted" + rhs: newEmptyMVar +- warn: + lhs: "(liftIO (newMVar x))" + name: "'liftIO' is not needed" + note: "If you import 'newMVar' from Relude, it's already lifted" + rhs: newMVar +- warn: + lhs: "(liftIO (putMVar x y))" + name: "'liftIO' is not needed" + note: "If you import 'putMVar' from Relude, it's already lifted" + rhs: putMVar +- warn: + lhs: "(liftIO (readMVar x))" + name: "'liftIO' is not needed" + note: "If you import 'readMVar' from Relude, it's already lifted" + rhs: readMVar +- warn: + lhs: "(liftIO (swapMVar x y))" + name: "'liftIO' is not needed" + note: "If you import 'swapMVar' from Relude, it's already lifted" + rhs: swapMVar +- warn: + lhs: "(liftIO (takeMVar x))" + name: "'liftIO' is not needed" + note: "If you import 'takeMVar' from Relude, it's already lifted" + rhs: takeMVar +- warn: + lhs: "(liftIO (tryPutMVar x y))" + name: "'liftIO' is not needed" + note: "If you import 'tryPutMVar' from Relude, it's already lifted" + rhs: tryPutMVar +- warn: + lhs: "(liftIO (tryReadMVar x))" + name: "'liftIO' is not needed" + note: "If you import 'tryReadMVar' from Relude, it's already lifted" + rhs: tryReadMVar +- warn: + lhs: "(liftIO (tryTakeMVar x))" + name: "'liftIO' is not needed" + note: "If you import 'tryTakeMVar' from Relude, it's already lifted" + rhs: tryTakeMVar +- warn: + lhs: "(liftIO (atomically x))" + name: "'liftIO' is not needed" + note: "If you import 'atomically' from Relude, it's already lifted" + rhs: atomically +- warn: + lhs: "(liftIO (newTVarIO x))" + name: "'liftIO' is not needed" + note: "If you import 'newTVarIO' from Relude, it's already lifted" + rhs: newTVarIO +- warn: + lhs: "(liftIO (readTVarIO x))" + name: "'liftIO' is not needed" + note: "If you import 'readTVarIO' from Relude, it's already lifted" + rhs: readTVarIO +- warn: + lhs: "(liftIO (newTMVarIO x))" + name: "'liftIO' is not needed" + note: "If you import 'newTMVarIO' from Relude, it's already lifted" + rhs: newTMVarIO +- warn: + lhs: "(liftIO (newEmptyTMVarIO ))" + name: "'liftIO' is not needed" + note: "If you import 'newEmptyTMVarIO' from Relude, it's already lifted" + rhs: newEmptyTMVarIO +- warn: + lhs: "(liftIO (exitWith x))" + name: "'liftIO' is not needed" + note: "If you import 'exitWith' from Relude, it's already lifted" + rhs: exitWith +- warn: + lhs: "(liftIO (exitFailure ))" + name: "'liftIO' is not needed" + note: "If you import 'exitFailure' from Relude, it's already lifted" + rhs: exitFailure +- warn: + lhs: "(liftIO (exitSuccess ))" + name: "'liftIO' is not needed" + note: "If you import 'exitSuccess' from Relude, it's already lifted" + rhs: exitSuccess +- warn: + lhs: "(liftIO (die x))" + name: "'liftIO' is not needed" + note: "If you import 'die' from Relude, it's already lifted" + rhs: die +- warn: + lhs: "(liftIO (readFile x))" + name: "'liftIO' is not needed" + note: "If you import 'readFile' from Relude, it's already lifted" + rhs: readFile +- warn: + lhs: "(liftIO (writeFile x y))" + name: "'liftIO' is not needed" + note: "If you import 'writeFile' from Relude, it's already lifted" + rhs: writeFile +- warn: + lhs: "(liftIO (appendFile x y))" + name: "'liftIO' is not needed" + note: "If you import 'appendFile' from Relude, it's already lifted" + rhs: appendFile +- warn: + lhs: "(liftIO (readFileText x))" + name: "'liftIO' is not needed" + note: "If you import 'readFileText' from Relude, it's already lifted" + rhs: readFileText +- warn: + lhs: "(liftIO (writeFileText x y))" + name: "'liftIO' is not needed" + note: "If you import 'writeFileText' from Relude, it's already lifted" + rhs: writeFileText +- warn: + lhs: "(liftIO (appendFileText x y))" + name: "'liftIO' is not needed" + note: "If you import 'appendFileText' from Relude, it's already lifted" + rhs: appendFileText +- warn: + lhs: "(liftIO (readFileLText x))" + name: "'liftIO' is not needed" + note: "If you import 'readFileLText' from Relude, it's already lifted" + rhs: readFileLText +- warn: + lhs: "(liftIO (writeFileLText x y))" + name: "'liftIO' is not needed" + note: "If you import 'writeFileLText' from Relude, it's already lifted" + rhs: writeFileLText +- warn: + lhs: "(liftIO (appendFileLText x y))" + name: "'liftIO' is not needed" + note: "If you import 'appendFileLText' from Relude, it's already lifted" + rhs: appendFileLText +- warn: + lhs: "(liftIO (readFileBS x))" + name: "'liftIO' is not needed" + note: "If you import 'readFileBS' from Relude, it's already lifted" + rhs: readFileBS +- warn: + lhs: "(liftIO (writeFileBS x y))" + name: "'liftIO' is not needed" + note: "If you import 'writeFileBS' from Relude, it's already lifted" + rhs: writeFileBS +- warn: + lhs: "(liftIO (appendFileBS x y))" + name: "'liftIO' is not needed" + note: "If you import 'appendFileBS' from Relude, it's already lifted" + rhs: appendFileBS +- warn: + lhs: "(liftIO (readFileLBS x))" + name: "'liftIO' is not needed" + note: "If you import 'readFileLBS' from Relude, it's already lifted" + rhs: readFileLBS +- warn: + lhs: "(liftIO (writeFileLBS x y))" + name: "'liftIO' is not needed" + note: "If you import 'writeFileLBS' from Relude, it's already lifted" + rhs: writeFileLBS +- warn: + lhs: "(liftIO (appendFileLBS x y))" + name: "'liftIO' is not needed" + note: "If you import 'appendFileLBS' from Relude, it's already lifted" + rhs: appendFileLBS +- warn: + lhs: "(liftIO (newIORef x))" + name: "'liftIO' is not needed" + note: "If you import 'newIORef' from Relude, it's already lifted" + rhs: newIORef +- warn: + lhs: "(liftIO (readIORef x))" + name: "'liftIO' is not needed" + note: "If you import 'readIORef' from Relude, it's already lifted" + rhs: readIORef +- warn: + lhs: "(liftIO (writeIORef x y))" + name: "'liftIO' is not needed" + note: "If you import 'writeIORef' from Relude, it's already lifted" + rhs: writeIORef +- warn: + lhs: "(liftIO (modifyIORef x y))" + name: "'liftIO' is not needed" + note: "If you import 'modifyIORef' from Relude, it's already lifted" + rhs: modifyIORef +- warn: + lhs: "(liftIO (modifyIORef' x y))" + name: "'liftIO' is not needed" + note: "If you import 'modifyIORef'' from Relude, it's already lifted" + rhs: "modifyIORef'" +- warn: + lhs: "(liftIO (atomicModifyIORef x y))" + name: "'liftIO' is not needed" + note: "If you import 'atomicModifyIORef' from Relude, it's already lifted" + rhs: atomicModifyIORef +- warn: + lhs: "(liftIO (atomicModifyIORef' x y))" + name: "'liftIO' is not needed" + note: "If you import 'atomicModifyIORef'' from Relude, it's already lifted" + rhs: "atomicModifyIORef'" +- warn: + lhs: "(liftIO (atomicWriteIORef x y))" + name: "'liftIO' is not needed" + note: "If you import 'atomicWriteIORef' from Relude, it's already lifted" + rhs: atomicWriteIORef +- warn: + lhs: "(liftIO (getLine ))" + name: "'liftIO' is not needed" + note: "If you import 'getLine' from Relude, it's already lifted" + rhs: getLine +- warn: + lhs: "(liftIO (print x))" + name: "'liftIO' is not needed" + note: "If you import 'print' from Relude, it's already lifted" + rhs: print +- warn: + lhs: "(liftIO (putStr x))" + name: "'liftIO' is not needed" + note: "If you import 'putStr' from Relude, it's already lifted" + rhs: putStr +- warn: + lhs: "(liftIO (putStrLn x))" + name: "'liftIO' is not needed" + note: "If you import 'putStrLn' from Relude, it's already lifted" + rhs: putStrLn +- warn: + lhs: "(liftIO (putText x))" + name: "'liftIO' is not needed" + note: "If you import 'putText' from Relude, it's already lifted" + rhs: putText +- warn: + lhs: "(liftIO (putTextLn x))" + name: "'liftIO' is not needed" + note: "If you import 'putTextLn' from Relude, it's already lifted" + rhs: putTextLn +- warn: + lhs: "(liftIO (putLText x))" + name: "'liftIO' is not needed" + note: "If you import 'putLText' from Relude, it's already lifted" + rhs: putLText +- warn: + lhs: "(liftIO (putLTextLn x))" + name: "'liftIO' is not needed" + note: "If you import 'putLTextLn' from Relude, it's already lifted" + rhs: putLTextLn +- warn: + lhs: "(liftIO (putBS x))" + name: "'liftIO' is not needed" + note: "If you import 'putBS' from Relude, it's already lifted" + rhs: putBS +- warn: + lhs: "(liftIO (putBSLn x))" + name: "'liftIO' is not needed" + note: "If you import 'putBSLn' from Relude, it's already lifted" + rhs: putBSLn +- warn: + lhs: "(liftIO (putLBS x))" + name: "'liftIO' is not needed" + note: "If you import 'putLBS' from Relude, it's already lifted" + rhs: putLBS +- warn: + lhs: "(liftIO (putLBSLn x))" + name: "'liftIO' is not needed" + note: "If you import 'putLBSLn' from Relude, it's already lifted" + rhs: putLBSLn +- warn: + lhs: "(liftIO (hFlush x))" + name: "'liftIO' is not needed" + note: "If you import 'hFlush' from Relude, it's already lifted" + rhs: hFlush +- warn: + lhs: "(liftIO (hIsEOF x))" + name: "'liftIO' is not needed" + note: "If you import 'hIsEOF' from Relude, it's already lifted" + rhs: hIsEOF +- warn: + lhs: "(liftIO (hSetBuffering x y))" + name: "'liftIO' is not needed" + note: "If you import 'hSetBuffering' from Relude, it's already lifted" + rhs: hSetBuffering +- warn: + lhs: "(liftIO (hGetBuffering x))" + name: "'liftIO' is not needed" + note: "If you import 'hGetBuffering' from Relude, it's already lifted" + rhs: hGetBuffering +- warn: + lhs: "(liftIO (getArgs ))" + name: "'liftIO' is not needed" + note: "If you import 'getArgs' from Relude, it's already lifted" + rhs: getArgs +- warn: + lhs: "(liftIO (lookupEnv x))" + name: "'liftIO' is not needed" + note: "If you import 'lookupEnv' from Relude, it's already lifted" + rhs: lookupEnv +- hint: + lhs: "fmap (bimap f g)" + note: "Use `bimapF` from `Relude.Extra.Bifunctor`" + rhs: bimapF f g +- hint: + lhs: "bimap f g <$> x" + note: "Use `bimapF` from `Relude.Extra.Bifunctor`" + rhs: bimapF f g x +- hint: + lhs: "fmap (first f)" + note: "Use `firstF` from `Relude.Extra.Bifunctor`" + rhs: firstF f +- hint: + lhs: fmap . first + note: "Use `firstF` from `Relude.Extra.Bifunctor`" + rhs: firstF +- hint: + lhs: "fmap (second f)" + note: "Use `secondF` from `Relude.Extra.Bifunctor`" + rhs: secondF f +- hint: + lhs: fmap . second + note: "Use `secondF` from `Relude.Extra.Bifunctor`" + rhs: secondF +- hint: + lhs: "[minBound .. maxBound]" + note: "Use `universe` from `Relude.Extra.Enum`" + rhs: universe +- hint: + lhs: succ + note: "`succ` from `Prelude` is a pure function but it may throw exception. Consider using `next` from `Relude.Extra.Enum` instead." + rhs: next +- hint: + lhs: pred + note: "`pred` from `Prelude` is a pure function but it may throw exception. Consider using `prev` from `Relude.Extra.Enum` instead." + rhs: prev +- hint: + lhs: toEnum + note: "`toEnum` from `Prelude` is a pure function but it may throw exception. Consider using `safeToEnum` from `Relude.Extra.Enum` instead." + rhs: safeToEnum +- hint: + lhs: sum xs / length xs + note: "Use `average` from `Relude.Extra.Foldable`" + rhs: average xs +- hint: + lhs: "\\a -> (a, a)" + note: "Use `dup` from `Relude.Extra.Tuple`" + rhs: dup +- hint: + lhs: "\\a -> (f a, a)" + note: "Use `toFst` from `Relude.Extra.Tuple`" + rhs: toFst f +- hint: + lhs: "\\a -> (a, f a)" + note: "Use `toSnd` from `Relude.Extra.Tuple`" + rhs: toSnd f +- hint: + lhs: fmap . toFst + note: "Use `fmapToFst` from `Relude.Extra.Tuple`" + rhs: fmapToFst +- hint: + lhs: "fmap (toFst f)" + note: "Use `fmapToFst` from `Relude.Extra.Tuple`" + rhs: fmapToFst f +- hint: + lhs: fmap . toSnd + note: "Use `fmapToSnd` from `Relude.Extra.Tuple`" + rhs: fmapToSnd +- hint: + lhs: "fmap (toSnd f)" + note: "Use `fmapToSnd` from `Relude.Extra.Tuple`" + rhs: fmapToSnd f +- hint: + lhs: map . toFst + note: "Use `fmapToFst` from `Relude.Extra.Tuple`" + rhs: fmapToFst +- hint: + lhs: "map (toFst f)" + note: "Use `fmapToFst` from `Relude.Extra.Tuple`" + rhs: fmapToFst f +- hint: + lhs: map . toSnd + note: "Use `fmapToSnd` from `Relude.Extra.Tuple`" + rhs: fmapToSnd +- hint: + lhs: "map (toSnd f)" + note: "Use `fmapToSnd` from `Relude.Extra.Tuple`" + rhs: fmapToSnd f +- hint: + lhs: "fmap (,a) (f a)" + note: "Use `traverseToFst` from `Relude.Extra.Tuple`" + rhs: traverseToFst f a +- hint: + lhs: "fmap (flip (,) a) (f a)" + note: "Use `traverseToFst` from `Relude.Extra.Tuple`" + rhs: traverseToFst f a +- hint: + lhs: "(,a) <$> f a" + note: "Use `traverseToFst` from `Relude.Extra.Tuple`" + rhs: traverseToFst f a +- hint: + lhs: "flip (,) a <$> f a" + note: "Use `traverseToFst` from `Relude.Extra.Tuple`" + rhs: traverseToFst f a +- hint: + lhs: "fmap (a,) (f a)" + note: "Use `traverseToSnd` from `Relude.Extra.Tuple`" + rhs: traverseToSnd f a +- hint: + lhs: "fmap ((,) a) (f a)" + note: "Use `traverseToSnd` from `Relude.Extra.Tuple`" + rhs: traverseToSnd f a +- hint: + lhs: "(a,) <$> f a" + note: "Use `traverseToSnd` from `Relude.Extra.Tuple`" + rhs: traverseToSnd f a +- hint: + lhs: "(,) a <$> f a" + note: "Use `traverseToSnd` from `Relude.Extra.Tuple`" + rhs: traverseToSnd f a diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..26d3352 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,3 @@ +# Default ignored files +/shelf/ +/workspace.xml diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml new file mode 100644 index 0000000..919ce1f --- /dev/null +++ b/.idea/codeStyles/Project.xml @@ -0,0 +1,7 @@ + + + + + + \ No newline at end of file diff --git a/.idea/codeStyles/codeStyleConfig.xml b/.idea/codeStyles/codeStyleConfig.xml new file mode 100644 index 0000000..a55e7a1 --- /dev/null +++ b/.idea/codeStyles/codeStyleConfig.xml @@ -0,0 +1,5 @@ + + + + \ No newline at end of file diff --git a/.idea/encodings.xml b/.idea/encodings.xml new file mode 100644 index 0000000..15a15b2 --- /dev/null +++ b/.idea/encodings.xml @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/.idea/heltc.iml b/.idea/heltc.iml new file mode 100644 index 0000000..74ff9dd --- /dev/null +++ b/.idea/heltc.iml @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..639900d --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000..d7034b9 --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/sbt.xml b/.idea/sbt.xml new file mode 100644 index 0000000..c54a2c5 --- /dev/null +++ b/.idea/sbt.xml @@ -0,0 +1,7 @@ + + + + + \ No newline at end of file diff --git a/.idea/thriftCompiler.xml b/.idea/thriftCompiler.xml new file mode 100644 index 0000000..7bc123c --- /dev/null +++ b/.idea/thriftCompiler.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..35eb1dd --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.stan.toml b/.stan.toml new file mode 100644 index 0000000..e69de29 diff --git a/.stylish-haskell.yaml b/.stylish-haskell.yaml new file mode 100644 index 0000000..1162c6b --- /dev/null +++ b/.stylish-haskell.yaml @@ -0,0 +1,359 @@ +# 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 + + # Format module header + # + # Currently, this option is not configurable and will format all exports and + # module declarations to minimize diffs + # + # - module_header: + # # How many spaces use for indentation in the module header. + # indent: 4 + # + # # Should export lists be sorted? Sorting is only performed within the + # # export section, as delineated by Haddock comments. + # sort: true + # + # # See `separate_lists` for the `imports` step. + # separate_lists: true + + # Format record definitions. This is disabled by default. + # + # You can control the layout of record fields. The only rules that can't be configured + # are these: + # + # - "|" is always aligned with "=" + # - "," in fields is always aligned with "{" + # - "}" is likewise always aligned with "{" + # + # - records: + # # How to format equals sign between type constructor and data constructor. + # # Possible values: + # # - "same_line" -- leave "=" AND data constructor on the same line as the type constructor. + # # - "indent N" -- insert a new line and N spaces from the beginning of the next line. + # equals: "indent 2" + # + # # How to format first field of each record constructor. + # # Possible values: + # # - "same_line" -- "{" and first field goes on the same line as the data constructor. + # # - "indent N" -- insert a new line and N spaces from the beginning of the data constructor + # first_field: "indent 2" + # + # # How many spaces to insert between the column with "," and the beginning of the comment in the next line. + # field_comment: 2 + # + # # How many spaces to insert before "deriving" clause. Deriving clauses are always on separate lines. + # deriving: 2 + # + # # How many spaces to insert before "via" clause counted from indentation of deriving clause + # # Possible values: + # # - "same_line" -- "via" part goes on the same line as "deriving" keyword. + # # - "indent N" -- insert a new line and N spaces from the beginning of "deriving" keyword. + # via: "indent 2" + # + # # Sort typeclass names in the "deriving" list alphabetically. + # sort_deriving: true + # + # # Wheter or not to break enums onto several lines + # # + # # Default: false + # break_enums: false + # + # # Whether or not to break single constructor data types before `=` sign + # # + # # Default: true + # break_single_constructors: true + # + # # Whether or not to curry constraints on function. + # # + # # E.g: @allValues :: Enum a => Bounded a => Proxy a -> [a]@ + # # + # # Instead of @allValues :: (Enum a, Bounded a) => Proxy a -> [a]@ + # # + # # Default: false + # curried_context: false + + # Align the right hand side of some elements. This is quite conservative + # and only applies to statements where each element occupies a single + # line. + # Possible values: + # - always - Always align statements. + # - adjacent - Align statements that are on adjacent lines in groups. + # - never - Never align statements. + # All default to always. + - simple_align: + cases: always + top_level_patterns: always + records: always + multi_way_if: always + + # 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: global + + # The following 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) + # + # - with_module_name: Import list is aligned `list_padding` spaces after + # the module name. + # + # > import qualified Data.List as List (concat, foldl, foldr, head, + # init, last, length) + # + # This is mainly intended for use with `pad_module_names: false`. + # + # > import qualified Data.List as List (concat, foldl, foldr, head, + # init, last, length, scanl, scanr, take, drop, + # sort, nub) + # + # - new_line: Import list starts always on new line. + # + # > import qualified Data.List as List + # > (concat, foldl, foldr, head, init, last, length) + # + # - repeat: Repeat the module name to align the import list. + # + # > import qualified Data.List as List (concat, foldl, foldr, head) + # > import qualified Data.List as List (init, last, length) + # + # Default: after_alias + list_align: after_alias + + # Right-pad the module names to align imports in a group: + # + # - true: a little more readable + # + # > import qualified Data.List as List (concat, foldl, foldr, + # > init, last, length) + # > import qualified Data.List.Extra as List (concat, foldl, foldr, + # > init, last, length) + # + # - false: diff-safe + # + # > import qualified Data.List as List (concat, foldl, foldr, init, + # > last, length) + # > import qualified Data.List.Extra as List (concat, foldl, foldr, + # > init, last, length) + # + # Default: true + pad_module_names: true + + # 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 constructor list acts like single import. + # + # > import qualified Data.Map as M + # > ( empty + # > , singleton + # > , ... + # > , delete + # > ) + # + # Default: inline + long_list_align: inline + + # Align empty list (importing instances) + # + # Empty list align has following options + # + # - inherit: inherit list_align setting + # + # - right_after: () is right after the module name: + # + # > import Vector.Instances () + # + # Default: inherit + empty_list_align: inherit + + # List padding determines indentation of import list on lines after import. + # This option affects 'long_list_align'. + # + # - : constant value + # + # - module_name: align under start of module name. + # Useful for 'file' and 'group' align settings. + # + # Default: 4 + list_padding: 4 + + # Separate lists option affects formatting 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 + + # Space surround option affects formatting of import lists on a single + # line. The only difference is single space after the initial + # parenthesis and a single space before the terminal parenthesis. + # + # - true: There is single space associated with the enclosing + # parenthesis. + # + # > import Data.Foo ( foo ) + # + # - false: There is no space associated with the enclosing parenthesis + # + # > import Data.Foo (foo) + # + # Default: false + space_surround: false + + # Enabling this argument will use the new GHC lib parse to format imports. + # + # This currently assumes a few things, it will assume that you want post + # qualified imports. It is also not as feature complete as the old + # imports formatting. + # + # It does not remove redundant lines or merge lines. As such, the full + # feature scope is still pending. + # + # It _is_ however, a fine alternative if you are using features that are + # not parseable by haskell src extensions and you're comfortable with the + # presets. + # + # Default: false + ghc_lib_parser: false + + # 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 column. + # + # - 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 + + # Language prefix to be used for pragma declaration, this allows you to + # use other options non case-sensitive like "language" or "Language". + # If a non correct String is provided, it will default to: LANGUAGE. + language_prefix: LANGUAGE + + # 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: {} + + # Squash multiple spaces between the left and right hand sides of some + # elements into single spaces. Basically, this undoes the effect of + # simple_align but is a bit less conservative. + # - squash: {} + +# A common setting is the number of columns (parts of) code will be wrapped +# to. Different steps take this into account. +# +# Set this to null to disable all line wrapping. +# +# Default: 80. +#columns: 80 +columns: 160 + +# By default, line endings are converted according to the OS. You can override +# preferred format here. +# +# - native: Native newline format. CRLF on Windows, LF on other OSes. +# +# - lf: Convert to LF ("\n"). +# +# - crlf: Convert to CRLF ("\r\n"). +# +# Default: native. +#newline: native +newline: lf + +# 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 + +# Attempt to find the cabal file in ancestors of the current directory, and +# parse options (currently only language extensions) from that. +# +# Default: true +cabal: true diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 0000000..6a21913 --- /dev/null +++ b/.travis.yml @@ -0,0 +1 @@ +language: haskell \ No newline at end of file diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..b32d02c --- /dev/null +++ b/Makefile @@ -0,0 +1,84 @@ +.PHONY: all bench build check check-whitespace clean configure exec fast golden haddock hlint hpack install main output repl report run sdist stan stylish test tix update + +all: update fast bench + +bench: + rm -f heltc-benchmark.tix + cabal new-bench --jobs -f ghcoptions + +build: + cabal new-build --jobs --enable-profiling -f ghcoptions + +check: + cabal check + +check-whitespace: + git check-whitespace + +clean: + cabal new-clean + if test -d .cabal-sandbox; then cabal sandbox delete; fi + if test -d .hpc; then rm -r .hpc; fi + if test -d .hie; then rm -r .hie; fi + +configure: + rm -f cabal.project.local* + cabal configure --enable-benchmarks --enable-coverage --enable-tests -f ghcoptions + +exec: + make tix + cabal new-exec --jobs heltc + +fast: main report sdist install + +golden: + if test -d .output/golden; then rm -r .output/golden; fi + +haddock: + cabal new-haddock + +hlint: + ./hlint.sh + +hpack: + curl -sSL https://github.com/sol/hpack/raw/main/get-hpack.sh | bash + +install: + cabal install all --overwrite-policy=always + +main: + make stylish configure check build test + +output: + if test -d .output; then rm -r .output; fi + +repl: + cabal new-repl lib:heltc + +report: + make haddock stan hlint + ./report.sh + +run: + make tix + cabal new-run --jobs heltc + +sdist: + cabal sdist + +stan: + ./stan.sh + mv stan.html docs/reports + +stylish: + #curl -sL https://raw.github.com/haskell/stylish-haskell/master/scripts/latest.sh | sh -s "-r -v -i hs" + stylish-haskell -r -v -i hs + +test: + cabal new-test --jobs --test-show-details=streaming -f ghcoptions + +tix: + rm -f heltc.tix + +update: + cabal update diff --git a/README.md b/README.md deleted file mode 100644 index c4a8448..0000000 --- a/README.md +++ /dev/null @@ -1,2 +0,0 @@ -# heltc -Haskellish Esoteric Lambda T Calculator diff --git a/Setup.hs b/Setup.hs new file mode 100644 index 0000000..9a994af --- /dev/null +++ b/Setup.hs @@ -0,0 +1,2 @@ +import Distribution.Simple +main = defaultMain diff --git a/cabal.project b/cabal.project new file mode 100644 index 0000000..3894ea5 --- /dev/null +++ b/cabal.project @@ -0,0 +1,7 @@ +packages: *.cabal + +source-repository-package + type: git + location: https://github.com/helvm/helio.git + branch: master + tag: 0.1.1.6 diff --git a/docs/Gemfile b/docs/Gemfile new file mode 100644 index 0000000..5c41b36 --- /dev/null +++ b/docs/Gemfile @@ -0,0 +1,17 @@ +source "https://rubygems.org" + +gem "github-pages", group: :jekyll_plugins + +gem "tzinfo-data" +gem "wdm", "~> 0.1.0" if Gem.win_platform? + +# If you have any plugins, put them here! +group :jekyll_plugins do + gem "jekyll-paginate" + gem "jekyll-sitemap" + gem "jekyll-gist" + gem "jekyll-feed" + gem "jemoji" + gem "jekyll-include-cache" + gem "jekyll-algolia" +end diff --git a/docs/README.md b/docs/README.md new file mode 100644 index 0000000..5464693 --- /dev/null +++ b/docs/README.md @@ -0,0 +1,27 @@ +# 🎓 🏫 HelTC - Haskellish Esoteric Lambda True Calculator to Esoteric Languages implemented in Haskell + +**🎓 🏫 HelTC** is part of [HelVM](http://helvm.github.io/) project and it is implementation of: + +## For Users +* [INSTALL](users/INSTALL.md) - How to download and run +* [AUTHORS](users/AUTHORS.md) - List of authors +* [THANKS](users/THANKS.md) - Thanks for inspiration +* [TODO](users/TODO.md) - Features and to do for all projects +* [NEWS](users/NEWS.md) - New features +* [FAQ](users/FAQ.md) - Frequently Asked Questions & Frequently Given Answers + +## For Developers +* [BUGS](developers/BUGS.md) - Know bugs to fix +* [ROADMAP](developers/ROADMAP.md) - Long versions of [TODO](users/TODO.md) +* [CHANGELOG](developers/CHANGELOG.md) - Long versions of [NEWS](users/NEWS.md) +* [ARCHITECTURE](developers/ARCHITECTURE.md) - List of libraries +* [CONTRIBUTING](developers/CONTRIBUTING.md) +* [CODE OF CONDUCT](developers/CODE_OF_CONDUCT.md) + +## Reports +* [hadock](reports/helct/index.html) - A documentation +* [hpc](reports/helct-test/hpc_index.html) - Haskell program coverage report +* [stan](reports/stan.html) - Haskell STatic ANalyser report +* [hlint](reports/hlint.html) - Source code suggestions report + +## 🦄 🌈 ❤️ 💛 💚 💙 🤍 🖤 diff --git a/docs/_config.yml b/docs/_config.yml new file mode 100644 index 0000000..5c65b09 --- /dev/null +++ b/docs/_config.yml @@ -0,0 +1,147 @@ +# Jekyll: https://jekyllrb.com/docs/configuration/ + +## Default Configuration: https://jekyllrb.com/docs/configuration/default/ + +future : true + +### Conversion +markdown : kramdown +#markdown : CommonMarkGhPages +highlighter : rouge + +### Outputting +permalink : /:categories/:title +paginate_path : /:num +timezone : "Europe/Warsaw" # https://en.wikipedia.org/wiki/List_of_tz_database_time_zones + +### Where things are +include: + - CONTRIBUTING.md + - CODE_OF_CONDUCT.md + +sass: + # sass_dir: ui/_scss + style: compressed + +## Collections: https://jekyllrb.com/docs/collections/ + +## Front Matter Defaults: https://jekyllrb.com/docs/configuration/front-matter-defaults/ + +# Plugins +plugins: + - jemoji + - jekyll-avatar + - jekyll-coffeescript + - jekyll-commonmark-ghpages + - jekyll-default-layout + - jekyll-feed + - jekyll-gist + - jekyll-github-metadata + - jekyll-include-cache + - jekyll-mentions + - jekyll-optional-front-matter + - jekyll-paginate + - jekyll-readme-index + - jekyll-redirect-from + - jekyll-relative-links + - jekyll-remote-theme + - jekyll-sass-converter + - jekyll-seo-tag + - jekyll-sitemap + - jekyll-titles-from-headings + +## jekyll-commonmark-ghpages +commonmark: + options : ["SMART", "FOOTNOTES"] + extensions : ["strikethrough", "autolink", "table", "tagfilter"] + +## jekyll-mentions +jekyll-mentions: + base_url : "https://twitter.com" + +## jekyll-paginate +paginate : 1 + +## jekyll-remote-theme +remote_theme : helvm/minima + +## jekyll-seo-tag +title : "Heavenly Esoteric Lambda T Calculator" +tagline : "Heavenly Esoteric Lambda True Calculator" +description: >- + Documentation of Heavenly Esoteric Little C Transpiler to Esoteric Languages implemented in Haskell/Eta +url : "https://helvm.github.io/heltc/" +author: + name : "Kamil Adam" + email : "kamil.adam.zabinski@gmail.com" + twitter : "TheKamilAdam" + avatar : "/assets/images/kamil.adam.jpg" + bio : "My awesome biography constrained to a sentence or two goes here." +twitter: + username : "TheKamilAdam" +facebook: +logo : "/assets/favicon.ico" +social: + name : "Kamil Adam" + links: + - https://twitter.com/TheKamilAdam + - https://github.com/helvm + - https://www.linkedin.com/company/writeonly-pl + - https://www.facebook.com/WriteOnlyPL + - https://www.instagram.com/degustujacaistota/ + +# jekyll-titles-from-headings +titles_from_headings: +# enabled: false +# strip_title: false +# collections: false + +# External systems + +## Compress HTML +compress_html: + clippings : all + comments : all + endings : all + profile : false + startings : [head, body] + +# minima +show_excerpts : false +google_analytics : UA-136426906-3 + +headings_form_titles: + enabled : false + +edit: + enabled : true + url : https://github.com/helvm/heltc/edit/master/docs + extention : md + +header_pages: + - users/INSTALL.md + - users/AUTHORS.md + - users/THANKS.md + - users/TODO.md + - users/NEWS.md + - users/FAQ.md + +minima: +# skin: solarized-dark + skin: dark +# date_format: "%b %-d, %Y" + social_links: + rss : rss + github : helvm + linkedin : writeonly-pl + facebook : WriteOnlyPL + instagram : degustujacaistota + twitter : TheKamilAdam + devto : KamilAdam +# dribbble: jekyll +# flickr: jekyll +# pinterest: jekyll +# telegram: jekyll +# googleplus: +jekyll +# microdotblog: jekyll +# keybase: jekyll diff --git a/docs/assets/android-chrome-192x192.png b/docs/assets/android-chrome-192x192.png new file mode 100644 index 0000000000000000000000000000000000000000..c194cbcfad75249daa9cf86b6af572b18cf7df49 GIT binary patch literal 7701 zcmd5>=OY|px1S|Q)QB2{5YbEY<pH-g`v!ULs1c8xe`SUN*=Q z#Ogin=DqL#aPNni`EX`V`JFT8d7kt8sHdY&LCQo5006~PjmHM~C+gpIlNf(DSa2r+ zfO`v1A1fOL+U#WCYEK(K?(1kNdCcCeCTimNke2BskLr8T$9L}(2I+CWQ|b9wFo3=v znPO07&Y|k?tjG;%)h)5Wtbe!b`ao_Z=-LJws;e*(d>pj=_2AFZS(Yw#eAaEZaeAo( zJ3C_GR^7-t>a6fw3`Sfd<$a?@sfJ(gUI}?gEO#|@e+uoB5=t`ieA627P~ZX%E#Vx_7Wf1yhD1Shy8(7`VB(k6N?sCoXyJZN zJX@z5ssfs$xkUZ|GT=to`30y^tYOx>(IEP1^)7;VzZgma4MUNjc4xnt(Et_%s*rOC zYGuIfz6%q&D4ec^AW)nX&;j)lSU&XVwXvy&3NW1#Z;%cPTs4n*0ScQAvl*oBJI0$5 zdQfqk1RDA6#o={d?if%)@r;nk2=?)!G?1b|94CsV3=}?M+XT?Newxp+{|@g;X{${@ zzFvwZeoe2VECdonU+GkQs6Y1GXW}V@9vE8x;*TrH~<#{gGsD_^w2}Q z+`FKa6R@%yiVz0-ysW!Kh}wm|oq~{nm4!QU+DRbGghZ7fD#%-#Fr^?Wpo4_ef{+y; zLR^OJvjSmMv<<}a0BP{q)tUlu$;#tQ5eU#8?q3Xq0H+FiXuKt!jrEh{lm8=wx5)tJ z3Mym1tF!tZ$C~LX+zHd8-!^7P2d$;^M^h28l9z^mwD~%Z=fM#QE47g|hoMrwT2hu? zn4)T{qq-Ll-yB$<#Wi7;Vf(#$g`yfKmL?Iwub$6R;ZWnaq3U(Hu;ATX5KP;!l5b*x zIAB5Ypm=K8ZeCD1`2yPk3u}8t0))>4O_iWV&9y4{PELoLP?EJD&Ao9N*3i!H1S~lvo=hA8W163~naNj9M{!T~e9 z=3>G275QD;7XG_%^?ACq)VZ^|)Vr%taL`?FcPTsI94Gi--JOFUT*FF2r=F zN#?vP?Q~b6cYjbo7(e#I61o|YDz`G8xfM(G^CO|lQGA{wxQ-yR9`K7-3b_Ps;)n1An2HC_+zWp3S9vF5Z2%zTK<}Wm` z3tq3yeB=M=(pr?n{ox)}cbg~p1DE`#E8&*+df@4UsK^j80PW0{ZcO_IZL!%&=G(L&o#zdsMq_eau3^&&Nw z*y&xzjJ?f&aD!|4$K40lZS@>flkW0FR_ zSB*m0=zov{+l^X~ml^Vv;sIR#%#Q0#2d_LSR_)t^kf+2yP7VPIXE= z8;anG9B+hu;;QPHgkts%(+Wm@`y9-W8i%IjO6px=Zc7 zCGcP0+7;v_SOd=63fmy+akMfR=kT!cW4*$c%BTcZka@#gAvPiufG8oBXcacC6 zxKU73c|E6deBF#M(4NM9?hPNrcM>}`I#B?YKO)u)g*-0=HACE6;YG<*QRY%J>Y-SB z=h1tAuTl~5{y(yt$yn@smWn(%Z%q%GM?C-CjhRdHY#a~3)pkPDeq;MmJLj=NtEZBs z^#J(S2$l;~C1=+5?yJ<=Ujc5Hco|yOIG@8Y^%Wn)%0cyxpDxxYCUL2#?OR~F{1xe& zlL+RZsi{v(3)P6WCX?Cgs?dXVdr2D~L0eFE6_NREzo+;=f@#tY!-+nd)MT(Cd@cVR zpOAr13SL>+*XzxM*FB$?=kPT=k$nA8M6WFk(NV;JGEo1z+4wZK825X5YKre-nJ&C> z+l9Hh1$jaJqm9XNr1``SgHKK#hiw+YIb)MS+YsiD`oHX`9!FrgXU=TRNGmV8O|Sn` zg58q1jgtF}BPw;V3?W5Ib>7%Cb!cMwi^rovmXuCZZ^Pw3Tf)Tv7?^9eYU|HShPAaY zWvka!n-GPS^|tMNKGMSmt(7f@e+AgQ%!e!GL7`Qu6vpZAcJ1?QpEWZmUt4JCw1^2u z^f8#X?8x5*^yII%P9W{+CSy@AtGGGLPnINZD%2#sMg3r8l>TOw(7x&C`Ht|U;i&0S zT^gP1G{>bDSe0V~i5OU0FEa;RJwhPH`ov4r}^yDKvi@^uW&h zIR#!V)!AQ7PaQlMQN2*cb?i=0i7qT3+3}Pc<%f1R3NH>e{;yJpgB_iY>c1q#hf!D? zDy6TV(#(aw_2;tpy-#JzBC2k;$ERX*=6FuLq@lJlUS2m{w#js;WTh@rCNkyUbqps+4fTdFoz-jCIv zg+MmA1y)(sjZjsd;w1~cBogmHXFJVtsM4~Yf!3&M(AZ_v9>VV9D7o8RLwR%1{rMvd zMTK>jPUS+7VZKJ~MO=-u=!P#c@+G_#CwppF7%7*m{uxnhO(@7Tdmge&BVES)=A4Z= zyb8XQ0eTg?9OtXpw4E68$NJGDnwG6r+IqL!1wp%*IwtdYpxN;Ow>J7 zRH^#hx#b~ofAK!sf4%w@ALZDaU$268P#Bh&sV4xl_mB!Up>;dJ>x_NeL+QM%9&aL5 z%vRGqkt9OMyJ0>lsn5sxI`?c)Z7wud88x&ZJ4%1t2Nd^E}p;>B7fxaSHJ{fX- zS=!M!t5%wdwodvn2_tLu$;JsQ0}~*o{bump>fX>}x(RWiz=e;yHLtugwOQ@Rtfi={ z7^ynsG&c%slJu`~S3lCbtYEO13VtwEDyLpne*GP47Br>FFX?PY6M%dR^f}Ak5T0OF z+!!k*G#&7;R?38XX|lP~n3BePfL*Gt`pTm$u#D2Q&2PA8a(C`@l_fhh+OebQ&l1ut zS>ouV0%$3tv6|&|X9)M;R)2yBkX&l9>Zz4_u!2J5og7}UJ#uETk`s~jGG}4-x~Yc9 zz1VD0+zlb1wWu;X<3zV;VN_N}%?J8v&%U?~l0rb(F7zKseR?D)>YIj+1GB`60i|Zo z63dGZ2z`SJtv(cm;ZF^msSOc5pSBj8{TGeJxZkq0Vd86>K2o1>3X2mA!OYmQ+aDrg zi{o&29Giwo0l}Hr-ft!cHg6xaeWM=u!OVU9_j%#<@}gsdi&5+WlBJY2 zWj{oNA*8i;??g3+`u@1@9cMI=_baE&g7|izuUEs>k-0I(3?}_ir&tN(A>0^E6ECc@ z9oyc4h+a9K-FvBlof=;+`vHr!W2d{TADm%DA5+tx@e_W^!no8u)m?FhF6xMtqBNb7 z0%sj^B>(CP3hF22e#mpvbMU$JpPCIm{f#Flm`7)w8|`jCTiWdtswaF6UAtKH262;d z!*zx06No6U&(LzK2E<&KhP@-wB_4dizwle}nU^^TeeT_|oNn{j_CObVYNG3!$Lw)K zot0&RdUJ{`;zv$hs)9wYgYkkKB5QOfxwTB-c(M^ z#Q-V9o+>ixMFGPtrOVcFgUp>v_D8Evn?%Q<4_N4ri;SW9n?$gpzR(%HN} zOw;^W0{-?7U~w5(tt4~SGdnswE0UOwR#p}-D0x`^harxToutIgyOGGrZWe{5Mca@f?eZ``s zJC};9q6yz)ChZi5eA1R`2tJ$26|PIy3b!9N%~R_rF?qI;`^&job1X`kD2RW4_!R%) z#K{LY8h^%6Cn9jHEAD&yqiwokZ6Av`o0>I+WQ) z*MYO2$Z+tWA{)Px31C!7t|afaBbxC>b10Xb+)GC1afk{{`Wp#%WL)agq&`bW+s_5x zUhtntr z7*U+ApW%zTo@C{-ggk?8KfAq5efZC2VH!Y|V3Ws)r=WpF`v*xVSqo<>6~c?rovv2z zs|u`uFffHEMMqu2yy!!QtNxvR{1mF%>}2sOQ0(+++C4O zwtstOr(uKb1>X79nk&0sM>XH+G4!01W$hIPqXi$PWOZKDE$RlC=Ey`(I1qpx(Iq`~ zbd4=J30e6`inCm4cg9_io zYj*cr4G7*TirZXXCCEu+TvrIj2X&&OWLw3^c(cJ03+^- zutgqgqD{GIt@AZ%z+|KxX?g6jCB$o@>BlEgsGa+rIx>1Z@-@l&&{NXQ{tD4Xf>5J5 z+{yy>Mp6tOlu3HyS0bbXzWTe*^wO%|BpMv>DkqDIsk09V%v#%mml0g@B9yKk%xYgy zOod;1s^yNKsV8$-xZOMWwRAI@D^4?0611q_FOhl+a4`1_28;U~Qdg`!i544R*p!^N zR?TA=;Hh3nsf*e0)t{hJjpQ$Xsi)|^I@O3T5R&K>7$X0q##-z3QAU1@4HrPae2e6+ zXobW!@abM}x_U;;+}8+C9k@S;E@b|k0 zEjzR6^<*E(evx~;=-sk9z+}m{}ydqV1*0>_0RoP=C<__AGoBx$N?w#AnES+p_w72~rYohN4tf)PYKqhE{5>e{Kn!?XCV{+LDPP z)gsA^bN7aVKMOex_6hdWP$C_$Z}E3N@S*R_8f;ikQDc)NHR~w)AV1#5#+-ewk^J{N zwb(@A_;1Fejdx;I*)FSf$OQQHOQ&x#u0PVUp4r3q2-Eo`QO8I|KQ{jk#ciDD{N~@c zznKo@_=7u!(z<0#-_}{Sai*#pWN@ZxMXQvDM?mv2@7wac*PA`EDsF#{B}y$B{I@o^ zBFcW1NBTQXJ{cq_+qinp3Dq_L4g9d0FoRx zOw5R3rR#H_#Px@KbfzEf-a3EpqqbFTYQX+W-ZDN(&DbsM?__U|n~*WRF_$~p;x%oS zZ*8O)t1f;MY?8WfZlQr`3(0oHtH~$0YZwI)6?yzH)Spjj{X?m~%#f$86=yX`zm#3B z94q9jS`8n&L|4@gDPin$(|&cW2Y~{u+IugFAZ1_r(>!xWkng|rSxB!QZ2W|`SM4L8 z6z=mRTe#%k7i(xAr#C1Pr`zdQPp?s1vOJ&H>Qd~uK`EAAE$CZx@RA61q_C4pvEEfZ zC0=DF8P+pj^33&tYKBoP&!^28Fl9MbFo>ca|jIsKA8L^LR^yy*+ zsnKLd=8fym=gp^HnKvjk)FeObHkrdX;@mTvj?_2)iBf((Q@5#}SbScU&Y>e5$5`Xp(5p4^y zgJm1=!KL4}>vs((oD0)NEhUZ~3x~B9f8BS{4Vkp(w@%TkHD0WWlGCD79zG}5qmM9& z^`N0PMS7lmdpg7pr+b}$%IqP}KwIoy{%KDzRKEEJ6Z6PVVQnaJh{Y4ZaMn~*QpPKt zQpRR{cSt0JH&z-I$6mCYKdR$lF)hr_YH?brMT^{ov_$N z)B}I8_2P{dn~%yJtj40T5(b>Z)~arHShluhMICJaDd6 z!3w`6N~a6S42&wr-fi1!(ER+TA(${O+Ya+CbwqjngK~INVxHgTVEJ*O=ifp@V&HJH zf_7T-l}91Xc~=Bk1%C2y<=XA`dcMm?qAW`!_-d*XWBDQd-0euY7UK-HMcQ=dgu&`xQc(gjU$=Noa?GyrR^tcL;B1O+?qOTy$#Gb zNd*QP9losEw5EdJBVJ@uw_^6fPIVrs@*@s}okuBBK93Xaz{LczSrI1CPql)fJf%L1 zlJq)y_ue^8V}|5NeePzh2WIUN>q$zl*MGh>qWNGKs`%g^rhlCxex_G&YAO3gIV7c6 znLT}#b8>J zjMaG8h>YQ!329Pp9z&#F#01h)oO6Hq=gF zGm@+DqJnDJXQebeE#x@XW)9LdB6R zf4qn@6i-*wim!lfYlVK5*~E)9&heCmy$jxI+PS>n7@i49IHWt=?;FEg6*vm|_5a!- z(8}wnMS|s8E^G#Zcq$L7^pE$U`w#InfzkwlC8+HuB89}jwLIYl%X40#2dzAQ-gJGtipT9YmfC&Oc+LHOoNjoa5Uc3kMQRVBeKAo zGyDVf`*k7z-n2ydptyN~jb%URM|L^=P_~EDXbJ7}PA|ptS0mgNO zdBuHYF9|@u&`t>>EST^keMCId>V35CWb+?_k0RYXSjPbb-iafqBK%GGHxov%^Pb>K z^pDGG0zxQv-S-e}09~|9!9!p{moRo|#2-h@dgC0#R=^fAR@}@56ohm4Kj!O$c5$`W zSNwEOh?b_2fh!95Y}04TPKysb0yIMTx6NK~cupj k1a*f3RP}p?t!GLxhJAbU3!|!dx)*q=rt`Q;<@wwH0U^HQfB*mh literal 0 HcmV?d00001 diff --git a/docs/assets/android-chrome-512x512.png b/docs/assets/android-chrome-512x512.png new file mode 100644 index 0000000000000000000000000000000000000000..aa2186d0c7062fb7f3a7a07b78a7977e2ae590e0 GIT binary patch literal 22148 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 literal 0 HcmV?d00001 diff --git a/docs/assets/apple-touch-icon.png b/docs/assets/apple-touch-icon.png new file mode 100644 index 0000000000000000000000000000000000000000..db216026abfa2ac0a8c1c60e6f24aeea4d249255 GIT binary patch literal 7088 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 literal 0 HcmV?d00001 diff --git a/docs/assets/favicon-16x16.png b/docs/assets/favicon-16x16.png new file mode 100644 index 0000000000000000000000000000000000000000..30bc500f08666b43e6a5403eb0f5b5ebda2248ba GIT binary patch literal 455 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 or the MIT license , at your option. This file may not be +copied, modified, or distributed except according to those terms. diff --git a/docs/license/LICENSE-APACHE b/docs/license/LICENSE-APACHE new file mode 100644 index 0000000..1959295 --- /dev/null +++ b/docs/license/LICENSE-APACHE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2020-2022 WriteOnly Developers + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/LICENSE b/docs/license/LICENSE-MIT similarity index 95% rename from LICENSE rename to docs/license/LICENSE-MIT index eda2e5f..21a6b31 100644 --- a/LICENSE +++ b/docs/license/LICENSE-MIT @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2022 HelVM +Copyright (c) 2020-2022 WriteOnly Developers Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/docs/reports/heltc-test/hpc_index.html b/docs/reports/heltc-test/hpc_index.html new file mode 100644 index 0000000..7fd2e9c --- /dev/null +++ b/docs/reports/heltc-test/hpc_index.html @@ -0,0 +1,12 @@ + + + + + +
moduleTop Level DefinitionsAlternativesExpressions
%covered / total%covered / total%covered / total
  Program Coverage Total- 0/0 - 0/0 - 0/0 
diff --git a/docs/reports/heltc-test/hpc_index_alt.html b/docs/reports/heltc-test/hpc_index_alt.html new file mode 100644 index 0000000..7fd2e9c --- /dev/null +++ b/docs/reports/heltc-test/hpc_index_alt.html @@ -0,0 +1,12 @@ + + + + + +
moduleTop Level DefinitionsAlternativesExpressions
%covered / total%covered / total%covered / total
  Program Coverage Total- 0/0 - 0/0 - 0/0 
diff --git a/docs/reports/heltc-test/hpc_index_exp.html b/docs/reports/heltc-test/hpc_index_exp.html new file mode 100644 index 0000000..7fd2e9c --- /dev/null +++ b/docs/reports/heltc-test/hpc_index_exp.html @@ -0,0 +1,12 @@ + + + + + +
moduleTop Level DefinitionsAlternativesExpressions
%covered / total%covered / total%covered / total
  Program Coverage Total- 0/0 - 0/0 - 0/0 
diff --git a/docs/reports/heltc-test/hpc_index_fun.html b/docs/reports/heltc-test/hpc_index_fun.html new file mode 100644 index 0000000..7fd2e9c --- /dev/null +++ b/docs/reports/heltc-test/hpc_index_fun.html @@ -0,0 +1,12 @@ + + + + + +
moduleTop Level DefinitionsAlternativesExpressions
%covered / total%covered / total%covered / total
  Program Coverage Total- 0/0 - 0/0 - 0/0 
diff --git a/docs/reports/heltc/HelVM-HelTC-HelTC.html b/docs/reports/heltc/HelVM-HelTC-HelTC.html new file mode 100644 index 0000000..8853390 --- /dev/null +++ b/docs/reports/heltc/HelVM-HelTC-HelTC.html @@ -0,0 +1 @@ +HelVM.HelTC.HelTC
heltc-0.1.0.0: HELCT - Heavenly Esoteric Little C Transpiler to Esoteric Languages
Safe HaskellNone
LanguageHaskell2010

HelVM.HelTC.HelTC

\ No newline at end of file diff --git a/docs/reports/heltc/doc-index.html b/docs/reports/heltc/doc-index.html new file mode 100644 index 0000000..4ee2867 --- /dev/null +++ b/docs/reports/heltc/doc-index.html @@ -0,0 +1 @@ +heltc-0.1.0.0: HELCT - Heavenly Esoteric Little C Transpiler to Esoteric Languages (Index)
heltc-0.1.0.0: HELCT - Heavenly Esoteric Little C Transpiler to Esoteric Languages
\ No newline at end of file diff --git a/docs/reports/heltc/haddock-bundle.min.js b/docs/reports/heltc/haddock-bundle.min.js new file mode 100644 index 0000000..45adda9 --- /dev/null +++ b/docs/reports/heltc/haddock-bundle.min.js @@ -0,0 +1,2 @@ +!function i(s,a,l){function c(t,e){if(!a[t]){if(!s[t]){var n="function"==typeof require&&require;if(!e&&n)return n(t,!0);if(u)return u(t,!0);var o=new Error("Cannot find module '"+t+"'");throw o.code="MODULE_NOT_FOUND",o}var r=a[t]={exports:{}};s[t][0].call(r.exports,function(e){return c(s[t][1][e]||e)},r,r.exports,i,s,a,l)}return a[t].exports}for(var u="function"==typeof require&&require,e=0;e element with id '"+e+"'");return t}function x(){return u.defaultInstanceState==i.Open}function w(e){for(var t=S(e.target.id),n=t.element.open,o=0,r=t.toggles;owindow.innerHeight?this.searchResults.scrollTop+=e.bottom-window.innerHeight+80:e.topn)return u(e,this.pattern,o);var r=this.options,i=r.location,s=r.distance,a=r.threshold,l=r.findAllMatches,c=r.minMatchCharLength;return d(e,this.pattern,this.patternAlphabet,{location:i,distance:s,threshold:a,findAllMatches:l,minMatchCharLength:c})}}]),y}();e.exports=r},function(e,t,n){"use strict";var u=n(0);e.exports=function(e,t){return function e(t,n,o){if(n){var r=n.indexOf("."),i=n,s=null;-1!==r&&(i=n.slice(0,r),s=n.slice(r+1));var a=t[i];if(null!=a)if(s||"string"!=typeof a&&"number"!=typeof a)if(u(a))for(var l=0,c=a.length;l 0 and <= 1");p=p.name}else a[p]={weight:1};this._analyze({key:p,value:this.options.getFn(u,p),record:u,index:l},{resultMap:o,results:r,tokenSearchers:e,fullSearcher:t})}return{weights:a,results:r}}},{key:"_analyze",value:function(e,t){var n=e.key,o=e.arrayIndex,r=void 0===o?-1:o,i=e.value,s=e.record,a=e.index,l=t.tokenSearchers,c=void 0===l?[]:l,u=t.fullSearcher,d=void 0===u?[]:u,h=t.resultMap,p=void 0===h?{}:h,f=t.results,v=void 0===f?[]:f;if(null!=i){var g=!1,m=-1,y=0;if("string"==typeof i){this._log("\nKey: "+(""===n?"-":n));var _=d.search(i);if(this._log('Full text: "'+i+'", score: '+_.score),this.options.tokenize){for(var b=i.split(this.options.tokenSeparator),k=[],S=0;S=c.length;if(this._log("\nCheck Matches: "+T),(g||_.isMatch)&&T){var N=p[a];N?N.output.push({key:n,arrayIndex:r,value:i,score:A,matchedIndices:_.matchedIndices}):(p[a]={item:s,output:[{key:n,arrayIndex:r,value:i,score:A,matchedIndices:_.matchedIndices}]},v.push(p[a]))}}else if(V(i))for(var P=0,j=i.length;PKPc>*x4UoILL5_ z;RwSqhLa5E7%nngVYtR{o#7_K1BQnTFB#r}bVowWU|NX;op)-}*G)HBdC(9O&% V$Vp6274%5W3G>whk|E9z5&$I2A>9A~ literal 0 HcmV?d00001 diff --git a/docs/reports/heltc/index.html b/docs/reports/heltc/index.html new file mode 100644 index 0000000..bc8dd92 --- /dev/null +++ b/docs/reports/heltc/index.html @@ -0,0 +1 @@ +heltc-0.1.0.0: HELCT - Heavenly Esoteric Little C Transpiler to Esoteric Languages
heltc-0.1.0.0: HELCT - Heavenly Esoteric Little C Transpiler to Esoteric Languages

heltc-0.1.0.0: HELCT - Heavenly Esoteric Little C Transpiler to Esoteric Languages

Please see the README on GitHub at https://github.com/helvm/heltc#readme

Modules

\ No newline at end of file diff --git a/docs/reports/heltc/linuwial.css b/docs/reports/heltc/linuwial.css new file mode 100644 index 0000000..cbb58a0 --- /dev/null +++ b/docs/reports/heltc/linuwial.css @@ -0,0 +1,877 @@ +/* @group Fundamentals */ + +* { margin: 0; padding: 0 } + +/* Is this portable? */ +html { + background-color: white; + width: 100%; + height: 100%; +} + +body { + background: #fefefe; + color: #111; + text-align: left; + min-height: 100vh; + position: relative; + -webkit-text-size-adjust: 100%; + -webkit-font-feature-settings: "kern" 1, "liga" 0; + -moz-font-feature-settings: "kern" 1, "liga" 0; + -o-font-feature-settings: "kern" 1, "liga" 0; + font-feature-settings: "kern" 1, "liga" 0; + letter-spacing: 0.0015rem; +} + +#content a { + overflow-wrap: break-word; +} + +p { + margin: 0.8em 0; +} + +ul, ol { + margin: 0.8em 0 0.8em 2em; +} + +dl { + margin: 0.8em 0; +} + +dt { + font-weight: bold; +} +dd { + margin-left: 2em; +} + +a { text-decoration: none; } +a[href]:link { color: #9E358F; } +a[href]:visited {color: #6F5F9C; } +a[href]:hover { text-decoration:underline; } + +a[href].def:link, a[href].def:visited { color: rgba(69, 59, 97, 0.8); } +a[href].def:hover { color: rgb(78, 98, 114); } + +/* @end */ + +/* @group Show and hide with JS */ + +body.js-enabled .hide-when-js-enabled { + display: none; +} + +/* @end */ + + +/* @group responsive */ + +#package-header .caption { + margin: 0px 1em 0 2em; +} + +@media only screen and (min-width: 1280px) { + #content { + width: 63vw; + max-width: 1450px; + } + + #table-of-contents { + position: fixed; + max-width: 10vw; + top: 10.2em; + left: 2em; + bottom: 1em; + overflow-y: auto; + } + + #synopsis { + display: block; + position: fixed; + float: left; + top: 5em; + bottom: 1em; + right: 0; + max-width: 65vw; + overflow-y: auto; + /* Ensure that synopsis covers everything (including MathJAX markup) */ + z-index: 1; + } + + #synopsis .show { + border: 1px solid #5E5184; + padding: 0.7em; + max-height: 65vh; + } + +} + +@media only screen and (max-width: 1279px) { + #content { + width: 80vw; + } + + #synopsis { + display: block; + padding: 0; + position: relative; + margin: 0; + width: 100%; + } +} + +@media only screen and (max-width: 999px) { + #content { + width: 93vw; + } +} + + +/* menu for wider screens + + Display the package name at the left and the menu links at the right, + inline with each other: + The package name Source . Contents . Index +*/ +@media only screen and (min-width: 1000px) { + #package-header { + text-align: left; + white-space: nowrap; + height: 40px; + padding: 4px 1.5em 0px 1.5em; + overflow: visible; + + display: flex; + justify-content: space-between; + align-items: center; + } + + #package-header .caption { + display: inline-block; + margin: 0; + } + + #package-header ul.links { + margin: 0; + display: inline-table; + } + + #package-header .caption + ul.links { + margin-left: 1em; + } +} + +/* menu for smaller screens + +Display the package name on top of the menu links and center both elements: + The package name + Source . Contents . Index +*/ +@media only screen and (max-width: 999px) { + #package-header { + text-align: center; + padding: 6px 0 4px 0; + overflow: hidden; + } + + #package-header ul.links { + display: block; + text-align: center; + margin: 0; + + /* Hide scrollbar but allow scrolling menu links horizontally */ + white-space: nowrap; + overflow-x: auto; + overflow-y: hidden; + margin-bottom: -17px; + height: 50px; + } + + #package-header .caption { + display: block; + margin: 4px 0; + text-align: center; + } + + #package-header ul.links::-webkit-scrollbar { + display: none; + } + + #package-header ul.links li:first-of-type { + padding-left: 1em; + } + + #package-header ul.links li:last-of-type { + /* + The last link of the menu should offer the same distance to the right + as the #package-header enforces at the left. + */ + padding-right: 1em; + } + + #package-header .caption + ul.links { + padding-top: 9px; + } + + #module-header table.info { + float: none; + top: 0; + margin: 0 auto; + overflow: hidden; + max-width: 80vw; + } +} + +/* @end */ + + +/* @group Fonts & Sizes */ + +/* Basic technique & IE workarounds from YUI 3 + For reasons, see: + http://yui.yahooapis.com/3.1.1/build/cssfonts/fonts.css + */ + + body, button { + font: 400 14px/1.4 'PT Sans', + /* Fallback Font Stack */ + -apple-system, + BlinkMacSystemFont, + 'Segoe UI', + Roboto, + Oxygen-Sans, + Cantarell, + 'Helvetica Neue', + sans-serif; + *font-size: medium; /* for IE */ + *font:x-small; /* for IE in quirks mode */ + } + +h1 { font-size: 146.5%; /* 19pt */ } +h2 { font-size: 131%; /* 17pt */ } +h3 { font-size: 116%; /* 15pt */ } +h4 { font-size: 100%; /* 13pt */ } +h5 { font-size: 100%; /* 13pt */ } + +table { + font-size:inherit; + font:100%; +} + +pre, code, kbd, samp, tt, .src { + font-family:monospace; +} + +.links, .link { + font-size: 85%; /* 11pt */ +} + +#module-header .caption { + font-size: 182%; /* 24pt */ +} + +#module-header .caption sup { + font-size: 80%; + font-weight: normal; +} + +#package-header #page-menu a:link, #package-header #page-menu a:visited { color: white; } + + +.info { + font-size: 90%; +} + + +/* @end */ + +/* @group Common */ + +.caption, h1, h2, h3, h4, h5, h6, summary { + font-weight: bold; + color: #5E5184; + margin: 1.5em 0 1em 0; +} + + +* + h1, * + h2, * + h3, * + h4, * + h5, * + h6 { + margin-top: 2em; +} + +h1 + h2, h2 + h3, h3 + h4, h4 + h5, h5 + h6 { + margin-top: inherit; +} + +ul li + li { + margin-top: 0.2rem; +} + +ul + p { + margin-top: 0.93em; +} + +p + ul { + margin-top: 0.5em; +} + +p { + margin-top: 0.7rem; +} + +ul, ol { + margin: 0.8em 0 0.8em 2em; +} + +ul.links { + list-style: none; + text-align: left; + font-size: 0.95em; +} + +#package-header ul.links, #package-header ul.links button { + font-size: 1rem; +} + +ul.links li { + display: inline; + white-space: nowrap; + padding: 0; +} + +ul.links > li + li:before { + content: '\00B7'; +} + +ul.links li a { + padding: 0.2em 0.5em; +} + +.hide { display: none; } +.show { display: inherit; } +.clear { clear: both; } + +.collapser:before, .expander:before, .noexpander:before { + font-size: 1.2em; + color: #9C5791; + display: inline-block; + padding-right: 7px; +} + +.collapser:before { + content: '▿'; +} +.expander:before { + content: '▹'; +} +.noexpander:before { + content: '▿'; + visibility: hidden; +} + +.collapser, .expander { + cursor: pointer; +} + +.instance.collapser, .instance.expander { + margin-left: 0px; + background-position: left center; + min-width: 9px; + min-height: 9px; +} + +summary { + cursor: pointer; + outline: none; +} + +pre { + padding: 0.5rem 1rem; + margin: 1em 0 0 0; + background-color: #f7f7f7; + overflow: auto; + border: 1px solid #ddd; + border-radius: 0.3em; +} + +pre + p { + margin-top: 1em; +} + +pre + pre { + margin-top: 0.5em; +} + +blockquote { + border-left: 3px solid #c7a5d3; + background-color: #eee4f1; + margin: 0.5em; + padding: 0.0005em 0.3em 0.5em 0.5em; +} + +.src { + background: #f2f2f2; + padding: 0.2em 0.5em; +} + +.keyword { font-weight: normal; } +.def { font-weight: bold; } + +@media print { + #footer { display: none; } +} + +/* @end */ + +/* @group Page Structure */ + +#content { + margin: 3em auto 6em auto; + padding: 0; +} + +#package-header { + background: #5E5184; + border-bottom: 5px solid rgba(69, 59, 97, 0.5); + color: #ddd; + position: relative; + font-size: 1.2em; + text-align: left; + margin: 0 auto; +} + +#package-header .caption { + color: white; + font-style: normal; + font-size: 1rem; + font-weight: bold; +} + +#module-header .caption { + font-weight: bold; + border-bottom: 1px solid #ddd; +} + +table.info { + float: right; + padding: 0.5em 1em; + border: 1px solid #ddd; + color: rgb(78,98,114); + background-color: #fff; + max-width: 60%; + border-spacing: 0; + position: relative; + top: -0.78em; + margin: 0 0 0 2em; +} + +.info th { + padding: 0 1em 0 0; + text-align: right; +} + +#style-menu li { + display: block; + border-style: none; + list-style-type: none; +} + +#footer { + background: #ededed; + border-top: 1px solid #aaa; + padding: 0.5em 0; + color: #222; + text-align: center; + width: 100%; + height: 3em; + margin-top: 3em; + position: relative; + clear: both; +} + +/* @end */ + +/* @group Front Matter */ + +#synopsis .caption, +#contents-list .caption { + font-size: 1rem; +} + +#synopsis, #table-of-contents { + font-size: 16px; +} + +#contents-list { + background: #f4f4f4; + padding: 1em; + margin: 0; +} + +#contents-list .caption { + text-align: left; + margin: 0; +} + +#contents-list ul { + list-style: none; + margin: 0; + margin-top: 10px; + font-size: 14px; +} + +#contents-list ul ul { + margin-left: 1.5em; +} + +#description .caption { + display: none; +} + +#synopsis summary { + display: block; + float: right; + width: 29px; + color: rgba(255,255,255,0); + height: 110px; + margin: 0; + font-size: 1px; + padding: 0; + background: url(synopsis.png) no-repeat 0px -8px; +} + +#synopsis details[open] > summary { + background: url(synopsis.png) no-repeat -75px -8px; +} + +#synopsis ul { + height: 100%; + overflow: auto; + padding: 0.5em; + margin: 0; +} + +#synopsis ul ul { + overflow: hidden; +} + +#synopsis ul, +#synopsis ul li.src { + background-color: rgb(250,247,224); + white-space: nowrap; + list-style: none; + margin-left: 0; +} + +#interface td.src { + white-space: nowrap; +} + +/* @end */ + +/* @group Main Content */ + +#interface div.top + div.top { + margin-top: 1.5em; +} + +#interface p + div.top, +#interface h1 + div.top, +#interface h2 + div.top, +#interface h3 + div.top, +#interface h4 + div.top, +#interface h5 + div.top { + margin-top: 1em; +} +#interface .src .selflink, +#interface .src .link { + float: right; + color: #888; + padding: 0 7px; + -moz-user-select: none; + font-weight: bold; + line-height: 30px; +} +#interface .src .selflink { + margin: 0 -0.5em 0 0.5em; +} + +#interface span.fixity { + color: #919191; + border-left: 1px solid #919191; + padding: 0.2em 0.5em 0.2em 0.5em; + margin: 0 -1em 0 1em; +} + +#interface span.rightedge { + border-left: 1px solid #919191; + padding: 0.2em 0 0.2em 0; + margin: 0 0 0 1em; +} + +#interface table { border-spacing: 2px; } +#interface td { + vertical-align: top; + padding-left: 0.5em; +} + +#interface td.doc p { + margin: 0; +} +#interface td.doc p + p { + margin-top: 0.8em; +} + +.doc table { + border-collapse: collapse; + border-spacing: 0px; +} + +.doc th, +.doc td { + padding: 5px; + border: 1px solid #ddd; +} + +.doc th { + background-color: #f0f0f0; +} + +.clearfix:after { + clear: both; + content: " "; + display: block; + height: 0; + visibility: hidden; +} + +.subs, .top > .doc, .subs > .doc { + padding-left: 1em; + border-left: 1px solid gainsboro; + margin-bottom: 1em; +} + +.top .subs { + margin-bottom: 0.6em; +} + +.subs.fields ul { + list-style: none; + display: table; + margin: 0; +} + +.subs.fields ul li { + display: table-row; +} + +.subs ul li dfn { + display: table-cell; + font-style: normal; + font-weight: bold; + margin: 1px 0; + white-space: nowrap; +} + +.subs ul li > .doc { + display: table-cell; + padding-left: 0.5em; + margin-bottom: 0.5em; +} + +.subs ul li > .doc p { + margin: 0; +} + +.subs .subs p.src { + border: none; + background-color: #f8f8f8; +} + +.subs .subs .caption { + margin-top: 1em ; + margin-bottom: 0px; +} + +.subs p.caption { + margin-top: 0; +} + +.subs .subs .caption + .src { + margin: 0px; + margin-top: 8px; +} + +.subs .subs .src + .src { + margin: 7px 0 0 0; +} + +/* Render short-style data instances */ +.inst ul { + height: 100%; + padding: 0.5em; + margin: 0; +} + +.inst, .inst li { + list-style: none; + margin-left: 1em; +} + +/* Workaround for bug in Firefox (issue #384) */ +.inst-left { + float: left; +} + +.top p.src { + border-bottom: 3px solid #e5e5e5; + line-height: 2rem; + margin-bottom: 1em; +} + +.warning { + color: red; +} + +.arguments { + margin-top: -0.4em; +} +.arguments .caption { + display: none; +} + +.fields { padding-left: 1em; } + +.fields .caption { display: none; } + +.fields p { margin: 0 0; } + +/* this seems bulky to me +.methods, .constructors { + background: #f8f8f8; + border: 1px solid #eee; +} +*/ + +/* @end */ + +/* @group Auxillary Pages */ + + +.extension-list { + list-style-type: none; + margin-left: 0; +} + +#mini { + margin: 0 auto; + padding: 0 1em 1em; +} + +#mini > * { + font-size: 93%; /* 12pt */ +} + +#mini #module-list .caption, +#mini #module-header .caption { + font-size: 125%; /* 15pt */ +} + +#mini #interface h1, +#mini #interface h2, +#mini #interface h3, +#mini #interface h4 { + font-size: 109%; /* 13pt */ + margin: 1em 0 0; +} + +#mini #interface .top, +#mini #interface .src { + margin: 0; +} + +#mini #module-list ul { + list-style: none; + margin: 0; +} + +#alphabet ul { + list-style: none; + padding: 0; + margin: 0.5em 0 0; + text-align: center; +} + +#alphabet li { + display: inline; + margin: 0 0.25em; +} + +#alphabet a { + font-weight: bold; +} + +#index .caption, +#module-list .caption { font-size: 131%; /* 17pt */ } + +#index table { + margin-left: 2em; +} + +#index .src { + font-weight: bold; +} +#index .alt { + font-size: 77%; /* 10pt */ + font-style: italic; + padding-left: 2em; +} + +#index td + td { + padding-left: 1em; +} + +#module-list ul { + list-style: none; + margin: 0 0 0 2em; +} + +#module-list li { + clear: right; +} + +#module-list span.collapser, +#module-list span.expander { + background-position: 0 0.3em; +} + +#module-list .package { + float: right; +} + +:target { + background: -webkit-linear-gradient(top, transparent 0%, transparent 65%, #fbf36d 60%, #fbf36d 100%); + background: -moz-linear-gradient(top, transparent 0%, transparent 65%, #fbf36d 60%, #fbf36d 100%); + background: -o-linear-gradient(top, transparent 0%, transparent 65%, #fbf36d 60%, #fbf36d 100%); + background: -ms-linear-gradient(top, transparent 0%, transparent 65%, #fbf36d 60%, #fbf36d 100%); + background: linear-gradient(to bottom, transparent 0%, transparent 65%, #fbf36d 60%, #fbf36d 100%); +} + +:target:hover { + background: -webkit-linear-gradient(top, transparent 0%, transparent 0%, #fbf36d 0%, #fbf36d 100%); + background: -moz-linear-gradient(top, transparent 0%, transparent 0%, #fbf36d 0%, #fbf36d 100%); + background: -o-linear-gradient(top, transparent 0%, transparent 0%, #fbf36d 0%, #fbf36d 100%); + background: -ms-linear-gradient(top, transparent 0%, transparent 0%, #fbf36d 0%, #fbf36d 100%); + background: linear-gradient(to bottom, transparent 0%, transparent 0%, #fbf36d 0%, #fbf36d 100%); +} + +/* @end */ + +/* @group Dropdown menus */ + +#preferences-menu, #style-menu { + width: 25em; + overflow-y: auto; +} + +/* @end */ diff --git a/docs/reports/heltc/meta.json b/docs/reports/heltc/meta.json new file mode 100644 index 0000000..6cb919c --- /dev/null +++ b/docs/reports/heltc/meta.json @@ -0,0 +1 @@ +{"haddock_version":"2.24.2"} \ No newline at end of file diff --git a/docs/reports/heltc/quick-jump.css b/docs/reports/heltc/quick-jump.css new file mode 100644 index 0000000..d656f51 --- /dev/null +++ b/docs/reports/heltc/quick-jump.css @@ -0,0 +1,222 @@ +/* @group Fundamentals */ + +.hidden { + display: none; +} + +/* @end */ + +/* @group Search box layout */ + +#search { + position: fixed; + top: 3.2em; + bottom: 0; + left: calc(50% - 22em); + width: 44em; + z-index: 1000; + pointer-events: none; + overflow-y: auto; +} + +@media only screen and (max-width: 999px) { + #search { + top: 5.7em; + } +} + +#search-form, #search-results { + box-shadow: 2px 2px 6px rgb(199, 204, 208); + pointer-events: all; +} + +#search-form input { + font-size: 1.25em; line-height: 2.3em; height: 2.4em; + display: block; + box-sizing: border-box; + width: 100%; + margin: 0; + padding: 0 0.75em; + border: 0.05em solid rgb(151, 179, 202); +} + +#search input:focus { + outline: none; +} + +#search p.error { + color: rgb(107, 24, 24); + font-weight: bold; +} + +#search-results { + box-sizing: border-box; + border: 0.05em solid #b2d5fb; + background: #e8f3ff; + max-height: 80%; + overflow: scroll; +} + +#search-form input + #search-results { + border-top: none; + top: 3em; + max-height: calc(100% - 3em); +} + +/* @end */ + +/* @group search results */ + +#search-results > ul { + margin: 0; + list-style: none; +} + +#search-results > ul > li, +#search-results > p, +#search-results > table { + padding: 0.5em 1em; + margin: 0; +} + +#search-results > ul > li { + border-bottom: 1px solid #b2d5fb; +} + +#search-results > ul > li > ul { + list-style: none; +} + +.search-module h4 { + margin: 0; +} + +.search-module > ul { + margin: 0.5em 0 0.5em 2em; +} + +.search-module > ul > li > a[href] { + display: block; + color: inherit; + padding: 0.25em 0.5em; +} + +.search-module > ul > li > a[href].active-link { + background: #faf9dc; +} + +.search-module a[href]:hover { + text-decoration: none; +} + +.search-result a a { + pointer-events: none; +} + +.search-result ul.subs { + display: inline-block; + margin: 0; padding: 0; +} + +.search-result ul.subs li { + display: none; +} + +.search-result ul.subs::after { + display: inline-block; + content: "..."; + color: rgb(78,98,114); + margin: 0 0.25em; +} + +.more-results { + color: rgb(99, 141, 173); + position: relative; +} + +.more-results::before { + content: "+"; + display: inline-block; + color: #b2d5fb; + font-weight: bold; + font-size: 1.25em; line-height: inherit; + position: absolute; + left: -1em; +} + +/* @end */ + +/* @group Keyboard shortcuts table */ + +.keyboard-shortcuts { + line-height: 1.6em; +} + +.keyboard-shortcuts th { + color: rgb(78,98,114); +} + +.keyboard-shortcuts td:first-child, +.keyboard-shortcuts th:first-child { + text-align: right; + padding-right: 0.6em; +} + +.key { + display: inline-block; + font-size: 0.9em; + min-width: 0.8em; line-height: 1.2em; + text-align: center; + background: #b2d5fb; + border: 1px solid #74a3d6; + padding: 0 0.2em; + margin: 0 0.1em; +} + +/* @end */ + +/* @group Dropdown menus */ + +/* Based on #search styling above. */ + +.dropdown-menu { + position: fixed; + /* Not robust to window size changes. */ + top: 3.2em; + right: 0; + /* To display on top of synopsis menu on right side. */ + z-index: 1000; + border: 0.05em solid #b2d5fb; + background: #e8f3ff; +} + +@media only screen and (max-width: 999px) { + .dropdown-menu { + top: 5.7em; + } +} + +.dropdown-menu * { + margin: 0.1em; +} + +.dropdown-menu button { + border: 1px #5E5184 solid; + border-radius: 3px; + background: #5E5184; + padding: 3px; + color: #f4f4f4; + min-width: 6em; +} + +.dropdown-menu button:hover { + color: #5E5184; + background: #f4f4f4; +} + +.dropdown-menu button:active { + color: #f4f4f4; + background: #5E5184; +} + +/* @end */ diff --git a/docs/reports/heltc/synopsis.png b/docs/reports/heltc/synopsis.png new file mode 100644 index 0000000000000000000000000000000000000000..85fb86ec84907bcc86531dc82871948ff4d471fa GIT binary patch literal 11327 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 B5rhB$ literal 0 HcmV?d00001 diff --git a/docs/reports/stan.html b/docs/reports/stan.html new file mode 100644 index 0000000..e390f59 --- /dev/null +++ b/docs/reports/stan.html @@ -0,0 +1,16 @@ + +Stan Report

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 Revisiondcbc8682a964ae6f642ae37adbd46f6545d39aa6
Release DateFri Jul 29 13:18:20 2022 +0100
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/heltc/.stan.toml
CLI arguments-s --hide-solution report

Project Info

Information about the analysed project

Project nameheltc
Cabal Filesheltc.cabal
HIE Files Directory.hie
Files Number4

Analysis Info

Summary stats from the static analysis

Modules4
LoC14
Extensions29
SafeHaskell Extensions0
Available inspections44
Checked inspections44
Found Observations0
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.

  • 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 does not have any suggestions for your code.

  • Congratulations! Your project has zero suggestions!

    Stan carefully ran all configured inspection and found 0 observations for the project.

Observations

Based on the analysis results, Stan found several areas for improvement in the analysed files. In Stan terminology, we call these findings Observations. 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.

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.
\ No newline at end of file diff --git a/docs/users/AUTHORS.md b/docs/users/AUTHORS.md new file mode 100644 index 0000000..7c3875c --- /dev/null +++ b/docs/users/AUTHORS.md @@ -0,0 +1,6 @@ +# 🐐 AUTHORS + +* Main Software Engineer @TheKamilAdam +* Main QA Engineer @degustujaca + +## 🦄 🌈 ❤️ 💛 💚 💙 🤍 🖤 diff --git a/docs/users/FAQ.md b/docs/users/FAQ.md new file mode 100644 index 0000000..7717541 --- /dev/null +++ b/docs/users/FAQ.md @@ -0,0 +1,9 @@ +# FAQ + +**Frequently Asked Questions & Frequently Given Answers**. + +*We do not have any **FAQ** now.* + +You can ask question by [GitHub](https://github.com/helvm/heltc/issues). + +## 🦄 🌈 ❤️ 💛 💚 💙 🤍 🖤 diff --git a/docs/users/INSTALL.md b/docs/users/INSTALL.md new file mode 100644 index 0000000..2fcfb06 --- /dev/null +++ b/docs/users/INSTALL.md @@ -0,0 +1,44 @@ +# INSTALL + +How to download, test and run. + +## Download + +```bash +git clone https://github.com/helvm/heltc.git +cd heltc +``` + +## Cabal + +Compile and run with `cabal`: +```bash +cabal clean && cabal build && cabal test +cabal run heltc +``` + +## Etlas + +Compile and run with `etlas`: +```bash +etlas clean && etlas build && etlas test +etlas run heltc +``` + +## Gradle + +Compile and run with `gradlew`: +```bash +./gradlew clean -PetaSendMetrics=true +./gradlew compileEta +./gradlew compileTestEta +./gradlew test +./gradlew run +./gradlew shadowJar +``` + +## Other + +For more see [CONTRIBUTING](../developers/CONTRIBUTING.md). + +## 🦄 🌈 ❤️ 💛 💚 💙 🤍 🖤 diff --git a/docs/users/NEWS.md b/docs/users/NEWS.md new file mode 100644 index 0000000..27c8223 --- /dev/null +++ b/docs/users/NEWS.md @@ -0,0 +1,11 @@ +# NEWS 📰 + +**New features.** + +*We do not have **news** now.* + +For more see: +* [CHANGELOG](../developers/CHANGELOG.md) +* [Blog](https://writeonly.github.io/projects/heltc) - in Polish + +## 🦄 🌈 ❤️ 💛 💚 💙 🤍 🖤 diff --git a/docs/users/THANKS.md b/docs/users/THANKS.md new file mode 100644 index 0000000..e70d01d --- /dev/null +++ b/docs/users/THANKS.md @@ -0,0 +1,5 @@ +# 🙏 THANKS + +**HelTC** was inspired by many resources: + +## 🦄 🌈 ❤️ 💛 💚 💙 🤍 🖤 diff --git a/docs/users/TODO.md b/docs/users/TODO.md new file mode 100644 index 0000000..4e560e9 --- /dev/null +++ b/docs/users/TODO.md @@ -0,0 +1,11 @@ +# TODO + +**Future Features** + +*We do not have **todo** now.* + +You can propose feature by [GitHub](https://github.com/helvm/heltc/issues). + +For more see [ROADMAP](../developers/ROADMAP.md). + +## 🦄 🌈 ❤️ 💛 💚 💙 🤍 🖤 diff --git a/heltc.cabal b/heltc.cabal new file mode 100644 index 0000000..1d24376 --- /dev/null +++ b/heltc.cabal @@ -0,0 +1,162 @@ +cabal-version: 2.4 + +name: heltc +version: 0.1.0.0 + +synopsis: HELCT - Heavenly Esoteric Little C Transpiler to Esoteric Languages +description: Please see the README on GitHub at +homepage: https://helvm.github.io/heltc/ +bug-reports: https://github.com/helvm/heltc/issues + +license: Apache-2.0 +license-file: docs/license/LICENSE-APACHE +author: Kamil Adam +maintainer: kamil.adam.zabinski@gmail.com +copyright: 2020-2021 WriteOnly Developers + +category: Language +build-type: Simple +extra-source-files: + docs/developers/CHANGELOG.md + docs/README.md + +tested-with: GHC == 9.4.2 + +source-repository head + type: git + location: https://github.com/helvm/heltc + +common common-options + build-depends: + base < 4.17 + , relude == 1.1.0.0 + mixins: + base hiding (Prelude) + , relude (Relude as Prelude, Relude.Extra, Data.Text) + default-extensions: + EmptyDataDecls + ExistentialQuantification + FlexibleContexts + FlexibleInstances + FunctionalDependencies + GADTs + GeneralizedNewtypeDeriving + InstanceSigs + KindSignatures + LambdaCase + MultiParamTypeClasses + MultiWayIf + NamedFieldPuns +-- NoImplicitPrelude + OverloadedStrings + PartialTypeSignatures + PatternGuards + PolyKinds + RankNTypes + RecordWildCards + ScopedTypeVariables + StandaloneDeriving + TupleSections + TypeFamilies + TypeSynonymInstances + ViewPatterns +-- CPP +-- TemplateHaskell +-- ForeignFunctionInterface +-- MagicHash +-- UnliftedFFITypes + TypeOperators +-- UnboxedTuples +-- PackageImports +-- QuasiQuotes +-- DeriveAnyClass +-- DeriveLift +-- StaticPointers + DerivingStrategies + ConstraintKinds + StrictData + ghc-options: + -Wall + -Wcompat + -Widentities + -Wincomplete-uni-patterns + -Wincomplete-record-updates + -Wredundant-constraints + -Wnoncanonical-monad-instances + -fhide-source-paths +-- -Wmissing-export-lists FIXME + -Wpartial-fields + -Wmissing-deriving-strategies + -fwrite-ide-info + -hiedir=.hie + -Wunused-packages +-- -Werror + -fprint-potential-instances + + default-language: Haskell2010 + +library + import: common-options + hs-source-dirs: hs/src + exposed-modules: + HelVM.HelTC.HelTC + + other-extensions: + build-depends: + mixins: + base hiding (Prelude) + , relude (Relude as Prelude, Relude.Extra) + hs-source-dirs: hs/src + default-language: Haskell2010 + ghc-options: + +executable heltc + import: common-options + hs-source-dirs: hs/app + main-is: Main.hs + other-modules: + AppOptions + build-depends: +-- heltc +-- , optparse-applicative >= 0.14.3.0 + ghc-options: + -threaded + -rtsopts + -with-rtsopts=-N + +test-suite heltc-test + import: common-options + type: exitcode-stdio-1.0 + hs-source-dirs: hs/test + main-is: Main.hs + other-modules: + Spec + build-depends: + hspec + , hspec-core + , hspec-expectations-pretty-diff + , hspec-golden + , hspec-slow + + , heltc + + build-tool-depends: hspec-discover:hspec-discover == 2.* + ghc-options: + -threaded + -rtsopts + -with-rtsopts=-N + +benchmark heltc-benchmark + import: common-options + type: exitcode-stdio-1.0 + hs-source-dirs: hs/benchmark + main-is: Main.hs + build-depends: + gauge + +-- , heltc + + ghc-options: + -threaded + -rtsopts + -with-rtsopts=-N diff --git a/hlint.sh b/hlint.sh new file mode 100755 index 0000000..fd8d9ef --- /dev/null +++ b/hlint.sh @@ -0,0 +1,3 @@ +#!/usr/bin/env bash + +curl -sSL https://raw.github.com/ndmitchell/hlint/master/misc/run.sh | sh -s . diff --git a/hs/app/AppOptions.hs b/hs/app/AppOptions.hs new file mode 100644 index 0000000..aac3889 --- /dev/null +++ b/hs/app/AppOptions.hs @@ -0,0 +1 @@ +module AppOptions where diff --git a/hs/app/Main.hs b/hs/app/Main.hs new file mode 100644 index 0000000..fb30aa4 --- /dev/null +++ b/hs/app/Main.hs @@ -0,0 +1,4 @@ +module Main where + +main :: IO () +main = putStrLn "Hello, HelTC!" diff --git a/hs/benchmark/Main.hs b/hs/benchmark/Main.hs new file mode 100644 index 0000000..7158baf --- /dev/null +++ b/hs/benchmark/Main.hs @@ -0,0 +1,17 @@ +module Main where + +import Gauge.Main + +fib :: Int -> Int +fib 0 = 0 +fib 1 = 1 +fib n = fib (n-1) + fib (n-2) + +main :: IO () +main = defaultMain [ + bgroup "fib" + [ bench "0" $ whnf fib 0 + , bench "1" $ whnf fib 1 + , bench "2" $ whnf fib 2 + ] + ] diff --git a/hs/src/HelVM/HelTC/HelTC.hs b/hs/src/HelVM/HelTC/HelTC.hs new file mode 100644 index 0000000..462807b --- /dev/null +++ b/hs/src/HelVM/HelTC/HelTC.hs @@ -0,0 +1,2 @@ +module HelVM.HelTC.HelTC where + diff --git a/hs/test/HelVM/HelTC/Assemblers/Expectations.hs b/hs/test/HelVM/HelTC/Assemblers/Expectations.hs new file mode 100644 index 0000000..7fa3a9a --- /dev/null +++ b/hs/test/HelVM/HelTC/Assemblers/Expectations.hs @@ -0,0 +1,34 @@ +module HelVM.HelTC.Assemblers.Expectations ( + shouldBeDo, + shouldParseReturn, + goldenShouldBe, + goldenShouldParse +) where + +import HelVM.HelTC.Common.API + +import Test.Hspec +import Test.Hspec.Attoparsec + +infix 1 `shouldBeDo` +shouldBeDo :: (HasCallStack, Show a, Eq a) => a -> IO a -> Expectation +shouldBeDo action expected = shouldBe action =<< expected + +infix 1 `shouldParseReturn` +shouldParseReturn :: (Show a, Eq a) => ParsedIO a -> a -> Expectation +shouldParseReturn action = shouldReturn (joinEitherToIO action) + +infix 1 `goldenShouldBe` +goldenShouldBe :: (HasCallStack, Show a, Eq a) => IO a -> IO a -> Expectation +goldenShouldBe action expected = join $ liftA2 shouldBe action expected + +infix 1 `goldenShouldParse` +goldenShouldParse :: (Show a, Eq a) => ParsedIO a -> IO a -> Expectation +goldenShouldParse action expected = join $ liftA2 shouldParse action expected + +joinEitherToIO :: ParsedIO a -> IO a +joinEitherToIO io = eitherToIO =<< io + +eitherToIO :: Parsed a -> IO a +eitherToIO (Right value) = return value +eitherToIO (Left message) = fail message diff --git a/hs/test/Main.hs b/hs/test/Main.hs new file mode 100644 index 0000000..c5f1840 --- /dev/null +++ b/hs/test/Main.hs @@ -0,0 +1,10 @@ +module Main where + +import qualified Spec +import Test.Hspec (hspec) +import Test.Hspec.Slow + +main :: IO () +main = do + config <- configure 1 + hspec $ timeThese config Spec.spec diff --git a/hs/test/Spec.hs b/hs/test/Spec.hs new file mode 100644 index 0000000..5416ef6 --- /dev/null +++ b/hs/test/Spec.hs @@ -0,0 +1 @@ +{-# OPTIONS_GHC -F -pgmF hspec-discover -optF --module-name=Spec #-} diff --git a/report.sh b/report.sh new file mode 100755 index 0000000..89f1c70 --- /dev/null +++ b/report.sh @@ -0,0 +1,8 @@ +#!/usr/bin/env bash + +mkdir_and_cp() { + mkdir -p $(dirname "$2") && cp -r "$1" "$2" +} + +mkdir_and_cp dist-newstyle/build/*/*/*/doc/html/heltc/ docs/reports +mkdir_and_cp dist-newstyle/build/*/*/*/hpc/vanilla/html/heltc-test/ docs/reports diff --git a/stan.sh b/stan.sh new file mode 100755 index 0000000..7872481 --- /dev/null +++ b/stan.sh @@ -0,0 +1,7 @@ +#!/usr/bin/env bash + +export STAN_USE_DEFAULT_CONFIG=True + +stan -s --hide-solution report + +cp stan.html docs/reports