Showing preview only (5,933K chars total). Download the full file or copy to clipboard to get everything.
Repository: github/semantic
Branch: main
Commit: d1d07eb6228b
Files: 3053
Total size: 5.1 MB
Directory structure:
gitextract_vw5g09h3/
├── .bazelignore
├── .bazelrc
├── .dockerignore
├── .ghci.repl
├── .ghci.sample
├── .gitattributes
├── .github/
│ └── workflows/
│ ├── bazel.yml.disabled
│ └── haskell.yml
├── .gitignore
├── .gitmodules
├── .hlint.yaml
├── .hspec
├── .licenses/
│ └── semantic/
│ └── cabal/
│ ├── MonadRandom.txt
│ ├── QuickCheck.txt
│ ├── StateVar.txt
│ ├── adjunctions.txt
│ ├── aeson-pretty.txt
│ ├── aeson.txt
│ ├── algebraic-graphs.txt
│ ├── ansi-terminal.txt
│ ├── ansi-wl-pprint.txt
│ ├── array.txt
│ ├── asn1-encoding.txt
│ ├── asn1-parse.txt
│ ├── asn1-types.txt
│ ├── async.txt
│ ├── attoparsec-iso8601.txt
│ ├── attoparsec.txt
│ ├── base-compat-batteries.txt
│ ├── base-compat.txt
│ ├── base-orphans.txt
│ ├── base-prelude.txt
│ ├── base.txt
│ ├── base64-bytestring.txt
│ ├── basement.txt
│ ├── bifunctors.txt
│ ├── binary.txt
│ ├── blaze-builder.txt
│ ├── byteable.txt
│ ├── bytestring.txt
│ ├── call-stack.txt
│ ├── case-insensitive.txt
│ ├── cereal.txt
│ ├── charset.txt
│ ├── clock.txt
│ ├── cmark-gfm.txt
│ ├── colour.txt
│ ├── comonad.txt
│ ├── connection.txt
│ ├── constraints.txt
│ ├── containers.txt
│ ├── contravariant.txt
│ ├── cookie.txt
│ ├── cryptonite.txt
│ ├── data-default-class.txt
│ ├── deepseq-generics.txt
│ ├── deepseq.txt
│ ├── directory-tree.txt
│ ├── directory.txt
│ ├── distributive.txt
│ ├── dlist.txt
│ ├── enclosed-exceptions.txt
│ ├── erf.txt
│ ├── exceptions.txt
│ ├── fastsum.txt
│ ├── filepath.txt
│ ├── fingertree.txt
│ ├── foldl.txt
│ ├── freer-cofreer.txt
│ ├── fused-effects.txt
│ ├── generic-monoid.txt
│ ├── generics-sop.txt
│ ├── ghc-boot-th.txt
│ ├── ghc-boot.txt
│ ├── ghc-heap.txt
│ ├── ghc-prim.txt
│ ├── ghc-tcplugins-extra.txt
│ ├── ghc-typelits-extra.txt
│ ├── ghc-typelits-knownnat.txt
│ ├── ghc-typelits-natnormalise.txt
│ ├── ghc.txt
│ ├── ghci.txt
│ ├── gitrev.txt
│ ├── hashable.txt
│ ├── haskeline.txt
│ ├── haskell-lexer.txt
│ ├── haskell-src.txt
│ ├── haskell-tree-sitter.txt
│ ├── heap.txt
│ ├── hostname.txt
│ ├── hourglass.txt
│ ├── hpc.txt
│ ├── http-api-data.txt
│ ├── insert-ordered-containers.txt
│ ├── integer-gmp.txt
│ ├── integer-logarithms.txt
│ ├── invariant.txt
│ ├── kan-extensions.txt
│ ├── kdt.txt
│ ├── keys.txt
│ ├── lens.txt
│ ├── lifted-async.txt
│ ├── lifted-base.txt
│ ├── machines.txt
│ ├── managed.txt
│ ├── math-functions.txt
│ ├── megaparsec.txt
│ ├── memory.txt
│ ├── mersenne-random-pure64.txt
│ ├── mime-types.txt
│ ├── mmorph.txt
│ ├── monad-control.txt
│ ├── mtl.txt
│ ├── mwc-random.txt
│ ├── neat-interpolation.txt
│ ├── network-uri.txt
│ ├── network.txt
│ ├── old-locale.txt
│ ├── old-time.txt
│ ├── optional-args.txt
│ ├── optparse-applicative.txt
│ ├── parallel.txt
│ ├── parsec.txt
│ ├── parser-combinators.txt
│ ├── parsers.txt
│ ├── pem.txt
│ ├── pointed.txt
│ ├── pretty.txt
│ ├── prettyprinter.txt
│ ├── primitive.txt
│ ├── process.txt
│ ├── profunctors.txt
│ ├── proto3-suite.txt
│ ├── proto3-wire.txt
│ ├── quickcheck-instances.txt
│ ├── random.txt
│ ├── recursion-schemes.txt
│ ├── reducers.txt
│ ├── reflection.txt
│ ├── rts.txt
│ ├── safe.txt
│ ├── scientific.txt
│ ├── semigroupoids.txt
│ ├── semigroups.txt
│ ├── semilattices.txt
│ ├── servant.txt
│ ├── shelly.txt
│ ├── singleton-bool.txt
│ ├── socks.txt
│ ├── sop-core.txt
│ ├── split.txt
│ ├── stm-chans.txt
│ ├── stm.txt
│ ├── streaming-commons.txt
│ ├── string-conversions.txt
│ ├── swagger2.txt
│ ├── syb.txt
│ ├── system-fileio.txt
│ ├── system-filepath.txt
│ ├── tagged.txt
│ ├── template-haskell.txt
│ ├── temporary.txt
│ ├── terminfo.txt
│ ├── text.txt
│ ├── tf-random.txt
│ ├── th-abstraction.txt
│ ├── these.txt
│ ├── time-locale-compat.txt
│ ├── time.txt
│ ├── tls.txt
│ ├── transformers-base.txt
│ ├── transformers-compat.txt
│ ├── transformers.txt
│ ├── turtle.txt
│ ├── unix-compat.txt
│ ├── unix.txt
│ ├── unliftio-core.txt
│ ├── unordered-containers.txt
│ ├── utf8-string.txt
│ ├── uuid-types.txt
│ ├── vault.txt
│ ├── vector-builder.txt
│ ├── vector-instances.txt
│ ├── vector-th-unbox.txt
│ ├── vector.txt
│ ├── void.txt
│ ├── x509-store.txt
│ ├── x509-system.txt
│ ├── x509-validation.txt
│ ├── x509.txt
│ └── zlib.txt
├── .stylish-haskell.yaml
├── BUILD.bazel
├── CODEOWNERS
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── Dockerfile
├── HACKING.md
├── README.md
├── WORKSPACE
├── build/
│ ├── common.bzl
│ └── example_repos.bzl
├── cabal.project
├── cabal.project.ci
├── docs/
│ ├── adding-new-languages.md
│ ├── build.md
│ ├── codegen.md
│ ├── coding-style.md
│ ├── configuration.md
│ ├── core-grammar.md
│ ├── development.md
│ ├── examples.md
│ ├── grammar-development-guide.md
│ ├── why-haskell.md
│ ├── why-tree-sitter.md
│ └── 💡ProTip!.md
├── hie.yaml
├── notices/
│ └── THIRD_PARTY_NOTICE.md
├── proto/
│ └── semantic.proto
├── script/
│ ├── astgen
│ ├── bootstrap
│ ├── bootstrap-bazel
│ ├── build-and-upload
│ ├── clone-example-repos
│ ├── fix-broken-cabal-store
│ ├── generate-example
│ ├── ghci-flags
│ ├── profile
│ ├── protoc
│ ├── publish
│ └── repl
├── semantic/
│ ├── BUILD.bazel
│ ├── LICENSE
│ ├── README.md
│ ├── Setup.hs
│ ├── app/
│ │ └── Main.hs
│ ├── bench/
│ │ ├── Main.hs
│ │ ├── Tagging.hs
│ │ └── bench-fixtures/
│ │ ├── python/
│ │ │ ├── function-definition.py
│ │ │ ├── if-statement-functions.py
│ │ │ └── simple-assignment.py
│ │ └── ruby/
│ │ ├── function-definition.rb
│ │ ├── if-statement-functions.rb
│ │ └── simple-assignment.rb
│ ├── semantic.cabal
│ ├── src/
│ │ ├── Control/
│ │ │ ├── Carrier/
│ │ │ │ └── Parse/
│ │ │ │ ├── Measured.hs
│ │ │ │ └── Simple.hs
│ │ │ └── Effect/
│ │ │ ├── Parse.hs
│ │ │ ├── Sum/
│ │ │ │ └── Project.hs
│ │ │ └── Timeout.hs
│ │ ├── Data/
│ │ │ ├── Blob/
│ │ │ │ └── IO.hs
│ │ │ ├── Blob.hs
│ │ │ ├── Duration.hs
│ │ │ ├── Edit.hs
│ │ │ ├── Error.hs
│ │ │ ├── Flag.hs
│ │ │ ├── Graph/
│ │ │ │ └── Algebraic.hs
│ │ │ ├── Handle.hs
│ │ │ ├── Maybe/
│ │ │ │ └── Exts.hs
│ │ │ └── Semigroup/
│ │ │ └── App.hs
│ │ ├── Parsing/
│ │ │ ├── Parser.hs
│ │ │ └── TreeSitter.hs
│ │ ├── Semantic/
│ │ │ ├── Api/
│ │ │ │ ├── Bridge.hs
│ │ │ │ ├── StackGraph.hs
│ │ │ │ ├── Symbols.hs
│ │ │ │ └── Terms.hs
│ │ │ ├── Api.hs
│ │ │ ├── CLI.hs
│ │ │ ├── Config.hs
│ │ │ ├── Env.hs
│ │ │ ├── IO.hs
│ │ │ ├── Task/
│ │ │ │ └── Files.hs
│ │ │ ├── Task.hs
│ │ │ ├── Telemetry/
│ │ │ │ ├── AsyncQueue.hs
│ │ │ │ ├── Error.hs
│ │ │ │ ├── Log.hs
│ │ │ │ └── Stat.hs
│ │ │ ├── Telemetry.hs
│ │ │ ├── Util/
│ │ │ │ └── Pretty.hs
│ │ │ ├── Util.hs
│ │ │ └── Version.hs
│ │ └── Serializing/
│ │ ├── Format.hs
│ │ └── SExpression/
│ │ └── Precise.hs
│ └── test/
│ ├── Data/
│ │ ├── Graph/
│ │ │ └── Spec.hs
│ │ ├── Language/
│ │ │ └── Spec.hs
│ │ └── Semigroup/
│ │ └── App/
│ │ └── Spec.hs
│ ├── Examples.hs
│ ├── Generators.hs
│ ├── Integration/
│ │ └── Spec.hs
│ ├── Properties.hs
│ ├── Semantic/
│ │ ├── CLI/
│ │ │ └── Spec.hs
│ │ ├── IO/
│ │ │ └── Spec.hs
│ │ ├── Spec.hs
│ │ └── Stat/
│ │ └── Spec.hs
│ ├── Spec.hs
│ ├── SpecHelpers.hs
│ ├── Tags/
│ │ └── Spec.hs
│ └── fixtures/
│ ├── base.rb
│ ├── cli/
│ │ ├── blank.json
│ │ ├── diff-empty-language.json
│ │ ├── diff-no-after.json
│ │ ├── diff-no-before.json
│ │ ├── diff-no-language.json
│ │ ├── diff-null-after.json
│ │ ├── diff-null-before.json
│ │ ├── diff-null-both-sides.json
│ │ ├── diff-tree.json
│ │ ├── diff-tree.toc.json
│ │ ├── diff-unsupported-language.json
│ │ ├── diff.json
│ │ ├── parse-tree-empty.json
│ │ ├── parse-tree.json
│ │ ├── parse-tree.symbols.json
│ │ ├── parse-trees.json
│ │ └── parse.json
│ ├── go/
│ │ ├── analysis/
│ │ │ ├── bar/
│ │ │ │ ├── bar.go
│ │ │ │ └── rab.go
│ │ │ ├── foo/
│ │ │ │ └── foo.go
│ │ │ ├── main.go
│ │ │ └── main1.go
│ │ ├── corpus/
│ │ │ ├── array-types.A.go
│ │ │ ├── array-types.B.go
│ │ │ ├── array-types.diffA-B.txt
│ │ │ ├── array-types.diffB-A.txt
│ │ │ ├── array-types.parseA.txt
│ │ │ ├── array-types.parseB.txt
│ │ │ ├── array-with-implicit-length.A.go
│ │ │ ├── array-with-implicit-length.B.go
│ │ │ ├── array-with-implicit-length.diffA-B.txt
│ │ │ ├── array-with-implicit-length.diffB-A.txt
│ │ │ ├── array-with-implicit-length.parseA.txt
│ │ │ ├── array-with-implicit-length.parseB.txt
│ │ │ ├── assignment-statements.A.go
│ │ │ ├── assignment-statements.B.go
│ │ │ ├── assignment-statements.diffA-B.txt
│ │ │ ├── assignment-statements.diffB-A.txt
│ │ │ ├── assignment-statements.parseA.txt
│ │ │ ├── assignment-statements.parseB.txt
│ │ │ ├── binary-expressions.A.go
│ │ │ ├── binary-expressions.B.go
│ │ │ ├── binary-expressions.diffA-B.txt
│ │ │ ├── binary-expressions.diffB-A.txt
│ │ │ ├── binary-expressions.parseA.txt
│ │ │ ├── binary-expressions.parseB.txt
│ │ │ ├── call-expressions.A.go
│ │ │ ├── call-expressions.B.go
│ │ │ ├── call-expressions.diffA-B.txt
│ │ │ ├── call-expressions.diffB-A.txt
│ │ │ ├── call-expressions.parseA.txt
│ │ │ ├── call-expressions.parseB.txt
│ │ │ ├── case-statements.A.go
│ │ │ ├── case-statements.B.go
│ │ │ ├── case-statements.diffA-B.txt
│ │ │ ├── case-statements.diffB-A.txt
│ │ │ ├── case-statements.parseA.txt
│ │ │ ├── case-statements.parseB.txt
│ │ │ ├── channel-types.A.go
│ │ │ ├── channel-types.B.go
│ │ │ ├── channel-types.diffA-B.txt
│ │ │ ├── channel-types.diffB-A.txt
│ │ │ ├── channel-types.parseA.txt
│ │ │ ├── channel-types.parseB.txt
│ │ │ ├── comment.A.go
│ │ │ ├── comment.B.go
│ │ │ ├── comment.diffA-B.txt
│ │ │ ├── comment.diffB-A.txt
│ │ │ ├── comment.parseA.txt
│ │ │ ├── comment.parseB.txt
│ │ │ ├── const-declarations-with-types.A.go
│ │ │ ├── const-declarations-with-types.B.go
│ │ │ ├── const-declarations-with-types.diffA-B.txt
│ │ │ ├── const-declarations-with-types.diffB-A.txt
│ │ │ ├── const-declarations-with-types.parseA.txt
│ │ │ ├── const-declarations-with-types.parseB.txt
│ │ │ ├── const-declarations-without-types.A.go
│ │ │ ├── const-declarations-without-types.B.go
│ │ │ ├── const-declarations-without-types.diffA-B.txt
│ │ │ ├── const-declarations-without-types.diffB-A.txt
│ │ │ ├── const-declarations-without-types.parseA.txt
│ │ │ ├── const-declarations-without-types.parseB.txt
│ │ │ ├── const-with-implicit-values.A.go
│ │ │ ├── const-with-implicit-values.B.go
│ │ │ ├── const-with-implicit-values.diffA-B.txt
│ │ │ ├── const-with-implicit-values.diffB-A.txt
│ │ │ ├── const-with-implicit-values.parseA.txt
│ │ │ ├── const-with-implicit-values.parseB.txt
│ │ │ ├── constructors.A.go
│ │ │ ├── constructors.B.go
│ │ │ ├── constructors.diffA-B.txt
│ │ │ ├── constructors.diffB-A.txt
│ │ │ ├── constructors.parseA.txt
│ │ │ ├── constructors.parseB.txt
│ │ │ ├── float-literals.A.go
│ │ │ ├── float-literals.B.go
│ │ │ ├── float-literals.diffA-B.txt
│ │ │ ├── float-literals.diffB-A.txt
│ │ │ ├── float-literals.parseA.txt
│ │ │ ├── float-literals.parseB.txt
│ │ │ ├── for-statements.A.go
│ │ │ ├── for-statements.B.go
│ │ │ ├── for-statements.diffA-B.txt
│ │ │ ├── for-statements.diffB-A.txt
│ │ │ ├── for-statements.parseA.txt
│ │ │ ├── for-statements.parseB.txt
│ │ │ ├── function-declarations.A.go
│ │ │ ├── function-declarations.B.go
│ │ │ ├── function-declarations.diffA-B.txt
│ │ │ ├── function-declarations.diffB-A.txt
│ │ │ ├── function-declarations.parseA.txt
│ │ │ ├── function-declarations.parseB.txt
│ │ │ ├── function-literals.A.go
│ │ │ ├── function-literals.B.go
│ │ │ ├── function-literals.diffA-B.txt
│ │ │ ├── function-literals.diffB-A.txt
│ │ │ ├── function-literals.parseA.txt
│ │ │ ├── function-literals.parseB.txt
│ │ │ ├── function-types.A.go
│ │ │ ├── function-types.B.go
│ │ │ ├── function-types.diffA-B.txt
│ │ │ ├── function-types.diffB-A.txt
│ │ │ ├── function-types.parseA.txt
│ │ │ ├── function-types.parseB.txt
│ │ │ ├── go-and-defer-statements.A.go
│ │ │ ├── go-and-defer-statements.B.go
│ │ │ ├── go-and-defer-statements.diffA-B.txt
│ │ │ ├── go-and-defer-statements.diffB-A.txt
│ │ │ ├── go-and-defer-statements.parseA.txt
│ │ │ ├── go-and-defer-statements.parseB.txt
│ │ │ ├── grouped-import-declarations.A.go
│ │ │ ├── grouped-import-declarations.B.go
│ │ │ ├── grouped-import-declarations.diffA-B.txt
│ │ │ ├── grouped-import-declarations.diffB-A.txt
│ │ │ ├── grouped-import-declarations.parseA.txt
│ │ │ ├── grouped-import-declarations.parseB.txt
│ │ │ ├── grouped-var-declarations.A.go
│ │ │ ├── grouped-var-declarations.B.go
│ │ │ ├── grouped-var-declarations.diffA-B.txt
│ │ │ ├── grouped-var-declarations.diffB-A.txt
│ │ │ ├── grouped-var-declarations.parseA.txt
│ │ │ ├── grouped-var-declarations.parseB.txt
│ │ │ ├── if-statements.A.go
│ │ │ ├── if-statements.B.go
│ │ │ ├── if-statements.diffA-B.txt
│ │ │ ├── if-statements.diffB-A.txt
│ │ │ ├── if-statements.parseA.txt
│ │ │ ├── if-statements.parseB.txt
│ │ │ ├── imaginary-literals.A.go
│ │ │ ├── imaginary-literals.B.go
│ │ │ ├── imaginary-literals.diffA-B.txt
│ │ │ ├── imaginary-literals.diffB-A.txt
│ │ │ ├── imaginary-literals.parseA.txt
│ │ │ ├── imaginary-literals.parseB.txt
│ │ │ ├── import-statements.A.go
│ │ │ ├── import-statements.B.go
│ │ │ ├── import-statements.diffA-B.txt
│ │ │ ├── import-statements.diffB-A.txt
│ │ │ ├── import-statements.parseA.txt
│ │ │ ├── import-statements.parseB.txt
│ │ │ ├── increment-decrement-statements.A.go
│ │ │ ├── increment-decrement-statements.B.go
│ │ │ ├── increment-decrement-statements.diffA-B.txt
│ │ │ ├── increment-decrement-statements.diffB-A.txt
│ │ │ ├── increment-decrement-statements.parseA.txt
│ │ │ ├── increment-decrement-statements.parseB.txt
│ │ │ ├── int-literals.A.go
│ │ │ ├── int-literals.B.go
│ │ │ ├── int-literals.diffA-B.txt
│ │ │ ├── int-literals.diffB-A.txt
│ │ │ ├── int-literals.parseA.txt
│ │ │ ├── int-literals.parseB.txt
│ │ │ ├── interface-types.A.go
│ │ │ ├── interface-types.B.go
│ │ │ ├── interface-types.diffA-B.txt
│ │ │ ├── interface-types.diffB-A.txt
│ │ │ ├── interface-types.parseA.txt
│ │ │ ├── interface-types.parseB.txt
│ │ │ ├── label-statements.A.go
│ │ │ ├── label-statements.B.go
│ │ │ ├── label-statements.diffA-B.txt
│ │ │ ├── label-statements.diffB-A.txt
│ │ │ ├── label-statements.parseA.txt
│ │ │ ├── label-statements.parseB.txt
│ │ │ ├── map-literals.A.go
│ │ │ ├── map-literals.B.go
│ │ │ ├── map-literals.diffA-B.txt
│ │ │ ├── map-literals.diffB-A.txt
│ │ │ ├── map-literals.parseA.txt
│ │ │ ├── map-literals.parseB.txt
│ │ │ ├── map-types.A.go
│ │ │ ├── map-types.B.go
│ │ │ ├── map-types.diffA-B.txt
│ │ │ ├── map-types.diffB-A.txt
│ │ │ ├── map-types.parseA.txt
│ │ │ ├── map-types.parseB.txt
│ │ │ ├── method-declarations.A.go
│ │ │ ├── method-declarations.B.go
│ │ │ ├── method-declarations.diffA-B.txt
│ │ │ ├── method-declarations.diffB-A.txt
│ │ │ ├── method-declarations.parseA.txt
│ │ │ ├── method-declarations.parseB.txt
│ │ │ ├── modifying-struct-fields.A.go
│ │ │ ├── modifying-struct-fields.B.go
│ │ │ ├── modifying-struct-fields.diffA-B.txt
│ │ │ ├── modifying-struct-fields.diffB-A.txt
│ │ │ ├── modifying-struct-fields.parseA.txt
│ │ │ ├── modifying-struct-fields.parseB.txt
│ │ │ ├── parameter-declarations-with-types.A.go
│ │ │ ├── parameter-declarations-with-types.B.go
│ │ │ ├── parameter-declarations-with-types.diffA-B.txt
│ │ │ ├── parameter-declarations-with-types.diffB-A.txt
│ │ │ ├── parameter-declarations-with-types.parseA.txt
│ │ │ ├── parameter-declarations-with-types.parseB.txt
│ │ │ ├── pointer-types.A.go
│ │ │ ├── pointer-types.B.go
│ │ │ ├── pointer-types.diffA-B.txt
│ │ │ ├── pointer-types.diffB-A.txt
│ │ │ ├── pointer-types.parseA.txt
│ │ │ ├── pointer-types.parseB.txt
│ │ │ ├── qualified-types.A.go
│ │ │ ├── qualified-types.B.go
│ │ │ ├── qualified-types.diffA-B.txt
│ │ │ ├── qualified-types.diffB-A.txt
│ │ │ ├── qualified-types.parseA.txt
│ │ │ ├── qualified-types.parseB.txt
│ │ │ ├── rune-literals.A.go
│ │ │ ├── rune-literals.B.go
│ │ │ ├── rune-literals.diffA-B.txt
│ │ │ ├── rune-literals.diffB-A.txt
│ │ │ ├── rune-literals.parseA.txt
│ │ │ ├── rune-literals.parseB.txt
│ │ │ ├── select-statements.A.go
│ │ │ ├── select-statements.B.go
│ │ │ ├── select-statements.diffA-B.txt
│ │ │ ├── select-statements.diffB-A.txt
│ │ │ ├── select-statements.parseA.txt
│ │ │ ├── select-statements.parseB.txt
│ │ │ ├── selector-expressions.A.go
│ │ │ ├── selector-expressions.B.go
│ │ │ ├── selector-expressions.diffA-B.txt
│ │ │ ├── selector-expressions.diffB-A.txt
│ │ │ ├── selector-expressions.parseA.txt
│ │ │ ├── selector-expressions.parseB.txt
│ │ │ ├── send-statements.A.go
│ │ │ ├── send-statements.B.go
│ │ │ ├── send-statements.diffA-B.txt
│ │ │ ├── send-statements.diffB-A.txt
│ │ │ ├── send-statements.parseA.txt
│ │ │ ├── send-statements.parseB.txt
│ │ │ ├── short-var-declarations.A.go
│ │ │ ├── short-var-declarations.B.go
│ │ │ ├── short-var-declarations.diffA-B.txt
│ │ │ ├── short-var-declarations.diffB-A.txt
│ │ │ ├── short-var-declarations.parseA.txt
│ │ │ ├── short-var-declarations.parseB.txt
│ │ │ ├── single-import-declarations.A.go
│ │ │ ├── single-import-declarations.B.go
│ │ │ ├── single-import-declarations.diffA-B.txt
│ │ │ ├── single-import-declarations.diffB-A.txt
│ │ │ ├── single-import-declarations.parseA.txt
│ │ │ ├── single-import-declarations.parseB.txt
│ │ │ ├── single-import-declarationsA.parseA.txt
│ │ │ ├── single-line-function-declarations.A.go
│ │ │ ├── single-line-function-declarations.B.go
│ │ │ ├── single-line-function-declarations.diffA-B.txt
│ │ │ ├── single-line-function-declarations.diffB-A.txt
│ │ │ ├── single-line-function-declarations.parseA.txt
│ │ │ ├── single-line-function-declarations.parseB.txt
│ │ │ ├── slice-expressions.A.go
│ │ │ ├── slice-expressions.B.go
│ │ │ ├── slice-expressions.diffA-B.txt
│ │ │ ├── slice-expressions.diffB-A.txt
│ │ │ ├── slice-expressions.parseA.txt
│ │ │ ├── slice-expressions.parseB.txt
│ │ │ ├── slice-literals.A.go
│ │ │ ├── slice-literals.B.go
│ │ │ ├── slice-literals.diffA-B.txt
│ │ │ ├── slice-literals.diffB-A.txt
│ │ │ ├── slice-literals.parseA.txt
│ │ │ ├── slice-literals.parseB.txt
│ │ │ ├── slice-types.A.go
│ │ │ ├── slice-types.B.go
│ │ │ ├── slice-types.diffA-B.txt
│ │ │ ├── slice-types.diffB-A.txt
│ │ │ ├── slice-types.parseA.txt
│ │ │ ├── slice-types.parseB.txt
│ │ │ ├── string-literals.A.go
│ │ │ ├── string-literals.B.go
│ │ │ ├── string-literals.diffA-B.txt
│ │ │ ├── string-literals.diffB-A.txt
│ │ │ ├── string-literals.parseA.txt
│ │ │ ├── string-literals.parseB.txt
│ │ │ ├── struct-field-declarations.A.go
│ │ │ ├── struct-field-declarations.B.go
│ │ │ ├── struct-field-declarations.diffA-B.txt
│ │ │ ├── struct-field-declarations.diffB-A.txt
│ │ │ ├── struct-field-declarations.parseA.txt
│ │ │ ├── struct-field-declarations.parseB.txt
│ │ │ ├── struct-literals.A.go
│ │ │ ├── struct-literals.B.go
│ │ │ ├── struct-literals.diffA-B.txt
│ │ │ ├── struct-literals.diffB-A.txt
│ │ │ ├── struct-literals.parseA.txt
│ │ │ ├── struct-literals.parseB.txt
│ │ │ ├── struct-types.A.go
│ │ │ ├── struct-types.B.go
│ │ │ ├── struct-types.diffA-B.txt
│ │ │ ├── struct-types.diffB-A.txt
│ │ │ ├── struct-types.parseA.txt
│ │ │ ├── struct-types.parseB.txt
│ │ │ ├── switch-statement.parseA.txt
│ │ │ ├── switch-statements.A.go
│ │ │ ├── switch-statements.B.go
│ │ │ ├── switch-statements.diffA-B.txt
│ │ │ ├── switch-statements.diffB-A.txt
│ │ │ ├── switch-statements.parseA.txt
│ │ │ ├── switch-statements.parseB.txt
│ │ │ ├── type-aliases.A.go
│ │ │ ├── type-aliases.B.go
│ │ │ ├── type-aliases.diffA-B.txt
│ │ │ ├── type-aliases.diffB-A.txt
│ │ │ ├── type-aliases.parseA.txt
│ │ │ ├── type-aliases.parseB.txt
│ │ │ ├── type-assertion-expressions.A.go
│ │ │ ├── type-assertion-expressions.B.go
│ │ │ ├── type-assertion-expressions.diffA-B.txt
│ │ │ ├── type-assertion-expressions.diffB-A.txt
│ │ │ ├── type-assertion-expressions.parseA.txt
│ │ │ ├── type-assertion-expressions.parseB.txt
│ │ │ ├── type-conversion-expressions.A.go
│ │ │ ├── type-conversion-expressions.B.go
│ │ │ ├── type-conversion-expressions.diffA-B.txt
│ │ │ ├── type-conversion-expressions.diffB-A.txt
│ │ │ ├── type-conversion-expressions.parseA.txt
│ │ │ ├── type-conversion-expressions.parseB.txt
│ │ │ ├── type-declarations.A.go
│ │ │ ├── type-declarations.B.go
│ │ │ ├── type-declarations.diffA-B.txt
│ │ │ ├── type-declarations.diffB-A.txt
│ │ │ ├── type-declarations.parseA.txt
│ │ │ ├── type-declarations.parseB.txt
│ │ │ ├── type-switch-statements.A.go
│ │ │ ├── type-switch-statements.B.go
│ │ │ ├── type-switch-statements.diffA-B.txt
│ │ │ ├── type-switch-statements.diffB-A.txt
│ │ │ ├── type-switch-statements.parseA.txt
│ │ │ ├── type-switch-statements.parseB.txt
│ │ │ ├── unary-expressions.A.go
│ │ │ ├── unary-expressions.B.go
│ │ │ ├── unary-expressions.diffA-B.txt
│ │ │ ├── unary-expressions.diffB-A.txt
│ │ │ ├── unary-expressions.parseA.txt
│ │ │ ├── unary-expressions.parseB.txt
│ │ │ ├── var-declarations-with-no-expressions.A.go
│ │ │ ├── var-declarations-with-no-expressions.B.go
│ │ │ ├── var-declarations-with-no-expressions.diffA-B.txt
│ │ │ ├── var-declarations-with-no-expressions.diffB-A.txt
│ │ │ ├── var-declarations-with-no-expressions.parseA.txt
│ │ │ ├── var-declarations-with-no-expressions.parseB.txt
│ │ │ ├── var-declarations-with-types.A.go
│ │ │ ├── var-declarations-with-types.B.go
│ │ │ ├── var-declarations-with-types.diffA-B.txt
│ │ │ ├── var-declarations-with-types.diffB-A.txt
│ │ │ ├── var-declarations-with-types.parseA.txt
│ │ │ ├── var-declarations-with-types.parseB.txt
│ │ │ ├── var-declarations-without-types.A.go
│ │ │ ├── var-declarations-without-types.B.go
│ │ │ ├── var-declarations-without-types.diffA-B.txt
│ │ │ ├── var-declarations-without-types.diffB-A.txt
│ │ │ ├── var-declarations-without-types.parseA.txt
│ │ │ ├── var-declarations-without-types.parseB.txt
│ │ │ ├── variadic-function-declarations.A.go
│ │ │ ├── variadic-function-declarations.B.go
│ │ │ ├── variadic-function-declarations.diffA-B.txt
│ │ │ ├── variadic-function-declarations.diffB-A.txt
│ │ │ ├── variadic-function-declarations.parseA.txt
│ │ │ └── variadic-function-declarations.parseB.txt
│ │ ├── import-graph/
│ │ │ ├── main.go
│ │ │ └── main.json
│ │ ├── matching/
│ │ │ ├── for.go
│ │ │ └── integers.go
│ │ ├── tags/
│ │ │ ├── method.go
│ │ │ └── simple_functions.go
│ │ └── toc/
│ │ ├── method-with-receiver.A.go
│ │ └── method-with-receiver.B.go
│ ├── haskell/
│ │ └── corpus/
│ │ ├── algebraic-datatype-declarations.A.hs
│ │ ├── algebraic-datatype-declarations.B.hs
│ │ ├── algebraic-datatype-declarations.diffA-B.txt
│ │ ├── algebraic-datatype-declarations.diffB-A.txt
│ │ ├── algebraic-datatype-declarations.parseA.txt
│ │ ├── algebraic-datatype-declarations.parseB.txt
│ │ ├── blank.A.hs
│ │ ├── blank.parseA.txt
│ │ ├── cpp-directives.A.hs
│ │ ├── cpp-directives.B.hs
│ │ ├── cpp-directives.diffA-B.txt
│ │ ├── cpp-directives.diffB-A.txt
│ │ ├── cpp-directives.parseA.txt
│ │ ├── cpp-directives.parseB.txt
│ │ ├── default-declaration.A.hs
│ │ ├── default-declaration.B.hs
│ │ ├── default-declaration.diffA-B.txt
│ │ ├── default-declaration.diffB-A.txt
│ │ ├── default-declaration.parseA.txt
│ │ ├── default-declaration.parseB.txt
│ │ ├── expressions.A.hs
│ │ ├── expressions.B.hs
│ │ ├── expressions.diffA-B.txt
│ │ ├── expressions.diffB-A.txt
│ │ ├── expressions.parseA.txt
│ │ ├── expressions.parseB.txt
│ │ ├── function-declarations.A.hs
│ │ ├── function-declarations.B.hs
│ │ ├── function-declarations.diffA-B.txt
│ │ ├── function-declarations.diffB-A.txt
│ │ ├── function-declarations.parseA.txt
│ │ ├── function-declarations.parseB.txt
│ │ ├── gadt-declarations.A.hs
│ │ ├── gadt-declarations.B.hs
│ │ ├── gadt-declarations.diffA-B.txt
│ │ ├── gadt-declarations.diffB-A.txt
│ │ ├── gadt-declarations.parseA.txt
│ │ ├── gadt-declarations.parseB.txt
│ │ ├── import-declaration.A.hs
│ │ ├── import-declaration.B.hs
│ │ ├── import-declaration.diffA-B.txt
│ │ ├── import-declaration.diffB-A.txt
│ │ ├── import-declaration.parseA.txt
│ │ ├── import-declaration.parseB.txt
│ │ ├── layout.A.hs
│ │ ├── layout.B.hs
│ │ ├── layout.diffA-B.txt
│ │ ├── layout.diffB-A.txt
│ │ ├── layout.parseA.txt
│ │ ├── layout.parseB.txt
│ │ ├── literals.A.hs
│ │ ├── literals.B.hs
│ │ ├── literals.diffA-B.txt
│ │ ├── literals.diffB-A.txt
│ │ ├── literals.parseA.txt
│ │ ├── literals.parseB.txt
│ │ ├── module-declaration1.A.hs
│ │ ├── module-declaration1.B.hs
│ │ ├── module-declaration1.diffA-B.txt
│ │ ├── module-declaration1.diffB-A.txt
│ │ ├── module-declaration1.parseA.txt
│ │ ├── module-declaration1.parseB.txt
│ │ ├── module-declaration2.A.hs
│ │ ├── module-declaration2.B.hs
│ │ ├── module-declaration2.diffA-B.txt
│ │ ├── module-declaration2.diffB-A.txt
│ │ ├── module-declaration2.parseA.txt
│ │ ├── module-declaration2.parseB.txt
│ │ ├── module-declaration3.A.hs
│ │ ├── module-declaration3.B.hs
│ │ ├── module-declaration3.diffA-B.txt
│ │ ├── module-declaration3.diffB-A.txt
│ │ ├── module-declaration3.parseA.txt
│ │ ├── module-declaration3.parseB.txt
│ │ ├── module-declaration4.A.hs
│ │ ├── module-declaration4.B.hs
│ │ ├── module-declaration4.diffA-B.txt
│ │ ├── module-declaration4.diffB-A.txt
│ │ ├── module-declaration4.parseA.txt
│ │ ├── module-declaration4.parseB.txt
│ │ ├── module-declaration5.A.hs
│ │ ├── module-declaration5.B.hs
│ │ ├── module-declaration5.diffA-B.txt
│ │ ├── module-declaration5.diffB-A.txt
│ │ ├── module-declaration5.parseA.txt
│ │ ├── module-declaration5.parseB.txt
│ │ ├── newtype-declaration.A.hs
│ │ ├── newtype-declaration.B.hs
│ │ ├── newtype-declaration.diffA-B.txt
│ │ ├── newtype-declaration.diffB-A.txt
│ │ ├── newtype-declaration.parseA.txt
│ │ ├── newtype-declaration.parseB.txt
│ │ ├── standalone-deriving-declaration.A.hs
│ │ ├── standalone-deriving-declaration.B.hs
│ │ ├── standalone-deriving-declaration.diffA-B.txt
│ │ ├── standalone-deriving-declaration.diffB-A.txt
│ │ ├── standalone-deriving-declaration.parseA.txt
│ │ ├── standalone-deriving-declaration.parseB.txt
│ │ ├── statements.A.hs
│ │ ├── statements.B.hs
│ │ ├── statements.diffA-B.txt
│ │ ├── statements.diffB-A.txt
│ │ ├── statements.parseA.txt
│ │ ├── statements.parseB.txt
│ │ ├── tempate-haskell.A.hs
│ │ ├── tempate-haskell.parseA.txt
│ │ ├── template-haskell.B.hs
│ │ ├── type-class-declarations.A.hs
│ │ ├── type-class-declarations.B.hs
│ │ ├── type-class-declarations.diffA-B.txt
│ │ ├── type-class-declarations.diffB-A.txt
│ │ ├── type-class-declarations.parseA.txt
│ │ ├── type-class-declarations.parseB.txt
│ │ ├── type-class-instance-declarations.A.hs
│ │ ├── type-class-instance-declarations.B.hs
│ │ ├── type-class-instance-declarations.diffA-B.txt
│ │ ├── type-class-instance-declarations.diffB-A.txt
│ │ ├── type-class-instance-declarations.parseA.txt
│ │ ├── type-class-instance-declarations.parseB.txt
│ │ ├── type-family-declarations.A.hs
│ │ ├── type-family-declarations.B.hs
│ │ ├── type-family-declarations.diffA-B.txt
│ │ ├── type-family-declarations.diffB-A.txt
│ │ ├── type-family-declarations.parseA.txt
│ │ ├── type-family-declarations.parseB.txt
│ │ ├── type-signatures.A.hs
│ │ ├── type-signatures.B.hs
│ │ ├── type-signatures.diffA-B.txt
│ │ ├── type-signatures.diffB-A.txt
│ │ ├── type-signatures.parseA.txt
│ │ ├── type-signatures.parseB.txt
│ │ ├── type-synonyms.A.hs
│ │ ├── type-synonyms.B.hs
│ │ ├── type-synonyms.diffA-B.txt
│ │ ├── type-synonyms.diffB-A.txt
│ │ ├── type-synonyms.parseA.txt
│ │ └── type-synonyms.parseB.txt
│ ├── java/
│ │ └── corpus/
│ │ ├── ArrayAccess.A.java
│ │ ├── ArrayAccess.B.java
│ │ ├── ArrayAccess.diffA-B.txt
│ │ ├── ArrayAccess.diffB-A.txt
│ │ ├── ArrayAccess.parseA.txt
│ │ ├── ArrayAccess.parseB.txt
│ │ ├── AssertStatement.A.java
│ │ ├── AssertStatement.B.java
│ │ ├── AssertStatement.diffA-B.txt
│ │ ├── AssertStatement.diffB-A.txt
│ │ ├── AssertStatement.parseA.txt
│ │ ├── AssertStatement.parseB.txt
│ │ ├── Binary.A.java
│ │ ├── Binary.B.java
│ │ ├── Binary.diffA-B.txt
│ │ ├── Binary.diffB-A.txt
│ │ ├── Binary.parseA.txt
│ │ ├── Binary.parseB.txt
│ │ ├── Boolean.A.java
│ │ ├── Boolean.B.java
│ │ ├── Boolean.diffA-B.txt
│ │ ├── Boolean.diffB-A.txt
│ │ ├── Boolean.parseA.txt
│ │ ├── Boolean.parseB.txt
│ │ ├── Char.A.java
│ │ ├── Char.B.java
│ │ ├── Char.diffA-B.txt
│ │ ├── Char.diffB-A.txt
│ │ ├── Char.parseA.txt
│ │ ├── Char.parseB.txt
│ │ ├── ClassBody.A.java
│ │ ├── ClassBody.B.java
│ │ ├── ClassBody.diffA-B.txt
│ │ ├── ClassBody.diffB-A.txt
│ │ ├── ClassBody.parseA.txt
│ │ ├── ClassBody.parseB.txt
│ │ ├── ClassLiteral.A.java
│ │ ├── ClassLiteral.B.java
│ │ ├── ClassLiteral.diffA-B.txt
│ │ ├── ClassLiteral.diffB-A.txt
│ │ ├── ClassLiteral.parseA.txt
│ │ ├── ClassLiteral.parseB.txt
│ │ ├── Comment.A.java
│ │ ├── Comment.B.java
│ │ ├── Comment.diffA-B.txt
│ │ ├── Comment.diffB-A.txt
│ │ ├── Comment.parseA.txt
│ │ ├── Comment.parseB.txt
│ │ ├── Continue.A.java
│ │ ├── Continue.B.java
│ │ ├── Continue.diffA-B.txt
│ │ ├── Continue.diffB-A.txt
│ │ ├── Continue.parseA.txt
│ │ ├── Continue.parseB.txt
│ │ ├── Continue0.A.java
│ │ ├── Continue1.A.java
│ │ ├── Dims.A.java
│ │ ├── Dims.B.java
│ │ ├── Dims.diffA-B.txt
│ │ ├── Dims.diffB-A.txt
│ │ ├── Dims.parseA.txt
│ │ ├── Dims.parseB.txt
│ │ ├── DoWhile.A.java
│ │ ├── DoWhile.B.java
│ │ ├── DoWhile.diffA-B.txt
│ │ ├── DoWhile.diffB-A.txt
│ │ ├── DoWhile.parseA.txt
│ │ ├── DoWhile.parseB.txt
│ │ ├── EnumDeclaration.A.java
│ │ ├── EnumDeclaration.B.java
│ │ ├── EnumDeclaration.diffA-B.txt
│ │ ├── EnumDeclaration.diffB-A.txt
│ │ ├── EnumDeclaration.parseA.txt
│ │ ├── EnumDeclaration.parseB.txt
│ │ ├── FieldAccess.A.java
│ │ ├── FieldAccess.B.java
│ │ ├── FieldAccess.diffA-B.txt
│ │ ├── FieldAccess.diffB-A.txt
│ │ ├── FieldAccess.parseA.txt
│ │ ├── FieldAccess.parseB.txt
│ │ ├── Float.A.java
│ │ ├── Float.B.java
│ │ ├── Float.diffA-B.txt
│ │ ├── Float.diffB-A.txt
│ │ ├── Float.parseA.txt
│ │ ├── Float.parseB.txt
│ │ ├── For.A.java
│ │ ├── For.B.java
│ │ ├── For.diffA-B.txt
│ │ ├── For.diffB-A.txt
│ │ ├── For.parseA.txt
│ │ ├── For.parseB.txt
│ │ ├── If.A.java
│ │ ├── If.B.java
│ │ ├── If.diffA-B.txt
│ │ ├── If.diffB-A.txt
│ │ ├── If.parseA.txt
│ │ ├── If.parseB.txt
│ │ ├── Import.A.java
│ │ ├── Import.B.java
│ │ ├── Import.diffA-B.txt
│ │ ├── Import.diffB-A.txt
│ │ ├── Import.parseA.txt
│ │ ├── Import.parseB.txt
│ │ ├── Int.A.java
│ │ ├── Int.B.java
│ │ ├── Int.diffA-B.txt
│ │ ├── Int.diffB-A.txt
│ │ ├── Int.parseA.txt
│ │ ├── Int.parseB.txt
│ │ ├── Interface.A.java
│ │ ├── Interface.B.java
│ │ ├── Interface.diffA-B.txt
│ │ ├── Interface.diffB-A.txt
│ │ ├── Interface.parseA.txt
│ │ ├── Interface.parseB.txt
│ │ ├── Lambda.A.java
│ │ ├── Lambda.B.java
│ │ ├── Lambda.diffA-B.txt
│ │ ├── Lambda.diffB-A.txt
│ │ ├── Lambda.parseA.txt
│ │ ├── Lambda.parseB.txt
│ │ ├── ScopedIdentifier.A.java
│ │ ├── ScopedIdentifier.B.java
│ │ ├── ScopedIdentifier.diffA-B.txt
│ │ ├── ScopedIdentifier.diffB-A.txt
│ │ ├── ScopedIdentifier.parseA.txt
│ │ ├── ScopedIdentifier.parseB.txt
│ │ ├── SpreadParameter.A.java
│ │ ├── SpreadParameter.B.java
│ │ ├── SpreadParameter.diffA-B.txt
│ │ ├── SpreadParameter.diffB-A.txt
│ │ ├── SpreadParameter.parseA.txt
│ │ ├── SpreadParameter.parseB.txt
│ │ ├── String.A.java
│ │ ├── String.B.java
│ │ ├── String.diffA-B.txt
│ │ ├── String.diffB-A.txt
│ │ ├── String.parseA.txt
│ │ ├── String.parseB.txt
│ │ ├── Switch.A.java
│ │ ├── Switch.B.java
│ │ ├── Switch.diffA-B.txt
│ │ ├── Switch.diffB-A.txt
│ │ ├── Switch.parseA.txt
│ │ ├── Switch.parseB.txt
│ │ ├── Throws.A.java
│ │ ├── Throws.B.java
│ │ ├── TryCatches.A.java
│ │ ├── TryCatches.B.java
│ │ ├── TryWithResourcesStatement.A.java
│ │ ├── TryWithResourcesStatement.B.java
│ │ ├── TryWithResourcesStatement.diffA-B.txt
│ │ ├── TryWithResourcesStatement.diffB-A.txt
│ │ ├── TryWithResourcesStatement.parseA.txt
│ │ ├── TryWithResourcesStatement.parseB.txt
│ │ ├── TypeArgument.A.java
│ │ ├── TypeArgument.B.java
│ │ ├── TypeArgument.diffA-B.txt
│ │ ├── TypeArgument.diffB-A.txt
│ │ ├── TypeArgument.parseA.txt
│ │ ├── TypeArgument.parseB.txt
│ │ ├── Update.A.java
│ │ ├── Update.B.java
│ │ ├── Update.diffA-B.txt
│ │ ├── Update.diffB-A.txt
│ │ ├── Update.parseA.txt
│ │ ├── Update.parseB.txt
│ │ ├── VariableDeclaration.A.java
│ │ ├── VariableDeclaration.B.java
│ │ ├── VariableDeclaration.diffA-B.txt
│ │ ├── VariableDeclaration.diffB-A.txt
│ │ ├── VariableDeclaration.parseA.txt
│ │ ├── VariableDeclaration.parseB.txt
│ │ ├── While.A.java
│ │ ├── While.B.java
│ │ ├── While.diffA-B.txt
│ │ ├── While.diffB-A.txt
│ │ ├── While.parseA.txt
│ │ ├── While.parseB.txt
│ │ ├── Wildcard.A.java
│ │ ├── Wildcard.B.java
│ │ ├── Wildcard.diffA-B.txt
│ │ ├── Wildcard.diffB-A.txt
│ │ ├── Wildcard.parseA.txt
│ │ ├── Wildcard.parseB.txt
│ │ ├── array-access.java
│ │ ├── assertStatement.java
│ │ ├── assertStringLiteral.java
│ │ ├── enum.java
│ │ ├── methodReference.java
│ │ ├── modifier-abstract.java
│ │ ├── modifier-private.java
│ │ ├── modifier-protected.java
│ │ ├── modifier-public.java
│ │ ├── modifier-static.java
│ │ ├── null.java
│ │ ├── package.java
│ │ ├── return.java
│ │ ├── try.java
│ │ └── try_with_resources.java
│ ├── javascript/
│ │ ├── analysis/
│ │ │ ├── exports/
│ │ │ │ ├── lib.js
│ │ │ │ └── main.js
│ │ │ ├── foo.js
│ │ │ ├── main.js
│ │ │ └── main2.js
│ │ ├── corpus/
│ │ │ ├── anonymous-function.A.js
│ │ │ ├── anonymous-function.B.js
│ │ │ ├── anonymous-function.diffA-B.txt
│ │ │ ├── anonymous-function.diffB-A.txt
│ │ │ ├── anonymous-function.parseA.txt
│ │ │ ├── anonymous-function.parseB.txt
│ │ │ ├── anonymous-parameterless-function.A.js
│ │ │ ├── anonymous-parameterless-function.B.js
│ │ │ ├── anonymous-parameterless-function.diffA-B.txt
│ │ │ ├── anonymous-parameterless-function.diffB-A.txt
│ │ │ ├── anonymous-parameterless-function.parseA.txt
│ │ │ ├── anonymous-parameterless-function.parseB.txt
│ │ │ ├── array.A.js
│ │ │ ├── array.B.js
│ │ │ ├── array.diffA-B.txt
│ │ │ ├── array.diffB-A.txt
│ │ │ ├── array.parseA.txt
│ │ │ ├── array.parseB.txt
│ │ │ ├── arrow-function.A.js
│ │ │ ├── arrow-function.B.js
│ │ │ ├── arrow-function.diffA-B.txt
│ │ │ ├── arrow-function.diffB-A.txt
│ │ │ ├── arrow-function.parseA.txt
│ │ │ ├── arrow-function.parseB.txt
│ │ │ ├── assignment-pattern.A.js
│ │ │ ├── assignment-pattern.B.js
│ │ │ ├── assignment-pattern.diffA-B.txt
│ │ │ ├── assignment-pattern.diffB-A.txt
│ │ │ ├── assignment-pattern.parseA.txt
│ │ │ ├── assignment-pattern.parseB.txt
│ │ │ ├── assignment.A.js
│ │ │ ├── assignment.B.js
│ │ │ ├── assignment.diffA-B.txt
│ │ │ ├── assignment.diffB-A.txt
│ │ │ ├── assignment.parseA.txt
│ │ │ ├── assignment.parseB.txt
│ │ │ ├── bitwise-operator.A.js
│ │ │ ├── bitwise-operator.B.js
│ │ │ ├── bitwise-operator.diffA-B.txt
│ │ │ ├── bitwise-operator.diffB-A.txt
│ │ │ ├── bitwise-operator.parseA.txt
│ │ │ ├── bitwise-operator.parseB.txt
│ │ │ ├── boolean-operator.A.js
│ │ │ ├── boolean-operator.B.js
│ │ │ ├── boolean-operator.diffA-B.txt
│ │ │ ├── boolean-operator.diffB-A.txt
│ │ │ ├── boolean-operator.parseA.txt
│ │ │ ├── boolean-operator.parseB.txt
│ │ │ ├── break.A.js
│ │ │ ├── break.B.js
│ │ │ ├── break.diffA-B.txt
│ │ │ ├── break.diffB-A.txt
│ │ │ ├── break.parseA.txt
│ │ │ ├── break.parseB.txt
│ │ │ ├── chained-callbacks.A.js
│ │ │ ├── chained-callbacks.B.js
│ │ │ ├── chained-callbacks.diffA-B.txt
│ │ │ ├── chained-callbacks.diffB-A.txt
│ │ │ ├── chained-callbacks.parseA.txt
│ │ │ ├── chained-callbacks.parseB.txt
│ │ │ ├── chained-property-access.A.js
│ │ │ ├── chained-property-access.B.js
│ │ │ ├── chained-property-access.diffA-B.txt
│ │ │ ├── chained-property-access.diffB-A.txt
│ │ │ ├── chained-property-access.parseA.txt
│ │ │ ├── chained-property-access.parseB.txt
│ │ │ ├── class.A.js
│ │ │ ├── class.B.js
│ │ │ ├── class.diffA-B.txt
│ │ │ ├── class.diffB-A.txt
│ │ │ ├── class.parseA.txt
│ │ │ ├── class.parseB.txt
│ │ │ ├── comma-operator.A.js
│ │ │ ├── comma-operator.B.js
│ │ │ ├── comma-operator.diffA-B.txt
│ │ │ ├── comma-operator.diffB-A.txt
│ │ │ ├── comma-operator.parseA.txt
│ │ │ ├── comma-operator.parseB.txt
│ │ │ ├── comment.A.js
│ │ │ ├── comment.B.js
│ │ │ ├── comment.diffA-B.txt
│ │ │ ├── comment.diffB-A.txt
│ │ │ ├── comment.parseA.txt
│ │ │ ├── comment.parseB.txt
│ │ │ ├── constructor-call.A.js
│ │ │ ├── constructor-call.B.js
│ │ │ ├── constructor-call.diffA-B.txt
│ │ │ ├── constructor-call.diffB-A.txt
│ │ │ ├── constructor-call.parseA.txt
│ │ │ ├── constructor-call.parseB.txt
│ │ │ ├── continue.A.js
│ │ │ ├── continue.B.js
│ │ │ ├── continue.diffA-B.txt
│ │ │ ├── continue.diffB-A.txt
│ │ │ ├── continue.parseA.txt
│ │ │ ├── continue.parseB.txt
│ │ │ ├── delete-operator.A.js
│ │ │ ├── delete-operator.B.js
│ │ │ ├── delete-operator.diffA-B.txt
│ │ │ ├── delete-operator.diffB-A.txt
│ │ │ ├── delete-operator.parseA.txt
│ │ │ ├── delete-operator.parseB.txt
│ │ │ ├── do-while-statement.A.js
│ │ │ ├── do-while-statement.B.js
│ │ │ ├── do-while-statement.diffA-B.txt
│ │ │ ├── do-while-statement.diffB-A.txt
│ │ │ ├── do-while-statement.parseA.txt
│ │ │ ├── do-while-statement.parseB.txt
│ │ │ ├── export.A.js
│ │ │ ├── export.B.js
│ │ │ ├── export.diffA-B.txt
│ │ │ ├── export.diffB-A.txt
│ │ │ ├── export.parseA.txt
│ │ │ ├── export.parseB.txt
│ │ │ ├── false.A.js
│ │ │ ├── false.B.js
│ │ │ ├── false.diffA-B.txt
│ │ │ ├── false.diffB-A.txt
│ │ │ ├── false.parseA.txt
│ │ │ ├── false.parseB.txt
│ │ │ ├── for-in-statement.A.js
│ │ │ ├── for-in-statement.B.js
│ │ │ ├── for-in-statement.diffA-B.txt
│ │ │ ├── for-in-statement.diffB-A.txt
│ │ │ ├── for-in-statement.parseA.txt
│ │ │ ├── for-in-statement.parseB.txt
│ │ │ ├── for-loop-with-in-statement.A.js
│ │ │ ├── for-loop-with-in-statement.B.js
│ │ │ ├── for-loop-with-in-statement.diffA-B.txt
│ │ │ ├── for-loop-with-in-statement.diffB-A.txt
│ │ │ ├── for-loop-with-in-statement.parseA.txt
│ │ │ ├── for-loop-with-in-statement.parseB.txt
│ │ │ ├── for-of-statement.A.js
│ │ │ ├── for-of-statement.B.js
│ │ │ ├── for-of-statement.diffA-B.txt
│ │ │ ├── for-of-statement.diffB-A.txt
│ │ │ ├── for-of-statement.parseA.txt
│ │ │ ├── for-of-statement.parseB.txt
│ │ │ ├── for-statement.A.js
│ │ │ ├── for-statement.B.js
│ │ │ ├── for-statement.diffA-B.txt
│ │ │ ├── for-statement.diffB-A.txt
│ │ │ ├── for-statement.parseA.txt
│ │ │ ├── for-statement.parseB.txt
│ │ │ ├── function-call-args.A.js
│ │ │ ├── function-call-args.B.js
│ │ │ ├── function-call-args.diffA-B.txt
│ │ │ ├── function-call-args.diffB-A.txt
│ │ │ ├── function-call-args.parseA.txt
│ │ │ ├── function-call-args.parseB.txt
│ │ │ ├── function-call.A.js
│ │ │ ├── function-call.B.js
│ │ │ ├── function-call.diffA-B.txt
│ │ │ ├── function-call.diffB-A.txt
│ │ │ ├── function-call.parseA.txt
│ │ │ ├── function-call.parseB.txt
│ │ │ ├── function.A.js
│ │ │ ├── function.B.js
│ │ │ ├── function.diffA-B.txt
│ │ │ ├── function.diffB-A.txt
│ │ │ ├── function.parseA.txt
│ │ │ ├── function.parseB.txt
│ │ │ ├── generator-function.A.js
│ │ │ ├── generator-function.B.js
│ │ │ ├── generator-function.diffA-B.txt
│ │ │ ├── generator-function.diffB-A.txt
│ │ │ ├── generator-function.parseA.txt
│ │ │ ├── generator-function.parseB.txt
│ │ │ ├── identifier.A.js
│ │ │ ├── identifier.B.js
│ │ │ ├── identifier.diffA-B.txt
│ │ │ ├── identifier.diffB-A.txt
│ │ │ ├── identifier.parseA.txt
│ │ │ ├── identifier.parseB.txt
│ │ │ ├── if-else.A.js
│ │ │ ├── if-else.B.js
│ │ │ ├── if-else.diffA-B.txt
│ │ │ ├── if-else.diffB-A.txt
│ │ │ ├── if-else.parseA.txt
│ │ │ ├── if-else.parseB.txt
│ │ │ ├── if.A.js
│ │ │ ├── if.B.js
│ │ │ ├── if.diffA-B.txt
│ │ │ ├── if.diffB-A.txt
│ │ │ ├── if.parseA.txt
│ │ │ ├── if.parseB.txt
│ │ │ ├── import.A.js
│ │ │ ├── import.B.js
│ │ │ ├── import.diffA-B.txt
│ │ │ ├── import.diffB-A.txt
│ │ │ ├── import.parseA.txt
│ │ │ ├── import.parseB.txt
│ │ │ ├── jsx.A.js
│ │ │ ├── jsx.B.js
│ │ │ ├── jsx.diffA-B.txt
│ │ │ ├── jsx.diffB-A.txt
│ │ │ ├── jsx.parseA.txt
│ │ │ ├── jsx.parseB.txt
│ │ │ ├── math-assignment-operator.A.js
│ │ │ ├── math-assignment-operator.B.js
│ │ │ ├── math-assignment-operator.diffA-B.txt
│ │ │ ├── math-assignment-operator.diffB-A.txt
│ │ │ ├── math-assignment-operator.parseA.txt
│ │ │ ├── math-assignment-operator.parseB.txt
│ │ │ ├── math-operator.A.js
│ │ │ ├── math-operator.B.js
│ │ │ ├── math-operator.diffA-B.txt
│ │ │ ├── math-operator.diffB-A.txt
│ │ │ ├── math-operator.parseA.txt
│ │ │ ├── math-operator.parseB.txt
│ │ │ ├── member-access-assignment.A.js
│ │ │ ├── member-access-assignment.B.js
│ │ │ ├── member-access-assignment.diffA-B.txt
│ │ │ ├── member-access-assignment.diffB-A.txt
│ │ │ ├── member-access-assignment.parseA.txt
│ │ │ ├── member-access-assignment.parseB.txt
│ │ │ ├── member-access.A.js
│ │ │ ├── member-access.B.js
│ │ │ ├── member-access.diffA-B.txt
│ │ │ ├── member-access.diffB-A.txt
│ │ │ ├── member-access.parseA.txt
│ │ │ ├── member-access.parseB.txt
│ │ │ ├── method-call.A.js
│ │ │ ├── method-call.B.js
│ │ │ ├── method-call.diffA-B.txt
│ │ │ ├── method-call.diffB-A.txt
│ │ │ ├── method-call.parseA.txt
│ │ │ ├── method-call.parseB.txt
│ │ │ ├── named-function.A.js
│ │ │ ├── named-function.B.js
│ │ │ ├── named-function.diffA-B.txt
│ │ │ ├── named-function.diffB-A.txt
│ │ │ ├── named-function.parseA.txt
│ │ │ ├── named-function.parseB.txt
│ │ │ ├── nested-do-while-in-function.A.js
│ │ │ ├── nested-do-while-in-function.B.js
│ │ │ ├── nested-do-while-in-function.diffA-B.txt
│ │ │ ├── nested-do-while-in-function.diffB-A.txt
│ │ │ ├── nested-do-while-in-function.parseA.txt
│ │ │ ├── nested-do-while-in-function.parseB.txt
│ │ │ ├── nested-functions.A.js
│ │ │ ├── nested-functions.B.js
│ │ │ ├── nested-functions.diffA-B.txt
│ │ │ ├── nested-functions.diffB-A.txt
│ │ │ ├── nested-functions.parseA.txt
│ │ │ ├── nested-functions.parseB.txt
│ │ │ ├── null.A.js
│ │ │ ├── null.B.js
│ │ │ ├── null.diffA-B.txt
│ │ │ ├── null.diffB-A.txt
│ │ │ ├── null.parseA.txt
│ │ │ ├── null.parseB.txt
│ │ │ ├── number.A.js
│ │ │ ├── number.B.js
│ │ │ ├── number.diffA-B.txt
│ │ │ ├── number.diffB-A.txt
│ │ │ ├── number.parseA.txt
│ │ │ ├── number.parseB.txt
│ │ │ ├── object.A.js
│ │ │ ├── object.B.js
│ │ │ ├── object.diffA-B.txt
│ │ │ ├── object.diffB-A.txt
│ │ │ ├── object.parseA.txt
│ │ │ ├── object.parseB.txt
│ │ │ ├── objects-with-methods.A.js
│ │ │ ├── objects-with-methods.B.js
│ │ │ ├── objects-with-methods.diffA-B.txt
│ │ │ ├── objects-with-methods.diffB-A.txt
│ │ │ ├── objects-with-methods.parseA.txt
│ │ │ ├── objects-with-methods.parseB.txt
│ │ │ ├── regex.A.js
│ │ │ ├── regex.B.js
│ │ │ ├── regex.diffA-B.txt
│ │ │ ├── regex.diffB-A.txt
│ │ │ ├── regex.parseA.txt
│ │ │ ├── regex.parseB.txt
│ │ │ ├── relational-operator.A.js
│ │ │ ├── relational-operator.B.js
│ │ │ ├── relational-operator.diffA-B.txt
│ │ │ ├── relational-operator.diffB-A.txt
│ │ │ ├── relational-operator.parseA.txt
│ │ │ ├── relational-operator.parseB.txt
│ │ │ ├── return-statement.A.js
│ │ │ ├── return-statement.B.js
│ │ │ ├── return-statement.diffA-B.txt
│ │ │ ├── return-statement.diffB-A.txt
│ │ │ ├── return-statement.parseA.txt
│ │ │ ├── return-statement.parseB.txt
│ │ │ ├── string.A.js
│ │ │ ├── string.B.js
│ │ │ ├── string.diffA-B.txt
│ │ │ ├── string.diffB-A.txt
│ │ │ ├── string.parseA.txt
│ │ │ ├── string.parseB.txt
│ │ │ ├── subscript-access-assignment.A.js
│ │ │ ├── subscript-access-assignment.B.js
│ │ │ ├── subscript-access-assignment.diffA-B.txt
│ │ │ ├── subscript-access-assignment.diffB-A.txt
│ │ │ ├── subscript-access-assignment.parseA.txt
│ │ │ ├── subscript-access-assignment.parseB.txt
│ │ │ ├── subscript-access-string.A.js
│ │ │ ├── subscript-access-string.B.js
│ │ │ ├── subscript-access-string.diffA-B.txt
│ │ │ ├── subscript-access-string.diffB-A.txt
│ │ │ ├── subscript-access-string.parseA.txt
│ │ │ ├── subscript-access-string.parseB.txt
│ │ │ ├── subscript-access-variable.A.js
│ │ │ ├── subscript-access-variable.B.js
│ │ │ ├── subscript-access-variable.diffA-B.txt
│ │ │ ├── subscript-access-variable.diffB-A.txt
│ │ │ ├── subscript-access-variable.parseA.txt
│ │ │ ├── subscript-access-variable.parseB.txt
│ │ │ ├── switch-statement.A.js
│ │ │ ├── switch-statement.B.js
│ │ │ ├── switch-statement.diffA-B.txt
│ │ │ ├── switch-statement.diffB-A.txt
│ │ │ ├── switch-statement.parseA.txt
│ │ │ ├── switch-statement.parseB.txt
│ │ │ ├── template-string.A.js
│ │ │ ├── template-string.B.js
│ │ │ ├── template-string.diffA-B.txt
│ │ │ ├── template-string.diffB-A.txt
│ │ │ ├── template-string.parseA.txt
│ │ │ ├── template-string.parseB.txt
│ │ │ ├── ternary.A.js
│ │ │ ├── ternary.B.js
│ │ │ ├── ternary.diffA-B.txt
│ │ │ ├── ternary.diffB-A.txt
│ │ │ ├── ternary.parseA.txt
│ │ │ ├── ternary.parseB.txt
│ │ │ ├── this-expression.A.js
│ │ │ ├── this-expression.B.js
│ │ │ ├── this-expression.diffA-B.txt
│ │ │ ├── this-expression.diffB-A.txt
│ │ │ ├── this-expression.parseA.txt
│ │ │ ├── this-expression.parseB.txt
│ │ │ ├── throw-statement.A.js
│ │ │ ├── throw-statement.B.js
│ │ │ ├── throw-statement.diffA-B.txt
│ │ │ ├── throw-statement.diffB-A.txt
│ │ │ ├── throw-statement.parseA.txt
│ │ │ ├── throw-statement.parseB.txt
│ │ │ ├── true.A.js
│ │ │ ├── true.B.js
│ │ │ ├── true.diffA-B.txt
│ │ │ ├── true.diffB-A.txt
│ │ │ ├── true.parseA.txt
│ │ │ ├── true.parseB.txt
│ │ │ ├── try-statement.A.js
│ │ │ ├── try-statement.B.js
│ │ │ ├── try-statement.diffA-B.txt
│ │ │ ├── try-statement.diffB-A.txt
│ │ │ ├── try-statement.parseA.txt
│ │ │ ├── try-statement.parseB.txt
│ │ │ ├── type-operator.A.js
│ │ │ ├── type-operator.B.js
│ │ │ ├── type-operator.diffA-B.txt
│ │ │ ├── type-operator.diffB-A.txt
│ │ │ ├── type-operator.parseA.txt
│ │ │ ├── type-operator.parseB.txt
│ │ │ ├── undefined.A.js
│ │ │ ├── undefined.B.js
│ │ │ ├── undefined.diffA-B.txt
│ │ │ ├── undefined.diffB-A.txt
│ │ │ ├── undefined.parseA.txt
│ │ │ ├── undefined.parseB.txt
│ │ │ ├── var-declaration.A.js
│ │ │ ├── var-declaration.B.js
│ │ │ ├── var-declaration.diffA-B.txt
│ │ │ ├── var-declaration.diffB-A.txt
│ │ │ ├── var-declaration.parseA.txt
│ │ │ ├── var-declaration.parseB.txt
│ │ │ ├── variable.A.js
│ │ │ ├── variable.B.js
│ │ │ ├── variable.diffA-B.txt
│ │ │ ├── variable.diffB-A.txt
│ │ │ ├── variable.parseA.txt
│ │ │ ├── variable.parseB.txt
│ │ │ ├── variadic-function-declarations.parseA.txt
│ │ │ ├── void-operator.A.js
│ │ │ ├── void-operator.B.js
│ │ │ ├── void-operator.diffA-B.txt
│ │ │ ├── void-operator.diffB-A.txt
│ │ │ ├── void-operator.parseA.txt
│ │ │ ├── void-operator.parseB.txt
│ │ │ ├── while-statement.A.js
│ │ │ ├── while-statement.B.js
│ │ │ ├── while-statement.diffA-B.txt
│ │ │ ├── while-statement.diffB-A.txt
│ │ │ ├── while-statement.parseA.txt
│ │ │ ├── while-statement.parseB.txt
│ │ │ ├── yield.A.js
│ │ │ ├── yield.B.js
│ │ │ ├── yield.diffA-B.txt
│ │ │ ├── yield.diffB-A.txt
│ │ │ ├── yield.parseA.txt
│ │ │ └── yield.parseB.txt
│ │ ├── reprinting/
│ │ │ └── map.json
│ │ ├── tags/
│ │ │ └── simple_function_with_docs.js
│ │ └── toc/
│ │ ├── duplicate-parent.A.js
│ │ ├── duplicate-parent.B.js
│ │ ├── erroneous-duplicate-method.A.js
│ │ ├── erroneous-duplicate-method.B.js
│ │ └── starts-with-newline.js
│ ├── json/
│ │ ├── corpus/
│ │ │ ├── array.A.json
│ │ │ ├── array.B.json
│ │ │ ├── array.parseA.txt
│ │ │ ├── array.parseB.txt
│ │ │ ├── boolean.A.json
│ │ │ ├── boolean.B.json
│ │ │ ├── boolean.parseA.txt
│ │ │ ├── boolean.parseB.txt
│ │ │ ├── hash.A.json
│ │ │ ├── hash.B.json
│ │ │ ├── hash.parseA.txt
│ │ │ ├── hash.parseB.txt
│ │ │ ├── null.A.json
│ │ │ ├── null.B.json
│ │ │ ├── null.parseA.txt
│ │ │ ├── null.parseB.txt
│ │ │ ├── number.A.json
│ │ │ ├── number.B.json
│ │ │ ├── number.parseA.txt
│ │ │ ├── number.parseB.txt
│ │ │ ├── string.A.json
│ │ │ ├── string.B.json
│ │ │ ├── string.parseA.txt
│ │ │ └── string.parseB.txt
│ │ └── rewriting/
│ │ ├── add_keys.json
│ │ └── add_keys_expected.json
│ ├── markdown/
│ │ ├── corpus/
│ │ │ └── example.A.md
│ │ └── toc/
│ │ ├── headings.A.md
│ │ └── headings.B.md
│ ├── php/
│ │ └── analysis/
│ │ ├── bar.php
│ │ ├── foo.php
│ │ ├── main.php
│ │ ├── main_once.php
│ │ └── namespaces.php
│ ├── python/
│ │ ├── analysis/
│ │ │ ├── a.py
│ │ │ ├── b/
│ │ │ │ ├── __init__.py
│ │ │ │ └── c.py
│ │ │ ├── c/
│ │ │ │ ├── __init__.py
│ │ │ │ └── utils.py
│ │ │ ├── main.py
│ │ │ ├── main1.py
│ │ │ ├── main2.py
│ │ │ ├── main3.py
│ │ │ ├── multiple_inheritance.py
│ │ │ └── subclass.py
│ │ ├── corpus/
│ │ │ ├── assert-statement.A.py
│ │ │ ├── assert-statement.B.py
│ │ │ ├── assert-statement.diffA-B.txt
│ │ │ ├── assert-statement.diffB-A.txt
│ │ │ ├── assert-statement.parseA.txt
│ │ │ ├── assert-statement.parseB.txt
│ │ │ ├── assignment.A.py
│ │ │ ├── assignment.B.py
│ │ │ ├── assignment.diffA-B.txt
│ │ │ ├── assignment.diffB-A.txt
│ │ │ ├── assignment.parseA.txt
│ │ │ ├── assignment.parseB.txt
│ │ │ ├── async-function-definition.A.py
│ │ │ ├── async-function-definition.B.py
│ │ │ ├── async-function-definition.diffA-B.txt
│ │ │ ├── async-function-definition.diffB-A.txt
│ │ │ ├── async-function-definition.parseA.txt
│ │ │ ├── async-function-definition.parseB.txt
│ │ │ ├── attribute.A.py
│ │ │ ├── attribute.B.py
│ │ │ ├── attribute.diffA-B.txt
│ │ │ ├── attribute.diffB-A.txt
│ │ │ ├── attribute.parseA.txt
│ │ │ ├── attribute.parseB.txt
│ │ │ ├── augmented-assignment.A.py
│ │ │ ├── augmented-assignment.B.py
│ │ │ ├── augmented-assignment.diffA-B.txt
│ │ │ ├── augmented-assignment.diffB-A.txt
│ │ │ ├── augmented-assignment.parseA.txt
│ │ │ ├── augmented-assignment.parseB.txt
│ │ │ ├── await.A.py
│ │ │ ├── await.B.py
│ │ │ ├── await.diffA-B.txt
│ │ │ ├── await.diffB-A.txt
│ │ │ ├── await.parseA.txt
│ │ │ ├── await.parseB.txt
│ │ │ ├── binary-operator.A.py
│ │ │ ├── binary-operator.B.py
│ │ │ ├── binary-operator.diffA-B.txt
│ │ │ ├── binary-operator.diffB-A.txt
│ │ │ ├── binary-operator.parseA.txt
│ │ │ ├── binary-operator.parseB.txt
│ │ │ ├── boolean-operator.A.py
│ │ │ ├── boolean-operator.B.py
│ │ │ ├── boolean-operator.diffA-B.txt
│ │ │ ├── boolean-operator.diffB-A.txt
│ │ │ ├── boolean-operator.parseA.txt
│ │ │ ├── boolean-operator.parseB.txt
│ │ │ ├── boolean.A.py
│ │ │ ├── boolean.B.py
│ │ │ ├── boolean.diffA-B.txt
│ │ │ ├── boolean.diffB-A.txt
│ │ │ ├── boolean.parseA.txt
│ │ │ ├── boolean.parseB.txt
│ │ │ ├── break-statement.A.py
│ │ │ ├── break-statement.B.py
│ │ │ ├── break-statement.diffA-B.txt
│ │ │ ├── break-statement.diffB-A.txt
│ │ │ ├── break-statement.parseA.txt
│ │ │ ├── break-statement.parseB.txt
│ │ │ ├── call.A.py
│ │ │ ├── call.B.py
│ │ │ ├── call.diffA-B.txt
│ │ │ ├── call.diffB-A.txt
│ │ │ ├── call.parseA.txt
│ │ │ ├── call.parseB.txt
│ │ │ ├── class-definition.A.py
│ │ │ ├── class-definition.B.py
│ │ │ ├── class-definition.diffA-B.txt
│ │ │ ├── class-definition.diffB-A.txt
│ │ │ ├── class-definition.parseA.txt
│ │ │ ├── class-definition.parseB.txt
│ │ │ ├── comment.A.py
│ │ │ ├── comment.B.py
│ │ │ ├── comment.diffA-B.txt
│ │ │ ├── comment.diffB-A.txt
│ │ │ ├── comment.parseA.txt
│ │ │ ├── comment.parseB.txt
│ │ │ ├── comparison-operator.A.py
│ │ │ ├── comparison-operator.B.py
│ │ │ ├── comparison-operator.diffA-B.txt
│ │ │ ├── comparison-operator.diffB-A.txt
│ │ │ ├── comparison-operator.parseA.txt
│ │ │ ├── comparison-operator.parseB.txt
│ │ │ ├── concatenated-string.A.py
│ │ │ ├── concatenated-string.B.py
│ │ │ ├── concatenated-string.diffA-B.txt
│ │ │ ├── concatenated-string.diffB-A.txt
│ │ │ ├── concatenated-string.parseA.txt
│ │ │ ├── concatenated-string.parseB.txt
│ │ │ ├── conditional-expression.A.py
│ │ │ ├── conditional-expression.B.py
│ │ │ ├── conditional-expression.diffA-B.txt
│ │ │ ├── conditional-expression.diffB-A.txt
│ │ │ ├── conditional-expression.parseA.txt
│ │ │ ├── conditional-expression.parseB.txt
│ │ │ ├── continue-statement.A.py
│ │ │ ├── continue-statement.B.py
│ │ │ ├── continue-statement.diffA-B.txt
│ │ │ ├── continue-statement.diffB-A.txt
│ │ │ ├── continue-statement.parseA.txt
│ │ │ ├── continue-statement.parseB.txt
│ │ │ ├── decorated-definition.A.py
│ │ │ ├── decorated-definition.B.py
│ │ │ ├── decorated-definition.diffA-B.txt
│ │ │ ├── decorated-definition.diffB-A.txt
│ │ │ ├── decorated-definition.parseA.txt
│ │ │ ├── decorated-definition.parseB.txt
│ │ │ ├── delete-statement.A.py
│ │ │ ├── delete-statement.B.py
│ │ │ ├── delete-statement.diffA-B.txt
│ │ │ ├── delete-statement.diffB-A.txt
│ │ │ ├── delete-statement.parseA.txt
│ │ │ ├── delete-statement.parseB.txt
│ │ │ ├── dictionary-comprehension.A.py
│ │ │ ├── dictionary-comprehension.B.py
│ │ │ ├── dictionary-comprehension.diffA-B.txt
│ │ │ ├── dictionary-comprehension.diffB-A.txt
│ │ │ ├── dictionary-comprehension.parseA.txt
│ │ │ ├── dictionary-comprehension.parseB.txt
│ │ │ ├── dictionary.A.py
│ │ │ ├── dictionary.B.py
│ │ │ ├── dictionary.diffA-B.txt
│ │ │ ├── dictionary.diffB-A.txt
│ │ │ ├── dictionary.parseA.txt
│ │ │ ├── dictionary.parseB.txt
│ │ │ ├── dotted-name.A.py
│ │ │ ├── dotted-name.B.py
│ │ │ ├── dotted-name.diffA-B.txt
│ │ │ ├── dotted-name.diffB-A.txt
│ │ │ ├── dotted-name.parseA.txt
│ │ │ ├── dotted-name.parseB.txt
│ │ │ ├── ellipsis.A.py
│ │ │ ├── ellipsis.B.py
│ │ │ ├── ellipsis.diffA-B.txt
│ │ │ ├── ellipsis.diffB-A.txt
│ │ │ ├── ellipsis.parseA.txt
│ │ │ ├── ellipsis.parseB.txt
│ │ │ ├── exec-statement.A.py
│ │ │ ├── exec-statement.B.py
│ │ │ ├── exec-statement.diffA-B.txt
│ │ │ ├── exec-statement.diffB-A.txt
│ │ │ ├── exec-statement.parseA.txt
│ │ │ ├── exec-statement.parseB.txt
│ │ │ ├── expression-statement.A.py
│ │ │ ├── expression-statement.B.py
│ │ │ ├── expression-statement.diffA-B.txt
│ │ │ ├── expression-statement.diffB-A.txt
│ │ │ ├── expression-statement.parseA.txt
│ │ │ ├── expression-statement.parseB.txt
│ │ │ ├── float.A.py
│ │ │ ├── float.B.py
│ │ │ ├── float.diffA-B.txt
│ │ │ ├── float.diffB-A.txt
│ │ │ ├── float.parseA.txt
│ │ │ ├── float.parseB.txt
│ │ │ ├── for-statement.A.py
│ │ │ ├── for-statement.B.py
│ │ │ ├── for-statement.diffA-B.txt
│ │ │ ├── for-statement.diffB-A.txt
│ │ │ ├── for-statement.parseA.txt
│ │ │ ├── for-statement.parseB.txt
│ │ │ ├── function-definition.A.py
│ │ │ ├── function-definition.B.py
│ │ │ ├── function-definition.diffA-B.txt
│ │ │ ├── function-definition.diffB-A.txt
│ │ │ ├── function-definition.parseA.txt
│ │ │ ├── function-definition.parseB.txt
│ │ │ ├── future_import_statement.A.py
│ │ │ ├── future_import_statement.B.py
│ │ │ ├── future_import_statement.diffA-B.txt
│ │ │ ├── future_import_statement.diffB-A.txt
│ │ │ ├── future_import_statement.parseA.txt
│ │ │ ├── future_import_statement.parseB.txt
│ │ │ ├── generator-expression.A.py
│ │ │ ├── generator-expression.B.py
│ │ │ ├── generator-expression.diffA-B.txt
│ │ │ ├── generator-expression.diffB-A.txt
│ │ │ ├── generator-expression.parseA.txt
│ │ │ ├── generator-expression.parseB.txt
│ │ │ ├── global-statement.A.py
│ │ │ ├── global-statement.B.py
│ │ │ ├── global-statement.diffA-B.txt
│ │ │ ├── global-statement.diffB-A.txt
│ │ │ ├── global-statement.parseA.txt
│ │ │ ├── global-statement.parseB.txt
│ │ │ ├── identifier.A.py
│ │ │ ├── identifier.B.py
│ │ │ ├── identifier.diffA-B.txt
│ │ │ ├── identifier.diffB-A.txt
│ │ │ ├── identifier.parseA.txt
│ │ │ ├── identifier.parseB.txt
│ │ │ ├── if-statement.A.py
│ │ │ ├── if-statement.B.py
│ │ │ ├── if-statement.diffA-B.txt
│ │ │ ├── if-statement.diffB-A.txt
│ │ │ ├── if-statement.parseA.txt
│ │ │ ├── if-statement.parseB.txt
│ │ │ ├── import-from-statement.A.py
│ │ │ ├── import-from-statement.B.py
│ │ │ ├── import-from-statement.diffA-B.txt
│ │ │ ├── import-from-statement.diffB-A.txt
│ │ │ ├── import-from-statement.parseA.txt
│ │ │ ├── import-from-statement.parseB.txt
│ │ │ ├── import-statement.A.py
│ │ │ ├── import-statement.B.py
│ │ │ ├── import-statement.diffA-B.txt
│ │ │ ├── import-statement.diffB-A.txt
│ │ │ ├── import-statement.parseA.txt
│ │ │ ├── import-statement.parseB.txt
│ │ │ ├── integer.A.py
│ │ │ ├── integer.B.py
│ │ │ ├── integer.diffA-B.txt
│ │ │ ├── integer.diffB-A.txt
│ │ │ ├── integer.parseA.txt
│ │ │ ├── integer.parseB.txt
│ │ │ ├── keyword-identifier.A.py
│ │ │ ├── keyword-identifier.B.py
│ │ │ ├── keyword-identifier.diffA-B.txt
│ │ │ ├── keyword-identifier.diffB-A.txt
│ │ │ ├── keyword-identifier.parseA.txt
│ │ │ ├── keyword-identifier.parseB.txt
│ │ │ ├── lambda.A.py
│ │ │ ├── lambda.B.py
│ │ │ ├── lambda.diffA-B.txt
│ │ │ ├── lambda.diffB-A.txt
│ │ │ ├── lambda.parseA.txt
│ │ │ ├── lambda.parseB.txt
│ │ │ ├── list-comprehension.A.py
│ │ │ ├── list-comprehension.B.py
│ │ │ ├── list-comprehension.diffA-B.txt
│ │ │ ├── list-comprehension.diffB-A.txt
│ │ │ ├── list-comprehension.parseA.txt
│ │ │ ├── list-comprehension.parseB.txt
│ │ │ ├── list.A.py
│ │ │ ├── list.B.py
│ │ │ ├── list.diffA-B.txt
│ │ │ ├── list.diffB-A.txt
│ │ │ ├── list.parseA.txt
│ │ │ ├── list.parseB.txt
│ │ │ ├── non-local-statement.A.py
│ │ │ ├── non-local-statement.B.py
│ │ │ ├── non-local-statement.diffA-B.txt
│ │ │ ├── non-local-statement.diffB-A.txt
│ │ │ ├── non-local-statement.parseA.txt
│ │ │ ├── non-local-statement.parseB.txt
│ │ │ ├── none.A.py
│ │ │ ├── none.B.py
│ │ │ ├── none.diffA-B.txt
│ │ │ ├── none.diffB-A.txt
│ │ │ ├── none.parseA.txt
│ │ │ ├── none.parseB.txt
│ │ │ ├── not.A.py
│ │ │ ├── not.B.py
│ │ │ ├── not.diffA-B.txt
│ │ │ ├── not.diffB-A.txt
│ │ │ ├── not.parseA.txt
│ │ │ ├── not.parseB.txt
│ │ │ ├── pass-statement.A.py
│ │ │ ├── pass-statement.B.py
│ │ │ ├── pass-statement.diffA-B.txt
│ │ │ ├── pass-statement.diffB-A.txt
│ │ │ ├── pass-statement.parseA.txt
│ │ │ ├── pass-statement.parseB.txt
│ │ │ ├── print-statement.A.py
│ │ │ ├── print-statement.B.py
│ │ │ ├── print-statement.diffA-B.txt
│ │ │ ├── print-statement.diffB-A.txt
│ │ │ ├── print-statement.parseA.txt
│ │ │ ├── print-statement.parseB.txt
│ │ │ ├── raise-statement.A.py
│ │ │ ├── raise-statement.B.py
│ │ │ ├── raise-statement.diffA-B.txt
│ │ │ ├── raise-statement.diffB-A.txt
│ │ │ ├── raise-statement.parseA.txt
│ │ │ ├── raise-statement.parseB.txt
│ │ │ ├── return-statement.A.py
│ │ │ ├── return-statement.B.py
│ │ │ ├── return-statement.diffA-B.txt
│ │ │ ├── return-statement.diffB-A.txt
│ │ │ ├── return-statement.parseA.txt
│ │ │ ├── return-statement.parseB.txt
│ │ │ ├── set-comprehension.A.py
│ │ │ ├── set-comprehension.B.py
│ │ │ ├── set-comprehension.diffA-B.txt
│ │ │ ├── set-comprehension.diffB-A.txt
│ │ │ ├── set-comprehension.parseA.txt
│ │ │ ├── set-comprehension.parseB.txt
│ │ │ ├── set.A.py
│ │ │ ├── set.B.py
│ │ │ ├── set.diffA-B.txt
│ │ │ ├── set.diffB-A.txt
│ │ │ ├── set.parseA.txt
│ │ │ ├── set.parseB.txt
│ │ │ ├── slice.A.py
│ │ │ ├── slice.B.py
│ │ │ ├── slice.diffA-B.txt
│ │ │ ├── slice.diffB-A.txt
│ │ │ ├── slice.parseA.txt
│ │ │ ├── slice.parseB.txt
│ │ │ ├── string.A.py
│ │ │ ├── string.B.py
│ │ │ ├── string.diffA-B.txt
│ │ │ ├── string.diffB-A.txt
│ │ │ ├── string.parseA.txt
│ │ │ ├── string.parseB.txt
│ │ │ ├── subscript.A.py
│ │ │ ├── subscript.B.py
│ │ │ ├── subscript.diffA-B.txt
│ │ │ ├── subscript.diffB-A.txt
│ │ │ ├── subscript.parseA.txt
│ │ │ ├── subscript.parseB.txt
│ │ │ ├── try-statement.A.py
│ │ │ ├── try-statement.B.py
│ │ │ ├── try-statement.diffA-B.txt
│ │ │ ├── try-statement.diffB-A.txt
│ │ │ ├── try-statement.parseA.txt
│ │ │ ├── try-statement.parseB.txt
│ │ │ ├── tuple.A.py
│ │ │ ├── tuple.B.py
│ │ │ ├── tuple.diffA-B.txt
│ │ │ ├── tuple.diffB-A.txt
│ │ │ ├── tuple.parseA.txt
│ │ │ ├── tuple.parseB.txt
│ │ │ ├── unary-operator.A.py
│ │ │ ├── unary-operator.B.py
│ │ │ ├── unary-operator.diffA-B.txt
│ │ │ ├── unary-operator.diffB-A.txt
│ │ │ ├── unary-operator.parseA.txt
│ │ │ ├── unary-operator.parseB.txt
│ │ │ ├── while-statement.A.py
│ │ │ ├── while-statement.B.py
│ │ │ ├── while-statement.diffA-B.txt
│ │ │ ├── while-statement.diffB-A.txt
│ │ │ ├── while-statement.parseA.txt
│ │ │ ├── while-statement.parseB.txt
│ │ │ ├── with-statement.A.py
│ │ │ ├── with-statement.B.py
│ │ │ ├── with-statement.diffA-B.txt
│ │ │ ├── with-statement.diffB-A.txt
│ │ │ ├── with-statement.parseA.txt
│ │ │ ├── with-statement.parseB.txt
│ │ │ ├── with.A.py
│ │ │ ├── with.B.py
│ │ │ ├── with.diffA-B.txt
│ │ │ ├── with.diffB-A.txt
│ │ │ ├── with.parseA.txt
│ │ │ ├── with.parseB.txt
│ │ │ ├── yield.A.py
│ │ │ ├── yield.B.py
│ │ │ ├── yield.diffA-B.txt
│ │ │ ├── yield.diffB-A.txt
│ │ │ ├── yield.parseA.txt
│ │ │ └── yield.parseB.txt
│ │ ├── graphing/
│ │ │ ├── conditional/
│ │ │ │ └── conditional.py
│ │ │ ├── simple/
│ │ │ │ └── simple.py
│ │ │ ├── typeerror/
│ │ │ │ └── typeerror.py
│ │ │ └── unbound/
│ │ │ └── unbound.py
│ │ ├── import-graph/
│ │ │ ├── main.json
│ │ │ └── main.py
│ │ ├── matching/
│ │ │ ├── docstrings.py
│ │ │ └── docstrings_nested.py
│ │ ├── reprinting/
│ │ │ ├── function.out.py
│ │ │ └── function.py
│ │ └── tags/
│ │ ├── class.py
│ │ ├── multiline.py
│ │ ├── simple_function_with_docs.py
│ │ └── simple_functions.py
│ ├── ruby/
│ │ ├── analysis/
│ │ │ ├── break.rb
│ │ │ ├── call.rb
│ │ │ ├── classes.rb
│ │ │ ├── early-return.rb
│ │ │ ├── foo.rb
│ │ │ ├── line.rb
│ │ │ ├── load-wrap.rb
│ │ │ ├── load.rb
│ │ │ ├── main.rb
│ │ │ ├── modules.rb
│ │ │ ├── next.rb
│ │ │ ├── preluded.rb
│ │ │ ├── puts.rb
│ │ │ ├── src/
│ │ │ │ ├── foo.rb
│ │ │ │ └── main.rb
│ │ │ └── subclass.rb
│ │ ├── corpus/
│ │ │ ├── alias.A.rb
│ │ │ ├── alias.parseA.txt
│ │ │ ├── and-or.A.rb
│ │ │ ├── and-or.B.rb
│ │ │ ├── and-or.diffA-B.txt
│ │ │ ├── and-or.diffB-A.txt
│ │ │ ├── and-or.parseA.txt
│ │ │ ├── and-or.parseB.txt
│ │ │ ├── array.A.rb
│ │ │ ├── array.B.rb
│ │ │ ├── array.diffA-B.txt
│ │ │ ├── array.diffB-A.txt
│ │ │ ├── array.parseA.txt
│ │ │ ├── array.parseB.txt
│ │ │ ├── assignment.A.rb
│ │ │ ├── assignment.B.rb
│ │ │ ├── assignment.diffA-B.txt
│ │ │ ├── assignment.diffB-A.txt
│ │ │ ├── assignment.parseA.txt
│ │ │ ├── assignment.parseB.txt
│ │ │ ├── begin-block.A.rb
│ │ │ ├── begin-block.B.rb
│ │ │ ├── begin-block.diffA-B.txt
│ │ │ ├── begin-block.diffB-A.txt
│ │ │ ├── begin-block.parseA.txt
│ │ │ ├── begin-block.parseB.txt
│ │ │ ├── begin.A.rb
│ │ │ ├── begin.B.rb
│ │ │ ├── begin.diffA-B.txt
│ │ │ ├── begin.diffB-A.txt
│ │ │ ├── begin.parseA.txt
│ │ │ ├── begin.parseB.txt
│ │ │ ├── binary.A.rb
│ │ │ ├── binary.parseA.txt
│ │ │ ├── bitwise-operator.A.rb
│ │ │ ├── bitwise-operator.B.rb
│ │ │ ├── bitwise-operator.diffA-B.txt
│ │ │ ├── bitwise-operator.diffB-A.txt
│ │ │ ├── bitwise-operator.parseA.txt
│ │ │ ├── bitwise-operator.parseB.txt
│ │ │ ├── boolean-operator.A.rb
│ │ │ ├── boolean-operator.B.rb
│ │ │ ├── boolean-operator.diffA-B.txt
│ │ │ ├── boolean-operator.diffB-A.txt
│ │ │ ├── boolean-operator.parseA.txt
│ │ │ ├── boolean-operator.parseB.txt
│ │ │ ├── break.A.rb
│ │ │ ├── break.B.rb
│ │ │ ├── break.diffA-B.txt
│ │ │ ├── break.diffB-A.txt
│ │ │ ├── break.parseA.txt
│ │ │ ├── break.parseB.txt
│ │ │ ├── calls.A.rb
│ │ │ ├── calls.parseA.txt
│ │ │ ├── chained-string.A.rb
│ │ │ ├── chained-string.parseA.txt
│ │ │ ├── class.A.rb
│ │ │ ├── class.B.rb
│ │ │ ├── class.diffA-B.txt
│ │ │ ├── class.diffB-A.txt
│ │ │ ├── class.parseA.txt
│ │ │ ├── class.parseB.txt
│ │ │ ├── comment.A.rb
│ │ │ ├── comment.B.rb
│ │ │ ├── comment.diffA-B.txt
│ │ │ ├── comment.diffB-A.txt
│ │ │ ├── comment.parseA.txt
│ │ │ ├── comment.parseB.txt
│ │ │ ├── comparision-operator.A.rb
│ │ │ ├── comparision-operator.B.rb
│ │ │ ├── comparision-operator.diffA-B.txt
│ │ │ ├── comparision-operator.diffB-A.txt
│ │ │ ├── comparision-operator.parseA.txt
│ │ │ ├── comparision-operator.parseB.txt
│ │ │ ├── conditional-assignment.A.rb
│ │ │ ├── conditional-assignment.B.rb
│ │ │ ├── conditional-assignment.diffA-B.txt
│ │ │ ├── conditional-assignment.diffB-A.txt
│ │ │ ├── conditional-assignment.parseA.txt
│ │ │ ├── conditional-assignment.parseB.txt
│ │ │ ├── delimiter.A.rb
│ │ │ ├── delimiter.B.rb
│ │ │ ├── delimiter.diffA-B.txt
│ │ │ ├── delimiter.diffB-A.txt
│ │ │ ├── delimiter.parseA.txt
│ │ │ ├── delimiter.parseB.txt
│ │ │ ├── element-reference.A.rb
│ │ │ ├── element-reference.B.rb
│ │ │ ├── element-reference.diffA-B.txt
│ │ │ ├── element-reference.diffB-A.txt
│ │ │ ├── element-reference.parseA.txt
│ │ │ ├── element-reference.parseB.txt
│ │ │ ├── else.A.rb
│ │ │ ├── else.B.rb
│ │ │ ├── else.diffA-B.txt
│ │ │ ├── else.diffB-A.txt
│ │ │ ├── else.parseA.txt
│ │ │ ├── else.parseB.txt
│ │ │ ├── elsif.A.rb
│ │ │ ├── elsif.B.rb
│ │ │ ├── elsif.diffA-B.txt
│ │ │ ├── elsif.diffB-A.txt
│ │ │ ├── elsif.parseA.txt
│ │ │ ├── elsif.parseB.txt
│ │ │ ├── empty-statement.A.rb
│ │ │ ├── empty-statement.parseA.txt
│ │ │ ├── end-block.A.rb
│ │ │ ├── end-block.B.rb
│ │ │ ├── end-block.diffA-B.txt
│ │ │ ├── end-block.diffB-A.txt
│ │ │ ├── end-block.parseA.txt
│ │ │ ├── end-block.parseB.txt
│ │ │ ├── ensure.A.rb
│ │ │ ├── ensure.B.rb
│ │ │ ├── ensure.diffA-B.txt
│ │ │ ├── ensure.diffB-A.txt
│ │ │ ├── ensure.parseA.txt
│ │ │ ├── ensure.parseB.txt
│ │ │ ├── for.A.rb
│ │ │ ├── for.B.rb
│ │ │ ├── for.diffA-B.txt
│ │ │ ├── for.diffB-A.txt
│ │ │ ├── for.parseA.txt
│ │ │ ├── for.parseB.txt
│ │ │ ├── hash.A.rb
│ │ │ ├── hash.B.rb
│ │ │ ├── hash.diffA-B.txt
│ │ │ ├── hash.diffB-A.txt
│ │ │ ├── hash.parseA.txt
│ │ │ ├── hash.parseB.txt
│ │ │ ├── heredoc.A.rb
│ │ │ ├── heredoc.B.rb
│ │ │ ├── heredoc.diffA-B.txt
│ │ │ ├── heredoc.diffB-A.txt
│ │ │ ├── heredoc.parseA.txt
│ │ │ ├── heredoc.parseB.txt
│ │ │ ├── if-unless-modifiers.A.rb
│ │ │ ├── if-unless-modifiers.B.rb
│ │ │ ├── if-unless-modifiers.diffA-B.txt
│ │ │ ├── if-unless-modifiers.diffB-A.txt
│ │ │ ├── if-unless-modifiers.parseA.txt
│ │ │ ├── if-unless-modifiers.parseB.txt
│ │ │ ├── if.A.rb
│ │ │ ├── if.B.rb
│ │ │ ├── if.diffA-B.txt
│ │ │ ├── if.diffB-A.txt
│ │ │ ├── if.parseA.txt
│ │ │ ├── if.parseB.txt
│ │ │ ├── interpolation.A.rb
│ │ │ ├── interpolation.B.rb
│ │ │ ├── interpolation.diffA-B.txt
│ │ │ ├── interpolation.diffB-A.txt
│ │ │ ├── interpolation.parseA.txt
│ │ │ ├── interpolation.parseB.txt
│ │ │ ├── keywords.A.rb
│ │ │ ├── keywords.parseA.txt
│ │ │ ├── lambda-dash-rocket.A.rb
│ │ │ ├── lambda-dash-rocket.B.rb
│ │ │ ├── lambda-dash-rocket.diffA-B.txt
│ │ │ ├── lambda-dash-rocket.diffB-A.txt
│ │ │ ├── lambda-dash-rocket.parseA.txt
│ │ │ ├── lambda-dash-rocket.parseB.txt
│ │ │ ├── lambda.A.rb
│ │ │ ├── lambda.B.rb
│ │ │ ├── lambda.diffA-B.txt
│ │ │ ├── lambda.diffB-A.txt
│ │ │ ├── lambda.parseA.txt
│ │ │ ├── lambda.parseB.txt
│ │ │ ├── literals.A.rb
│ │ │ ├── literals.parseA.txt
│ │ │ ├── math-assignment.A.rb
│ │ │ ├── math-assignment.B.rb
│ │ │ ├── math-assignment.diffA-B.txt
│ │ │ ├── math-assignment.diffB-A.txt
│ │ │ ├── math-assignment.parseA.txt
│ │ │ ├── math-assignment.parseB.txt
│ │ │ ├── method-calls-hash-args.A.rb
│ │ │ ├── method-calls-hash-args.B.rb
│ │ │ ├── method-calls-hash-args.diffA-B.txt
│ │ │ ├── method-calls-hash-args.diffB-A.txt
│ │ │ ├── method-calls-hash-args.parseA.txt
│ │ │ ├── method-calls-hash-args.parseB.txt
│ │ │ ├── method-calls-keyword-args.A.rb
│ │ │ ├── method-calls-keyword-args.B.rb
│ │ │ ├── method-calls-keyword-args.diffA-B.txt
│ │ │ ├── method-calls-keyword-args.diffB-A.txt
│ │ │ ├── method-calls-keyword-args.parseA.txt
│ │ │ ├── method-calls-keyword-args.parseB.txt
│ │ │ ├── method-calls.A.rb
│ │ │ ├── method-calls.B.rb
│ │ │ ├── method-calls.diffA-B.txt
│ │ │ ├── method-calls.diffB-A.txt
│ │ │ ├── method-calls.parseA.txt
│ │ │ ├── method-calls.parseB.txt
│ │ │ ├── method-declaration-keyword-param.A.rb
│ │ │ ├── method-declaration-keyword-param.B.rb
│ │ │ ├── method-declaration-keyword-param.diffA-B.txt
│ │ │ ├── method-declaration-keyword-param.diffB-A.txt
│ │ │ ├── method-declaration-keyword-param.parseA.txt
│ │ │ ├── method-declaration-keyword-param.parseB.txt
│ │ │ ├── method-declaration-param-default.A.rb
│ │ │ ├── method-declaration-param-default.B.rb
│ │ │ ├── method-declaration-param-default.diffA-B.txt
│ │ │ ├── method-declaration-param-default.diffB-A.txt
│ │ │ ├── method-declaration-param-default.parseA.txt
│ │ │ ├── method-declaration-param-default.parseB.txt
│ │ │ ├── method-declaration-params.A.rb
│ │ │ ├── method-declaration-params.B.rb
│ │ │ ├── method-declaration-params.diffA-B.txt
│ │ │ ├── method-declaration-params.diffB-A.txt
│ │ │ ├── method-declaration-params.parseA.txt
│ │ │ ├── method-declaration-params.parseB.txt
│ │ │ ├── method-declaration-required-keyword-param.A.rb
│ │ │ ├── method-declaration-required-keyword-param.B.rb
│ │ │ ├── method-declaration-required-keyword-param.diffA-B.txt
│ │ │ ├── method-declaration-required-keyword-param.diffB-A.txt
│ │ │ ├── method-declaration-required-keyword-param.parseA.txt
│ │ │ ├── method-declaration-required-keyword-param.parseB.txt
│ │ │ ├── method-declaration-unnamed-param.A.rb
│ │ │ ├── method-declaration-unnamed-param.B.rb
│ │ │ ├── method-declaration-unnamed-param.diffA-B.txt
│ │ │ ├── method-declaration-unnamed-param.diffB-A.txt
│ │ │ ├── method-declaration-unnamed-param.parseA.txt
│ │ │ ├── method-declaration-unnamed-param.parseB.txt
│ │ │ ├── method-declaration.A.rb
│ │ │ ├── method-declaration.B.rb
│ │ │ ├── method-declaration.diffA-B.txt
│ │ │ ├── method-declaration.diffB-A.txt
│ │ │ ├── method-declaration.parseA.txt
│ │ │ ├── method-declaration.parseB.txt
│ │ │ ├── method-invocation.A.rb
│ │ │ ├── method-invocation.B.rb
│ │ │ ├── method-invocation.diffA-B.txt
│ │ │ ├── method-invocation.diffB-A.txt
│ │ │ ├── method-invocation.parseA.txt
│ │ │ ├── method-invocation.parseB.txt
│ │ │ ├── methods.A.rb
│ │ │ ├── methods.parseA.txt
│ │ │ ├── misc.A.rb
│ │ │ ├── misc.parseA.txt
│ │ │ ├── module.A.rb
│ │ │ ├── module.B.rb
│ │ │ ├── module.diffA-B.txt
│ │ │ ├── module.diffB-A.txt
│ │ │ ├── module.parseA.txt
│ │ │ ├── module.parseB.txt
│ │ │ ├── multiple-assignments.A.rb
│ │ │ ├── multiple-assignments.B.rb
│ │ │ ├── multiple-assignments.diffA-B.txt
│ │ │ ├── multiple-assignments.diffB-A.txt
│ │ │ ├── multiple-assignments.parseA.txt
│ │ │ ├── multiple-assignments.parseB.txt
│ │ │ ├── next.A.rb
│ │ │ ├── next.parseA.txt
│ │ │ ├── number.A.rb
│ │ │ ├── number.B.rb
│ │ │ ├── number.diffA-B.txt
│ │ │ ├── number.diffB-A.txt
│ │ │ ├── number.parseA.txt
│ │ │ ├── number.parseB.txt
│ │ │ ├── percent-array.A.rb
│ │ │ ├── percent-array.B.rb
│ │ │ ├── percent-array.diffA-B.txt
│ │ │ ├── percent-array.diffB-A.txt
│ │ │ ├── percent-array.parseA.txt
│ │ │ ├── percent-array.parseB.txt
│ │ │ ├── pseudo-variables.A.rb
│ │ │ ├── pseudo-variables.B.rb
│ │ │ ├── pseudo-variables.diffA-B.txt
│ │ │ ├── pseudo-variables.diffB-A.txt
│ │ │ ├── pseudo-variables.parseA.txt
│ │ │ ├── pseudo-variables.parseB.txt
│ │ │ ├── regex.A.rb
│ │ │ ├── regex.B.rb
│ │ │ ├── regex.diffA-B.txt
│ │ │ ├── regex.diffB-A.txt
│ │ │ ├── regex.parseA.txt
│ │ │ ├── regex.parseB.txt
│ │ │ ├── relational-operator.A.rb
│ │ │ ├── relational-operator.B.rb
│ │ │ ├── relational-operator.diffA-B.txt
│ │ │ ├── relational-operator.diffB-A.txt
│ │ │ ├── relational-operator.parseA.txt
│ │ │ ├── relational-operator.parseB.txt
│ │ │ ├── require.A.rb
│ │ │ ├── require.B.rb
│ │ │ ├── require.diffA-B.txt
│ │ │ ├── require.diffB-A.txt
│ │ │ ├── require.parseA.txt
│ │ │ ├── require.parseB.txt
│ │ │ ├── rescue-empty.A.rb
│ │ │ ├── rescue-empty.B.rb
│ │ │ ├── rescue-empty.diffA-B.txt
│ │ │ ├── rescue-empty.diffB-A.txt
│ │ │ ├── rescue-empty.parseA.txt
│ │ │ ├── rescue-empty.parseB.txt
│ │ │ ├── rescue-last-ex.A.rb
│ │ │ ├── rescue-last-ex.B.rb
│ │ │ ├── rescue-last-ex.diffA-B.txt
│ │ │ ├── rescue-last-ex.diffB-A.txt
│ │ │ ├── rescue-last-ex.parseA.txt
│ │ │ ├── rescue-last-ex.parseB.txt
│ │ │ ├── rescue-modifier.A.rb
│ │ │ ├── rescue-modifier.B.rb
│ │ │ ├── rescue-modifier.diffA-B.txt
│ │ │ ├── rescue-modifier.diffB-A.txt
│ │ │ ├── rescue-modifier.parseA.txt
│ │ │ ├── rescue-modifier.parseB.txt
│ │ │ ├── rescue-modifier2.A.rb
│ │ │ ├── rescue-modifier2.B.rb
│ │ │ ├── rescue-modifier2.diffA-B.txt
│ │ │ ├── rescue-modifier2.diffB-A.txt
│ │ │ ├── rescue-modifier2.parseA.txt
│ │ │ ├── rescue-modifier2.parseB.txt
│ │ │ ├── rescue.A.rb
│ │ │ ├── rescue.B.rb
│ │ │ ├── rescue.diffA-B.txt
│ │ │ ├── rescue.diffB-A.txt
│ │ │ ├── rescue.parseA.txt
│ │ │ ├── rescue.parseB.txt
│ │ │ ├── return.A.rb
│ │ │ ├── return.B.rb
│ │ │ ├── return.diffA-B.txt
│ │ │ ├── return.diffB-A.txt
│ │ │ ├── return.parseA.txt
│ │ │ ├── return.parseB.txt
│ │ │ ├── singleton-class.A.rb
│ │ │ ├── singleton-class.parseA.txt
│ │ │ ├── string.A.rb
│ │ │ ├── string.B.rb
│ │ │ ├── string.diffA-B.txt
│ │ │ ├── string.diffB-A.txt
│ │ │ ├── string.parseA.txt
│ │ │ ├── string.parseB.txt
│ │ │ ├── subshell.A.rb
│ │ │ ├── subshell.B.rb
│ │ │ ├── subshell.diffA-B.txt
│ │ │ ├── subshell.diffB-A.txt
│ │ │ ├── subshell.parseA.txt
│ │ │ ├── subshell.parseB.txt
│ │ │ ├── symbol.A.rb
│ │ │ ├── symbol.B.rb
│ │ │ ├── symbol.diffA-B.txt
│ │ │ ├── symbol.diffB-A.txt
│ │ │ ├── symbol.parseA.txt
│ │ │ ├── symbol.parseB.txt
│ │ │ ├── ternary.A.rb
│ │ │ ├── ternary.B.rb
│ │ │ ├── ternary.diffA-B.txt
│ │ │ ├── ternary.diffB-A.txt
│ │ │ ├── ternary.parseA.txt
│ │ │ ├── ternary.parseB.txt
│ │ │ ├── unary.A.rb
│ │ │ ├── unary.parseA.txt
│ │ │ ├── undef.A.rb
│ │ │ ├── undef.parseA.txt
│ │ │ ├── unless.A.rb
│ │ │ ├── unless.B.rb
│ │ │ ├── unless.diffA-B.txt
│ │ │ ├── unless.diffB-A.txt
│ │ │ ├── unless.parseA.txt
│ │ │ ├── unless.parseB.txt
│ │ │ ├── until.A.rb
│ │ │ ├── until.B.rb
│ │ │ ├── until.diffA-B.txt
│ │ │ ├── until.diffB-A.txt
│ │ │ ├── until.parseA.txt
│ │ │ ├── until.parseB.txt
│ │ │ ├── when-else.A.rb
│ │ │ ├── when-else.B.rb
│ │ │ ├── when-else.diffA-B.txt
│ │ │ ├── when-else.diffB-A.txt
│ │ │ ├── when-else.parseA.txt
│ │ │ ├── when-else.parseB.txt
│ │ │ ├── when.A.rb
│ │ │ ├── when.B.rb
│ │ │ ├── when.diffA-B.txt
│ │ │ ├── when.diffB-A.txt
│ │ │ ├── when.parseA.txt
│ │ │ ├── when.parseB.txt
│ │ │ ├── while.A.rb
│ │ │ ├── while.B.rb
│ │ │ ├── while.diffA-B.txt
│ │ │ ├── while.diffB-A.txt
│ │ │ ├── while.parseA.txt
│ │ │ ├── while.parseB.txt
│ │ │ ├── yield.A.rb
│ │ │ ├── yield.B.rb
│ │ │ ├── yield.diffA-B.txt
│ │ │ ├── yield.diffB-A.txt
│ │ │ ├── yield.parseA.txt
│ │ │ └── yield.parseB.txt
│ │ ├── import-graph/
│ │ │ ├── app.json
│ │ │ └── app.rb
│ │ ├── reprinting/
│ │ │ ├── function.out.rb
│ │ │ ├── function.rb
│ │ │ └── infix.rb
│ │ ├── tags/
│ │ │ ├── class_module.rb
│ │ │ ├── simple_method.rb
│ │ │ ├── simple_method_with_docs.rb
│ │ │ └── unicode_identifiers.rb
│ │ └── toc/
│ │ ├── classes.A.rb
│ │ ├── classes.B.rb
│ │ ├── lambda.A.rb
│ │ ├── lambda.B.rb
│ │ ├── method-starts-with-two-identifiers.A.rb
│ │ ├── method-starts-with-two-identifiers.B.rb
│ │ ├── methods.A.rb
│ │ ├── methods.B.rb
│ │ ├── methods.X.rb
│ │ ├── unicode.A.rb
│ │ └── unicode.B.rb
│ ├── tsx/
│ │ └── corpus/
│ │ ├── jsx-elements.A.tsx
│ │ ├── jsx-elements.B.tsx
│ │ ├── jsx-elements.diffA-B.txt
│ │ ├── jsx-elements.diffB-A.txt
│ │ ├── jsx-elements.parseA.txt
│ │ └── jsx-elements.parseB.txt
│ └── typescript/
│ ├── analysis/
│ │ ├── .gitignore
│ │ ├── a.ts
│ │ ├── access_control/
│ │ │ ├── adder.ts
│ │ │ ├── private_field_definition.ts
│ │ │ ├── private_method.ts
│ │ │ └── private_static_field_definition.ts
│ │ ├── await.ts
│ │ ├── bad-export.ts
│ │ ├── band.ts
│ │ ├── baz.ts
│ │ ├── bor.ts
│ │ ├── bxor.ts
│ │ ├── class1.ts
│ │ ├── class2.ts
│ │ ├── complement.ts
│ │ ├── delete.ts
│ │ ├── early-return.ts
│ │ ├── foo/
│ │ │ └── b.ts
│ │ ├── foo.ts
│ │ ├── foo2.ts
│ │ ├── lshift.ts
│ │ ├── main.ts
│ │ ├── main1.ts
│ │ ├── main2.ts
│ │ ├── main3.ts
│ │ ├── main4.ts
│ │ ├── main5.ts
│ │ ├── main6.ts
│ │ ├── main7.ts
│ │ ├── pip.ts
│ │ ├── rshift.ts
│ │ ├── sequence-expression.ts
│ │ ├── unsignedrshift.ts
│ │ └── void.ts
│ ├── corpus/
│ │ ├── ambient-declarations.A.ts
│ │ ├── ambient-declarations.B.ts
│ │ ├── ambient-declarations.diffA-B.txt
│ │ ├── ambient-declarations.diffB-A.txt
│ │ ├── ambient-declarations.parseA.txt
│ │ ├── ambient-declarations.parseB.txt
│ │ ├── ambient-exports.A.ts
│ │ ├── ambient-exports.B.ts
│ │ ├── ambient-exports.diffA-B.txt
│ │ ├── ambient-exports.diffB-A.txt
│ │ ├── ambient-exports.parseA.txt
│ │ ├── ambient-exports.parseB.txt
│ │ ├── ambient-type-declarations.A.ts
│ │ ├── ambient-type-declarations.B.ts
│ │ ├── ambient-type-declarations.diffA-B.txt
│ │ ├── ambient-type-declarations.diffB-A.txt
│ │ ├── ambient-type-declarations.parseA.txt
│ │ ├── ambient-type-declarations.parseB.txt
│ │ ├── anonymous-function.A.ts
│ │ ├── anonymous-function.B.ts
│ │ ├── anonymous-function.diffA-B.txt
│ │ ├── anonymous-function.diffB-A.txt
│ │ ├── anonymous-function.parseA.txt
│ │ ├── anonymous-function.parseB.txt
│ │ ├── anonymous-parameterless-function.A.ts
│ │ ├── anonymous-parameterless-function.B.ts
│ │ ├── anonymous-parameterless-function.diffA-B.txt
│ │ ├── anonymous-parameterless-function.diffB-A.txt
│ │ ├── anonymous-parameterless-function.parseA.txt
│ │ ├── anonymous-parameterless-function.parseB.txt
│ │ ├── array-type.A.ts
│ │ ├── array-type.B.ts
│ │ ├── array-type.diffA-B.txt
│ │ ├── array-type.diffB-A.txt
│ │ ├── array-type.parseA.txt
│ │ ├── array-type.parseB.txt
│ │ ├── array.A.ts
│ │ ├── array.B.ts
│ │ ├── array.diffA-B.txt
│ │ ├── array.diffB-A.txt
│ │ ├── array.parseA.txt
│ │ ├── array.parseB.txt
│ │ ├── arrow-function.A.ts
│ │ ├── arrow-function.B.ts
│ │ ├── arrow-function.diffA-B.txt
│ │ ├── arrow-function.diffB-A.txt
│ │ ├── arrow-function.parseA.txt
│ │ ├── arrow-function.parseB.txt
│ │ ├── assignment-pattern.A.ts
│ │ ├── assignment-pattern.B.ts
│ │ ├── assignment-pattern.diffA-B.txt
│ │ ├── assignment-pattern.diffB-A.txt
│ │ ├── assignment-pattern.parseA.txt
│ │ ├── assignment-pattern.parseB.txt
│ │ ├── assignment.A.ts
│ │ ├── assignment.B.ts
│ │ ├── assignment.diffA-B.txt
│ │ ├── assignment.diffB-A.txt
│ │ ├── assignment.parseA.txt
│ │ ├── assignment.parseB.txt
│ │ ├── bitwise-operator.A.ts
│ │ ├── bitwise-operator.B.ts
│ │ ├── bitwise-operator.diffA-B.txt
│ │ ├── bitwise-operator.diffB-A.txt
│ │ ├── bitwise-operator.parseA.txt
│ │ ├── bitwise-operator.parseB.txt
│ │ ├── boolean-operator.A.ts
│ │ ├── boolean-operator.B.ts
│ │ ├── boolean-operator.diffA-B.txt
│ │ ├── boolean-operator.diffB-A.txt
│ │ ├── boolean-operator.parseA.txt
│ │ ├── boolean-operator.parseB.txt
│ │ ├── break.A.ts
│ │ ├── break.B.ts
│ │ ├── break.diffA-B.txt
│ │ ├── break.diffB-A.txt
│ │ ├── break.parseA.txt
│ │ ├── break.parseB.txt
│ │ ├── chained-callbacks.A.ts
│ │ ├── chained-callbacks.B.ts
│ │ ├── chained-callbacks.diffA-B.txt
│ │ ├── chained-callbacks.diffB-A.txt
│ │ ├── chained-callbacks.parseA.txt
│ │ ├── chained-callbacks.parseB.txt
│ │ ├── chained-property-access.A.ts
│ │ ├── chained-property-access.B.ts
│ │ ├── chained-property-access.diffA-B.txt
│ │ ├── chained-property-access.diffB-A.txt
│ │ ├── chained-property-access.parseA.txt
│ │ ├── chained-property-access.parseB.txt
│ │ ├── class.A.ts
│ │ ├── class.B.ts
│ │ ├── class.diffA-B.txt
│ │ ├── class.diffB-A.txt
│ │ ├── class.parseA.txt
│ │ ├── class.parseB.txt
│ │ ├── comma-operator.A.ts
│ │ ├── comma-operator.B.ts
│ │ ├── comma-operator.diffA-B.txt
│ │ ├── comma-operator.diffB-A.txt
│ │ ├── comma-operator.parseA.txt
│ │ ├── comma-operator.parseB.txt
│ │ ├── comment.A.ts
│ │ ├── comment.B.ts
│ │ ├── comment.diffA-B.txt
│ │ ├── comment.diffB-A.txt
│ │ ├── comment.parseA.txt
│ │ ├── comment.parseB.txt
│ │ ├── constructor-call.A.ts
│ │ ├── constructor-call.B.ts
│ │ ├── constructor-call.diffA-B.txt
│ │ ├── constructor-call.diffB-A.txt
│ │ ├── constructor-call.parseA.txt
│ │ ├── constructor-call.parseB.txt
│ │ ├── continue.A.ts
│ │ ├── continue.B.ts
│ │ ├── continue.diffA-B.txt
│ │ ├── continue.diffB-A.txt
│ │ ├── continue.parseA.txt
│ │ ├── continue.parseB.txt
│ │ ├── delete-operator.A.ts
│ │ ├── delete-operator.B.ts
│ │ ├── delete-operator.diffA-B.txt
│ │ ├── delete-operator.diffB-A.txt
│ │ ├── delete-operator.parseA.txt
│ │ ├── delete-operator.parseB.txt
│ │ ├── do-while-statement.A.ts
│ │ ├── do-while-statement.B.ts
│ │ ├── do-while-statement.diffA-B.txt
│ │ ├── do-while-statement.diffB-A.txt
│ │ ├── do-while-statement.parseA.txt
│ │ ├── do-while-statement.parseB.txt
│ │ ├── export-assignments.A.ts
│ │ ├── export-assignments.B.ts
│ │ ├── export-assignments.diffA-B.txt
│ │ ├── export-assignments.diffB-A.txt
│ │ ├── export-assignments.parseA.txt
│ │ ├── export-assignments.parseB.txt
│ │ ├── export.A.ts
│ │ ├── export.B.ts
│ │ ├── export.diffA-B.txt
│ │ ├── export.diffB-A.txt
│ │ ├── export.parseA.txt
│ │ ├── export.parseB.txt
│ │ ├── false.A.ts
│ │ ├── false.B.ts
│ │ ├── false.diffA-B.txt
│ │ ├── false.diffB-A.txt
│ │ ├── false.parseA.txt
│ │ ├── false.parseB.txt
│ │ ├── for-in-statement.A.ts
│ │ ├── for-in-statement.B.ts
│ │ ├── for-in-statement.diffA-B.txt
│ │ ├── for-in-statement.diffB-A.txt
│ │ ├── for-in-statement.parseA.txt
│ │ ├── for-in-statement.parseB.txt
│ │ ├── for-loop-with-in-statement.A.ts
│ │ ├── for-loop-with-in-statement.B.ts
│ │ ├── for-loop-with-in-statement.diffA-B.txt
│ │ ├── for-loop-with-in-statement.diffB-A.txt
│ │ ├── for-loop-with-in-statement.parseA.txt
│ │ ├── for-loop-with-in-statement.parseB.txt
│ │ ├── for-of-statement.A.ts
│ │ ├── for-of-statement.B.ts
│ │ ├── for-of-statement.diffA-B.txt
│ │ ├── for-of-statement.diffB-A.txt
│ │ ├── for-of-statement.parseA.txt
│ │ ├── for-of-statement.parseB.txt
│ │ ├── for-statement.A.ts
│ │ ├── for-statement.B.ts
│ │ ├── for-statement.diffA-B.txt
│ │ ├── for-statement.diffB-A.txt
│ │ ├── for-statement.parseA.txt
│ │ ├── for-statement.parseB.txt
│ │ ├── function-call-args.A.ts
│ │ ├── function-call-args.B.ts
│ │ ├── function-call-args.diffA-B.txt
│ │ ├── function-call-args.diffB-A.txt
│ │ ├── function-call-args.parseA.txt
│ │ ├── function-call-args.parseB.txt
│ │ ├── function-call.A.ts
│ │ ├── function-call.B.ts
│ │ ├── function-call.diffA-B.txt
│ │ ├── function-call.diffB-A.txt
│ │ ├── function-call.parseA.txt
│ │ ├── function-call.parseB.txt
│ │ ├── function-type.A.ts
│ │ ├── function-type.B.ts
│ │ ├── function-type.diffA-B.txt
│ │ ├── function-type.diffB-A.txt
│ │ ├── function-type.parseA.txt
│ │ ├── function-type.parseB.txt
│ │ ├── function.A.ts
│ │ ├── function.B.ts
│ │ ├── function.diffA-B.txt
│ │ ├── function.diffB-A.txt
│ │ ├── function.parseA.txt
│ │ ├── function.parseB.txt
│ │ ├── generator-function.A.ts
│ │ ├── generator-function.B.ts
│ │ ├── generator-function.diffA-B.txt
│ │ ├── generator-function.diffB-A.txt
│ │ ├── generator-function.parseA.txt
│ │ ├── generator-function.parseB.txt
│ │ ├── identifier.A.ts
│ │ ├── identifier.B.ts
│ │ ├── identifier.diffA-B.txt
│ │ ├── identifier.diffB-A.txt
│ │ ├── identifier.parseA.txt
│ │ ├── identifier.parseB.txt
│ │ ├── if-else.A.ts
│ │ ├── if-else.B.ts
│ │ ├── if-else.diffA-B.txt
│ │ ├── if-else.diffB-A.txt
│ │ ├── if-else.parseA.txt
│ │ ├── if-else.parseB.txt
│ │ ├── if.A.ts
│ │ ├── if.B.ts
│ │ ├── if.diffA-B.txt
│ │ ├── if.diffB-A.txt
│ │ ├── if.parseA.txt
│ │ ├── if.parseB.txt
│ │ ├── import.A.ts
│ │ ├── import.B.ts
│ │ ├── import.diffA-B.txt
│ │ ├── import.diffB-A.txt
│ │ ├── import.parseA.txt
│ │ ├── import.parseB.txt
│ │ ├── interface.A.ts
│ │ ├── interface.B.ts
│ │ ├── interface.diffA-B.txt
│ │ ├── interface.diffB-A.txt
│ │ ├── interface.parseA.txt
│ │ ├── interface.parseB.txt
│ │ ├── intersection-type.A.ts
│ │ ├── intersection-type.B.ts
│ │ ├── intersection-type.diffA-B.txt
│ │ ├── intersection-type.diffB-A.txt
│ │ ├── intersection-type.parseA.txt
│ │ ├── intersection-type.parseB.txt
│ │ ├── math-assignment-operator.A.ts
│ │ ├── math-assignment-operator.B.ts
│ │ ├── math-assignment-operator.diffA-B.txt
│ │ ├── math-assignment-operator.diffB-A.txt
│ │ ├── math-assignment-operator.parseA.txt
│ │ ├── math-assignment-operator.parseB.txt
│ │ ├── math-operator.A.ts
│ │ ├── math-operator.B.ts
│ │ ├── math-operator.diffA-B.txt
│ │ ├── math-operator.diffB-A.txt
│ │ ├── math-operator.parseA.txt
│ │ ├── math-operator.parseB.txt
│ │ ├── member-access-assignment.A.ts
│ │ ├── member-access-assignment.B.ts
│ │ ├── member-access-assignment.diffA-B.txt
│ │ ├── member-access-assignment.diffB-A.txt
│ │ ├── member-access-assignment.parseA.txt
│ │ ├── member-access-assignment.parseB.txt
│ │ ├── member-access.A.ts
│ │ ├── member-access.B.ts
│ │ ├── member-access.diffA-B.txt
│ │ ├── member-access.diffB-A.txt
│ │ ├── member-access.parseA.txt
│ │ ├── member-access.parseB.txt
│ │ ├── method-call.A.ts
│ │ ├── method-call.B.ts
│ │ ├── method-call.diffA-B.txt
│ │ ├── method-call.diffB-A.txt
│ │ ├── method-call.parseA.txt
│ │ ├── method-call.parseB.txt
│ │ ├── method-definition.A.ts
│ │ ├── method-definition.B.ts
│ │ ├── method-definition.diffA-B.txt
│ │ ├── method-definition.diffB-A.txt
│ │ ├── method-definition.parseA.txt
│ │ ├── method-definition.parseB.txt
│ │ ├── module-declarations.A.ts
│ │ ├── module-declarations.B.ts
│ │ ├── module-declarations.diffA-B.txt
│ │ ├── module-declarations.diffB-A.txt
│ │ ├── module-declarations.parseA.txt
│ │ ├── module-declarations.parseB.txt
│ │ ├── named-function.A.ts
│ │ ├── named-function.B.ts
│ │ ├── named-function.diffA-B.txt
│ │ ├── named-function.diffB-A.txt
│ │ ├── named-function.parseA.txt
│ │ ├── named-function.parseB.txt
│ │ ├── nested-do-while-in-function.A.ts
│ │ ├── nested-do-while-in-function.B.ts
│ │ ├── nested-do-while-in-function.diffA-B.txt
│ │ ├── nested-do-while-in-function.diffB-A.txt
│ │ ├── nested-do-while-in-function.parseA.txt
│ │ ├── nested-do-while-in-function.parseB.txt
│ │ ├── nested-functions.A.ts
│ │ ├── nested-functions.B.ts
│ │ ├── nested-functions.diffA-B.txt
│ │ ├── nested-functions.diffB-A.txt
│ │ ├── nested-functions.parseA.txt
│ │ ├── nested-functions.parseB.txt
│ │ ├── null.A.ts
│ │ ├── null.B.ts
│ │ ├── null.diffA-B.txt
│ │ ├── null.diffB-A.txt
│ │ ├── null.parseA.txt
│ │ ├── null.parseB.txt
│ │ ├── number.A.ts
│ │ ├── number.B.ts
│ │ ├── number.diffA-B.txt
│ │ ├── number.diffB-A.txt
│ │ ├── number.parseA.txt
│ │ ├── number.parseB.txt
│ │ ├── object.A.ts
│ │ ├── object.B.ts
│ │ ├── object.diffA-B.txt
│ │ ├── object.diffB-A.txt
│ │ ├── object.parseA.txt
│ │ ├── object.parseB.txt
│ │ ├── objects-with-methods.A.ts
│ │ ├── objects-with-methods.B.ts
│ │ ├── objects-with-methods.diffA-B.txt
│ │ ├── objects-with-methods.diffB-A.txt
│ │ ├── objects-with-methods.parseA.txt
│ │ ├── objects-with-methods.parseB.txt
│ │ ├── public-field-definition.A.ts
│ │ ├── public-field-definition.B.ts
│ │ ├── public-field-definition.diffA-B.txt
│ │ ├── public-field-definition.diffB-A.txt
│ │ ├── public-field-definition.parseA.txt
│ │ ├── public-field-definition.parseB.txt
│ │ ├── regex.A.ts
│ │ ├── regex.B.ts
│ │ ├── regex.diffA-B.txt
│ │ ├── regex.diffB-A.txt
│ │ ├── regex.parseA.txt
│ │ ├── regex.parseB.txt
│ │ ├── relational-operator.A.ts
│ │ ├── relational-operator.B.ts
│ │ ├── relational-operator.diffA-B.txt
│ │ ├── relational-operator.diffB-A.txt
│ │ ├── relational-operator.parseA.txt
│ │ ├── relational-operator.parseB.txt
│ │ ├── return-statement.A.ts
│ │ ├── return-statement.B.ts
│ │ ├── return-statement.diffA-B.txt
│ │ ├── return-statement.diffB-A.txt
│ │ ├── return-statement.parseA.txt
│ │ ├── return-statement.parseB.txt
│ │ ├── string.A.ts
│ │ ├── string.B.ts
│ │ ├── string.diffA-B.txt
│ │ ├── string.diffB-A.txt
│ │ ├── string.parseA.txt
│ │ ├── string.parseB.txt
│ │ ├── subscript-access-assignment.A.ts
│ │ ├── subscript-access-assignment.B.ts
│ │ ├── subscript-access-assignment.diffA-B.txt
│ │ ├── subscript-access-assignment.diffB-A.txt
│ │ ├── subscript-access-assignment.parseA.txt
│ │ ├── subscript-access-assignment.parseB.txt
│ │ ├── subscript-access-string.A.ts
│ │ ├── subscript-access-string.B.ts
│ │ ├── subscript-access-string.diffA-B.txt
│ │ ├── subscript-access-string.diffB-A.txt
│ │ ├── subscript-access-string.parseA.txt
│ │ ├── subscript-access-string.parseB.txt
│ │ ├── subscript-access-variable.A.ts
│ │ ├── subscript-access-variable.B.ts
│ │ ├── subscript-access-variable.diffA-B.txt
│ │ ├── subscript-access-variable.diffB-A.txt
│ │ ├── subscript-access-variable.parseA.txt
│ │ ├── subscript-access-variable.parseB.txt
│ │ ├── switch-statement.A.ts
│ │ ├── switch-statement.B.ts
│ │ ├── switch-statement.diffA-B.txt
│ │ ├── switch-statement.diffB-A.txt
│ │ ├── switch-statement.parseA.txt
│ │ ├── switch-statement.parseB.txt
│ │ ├── template-string.A.ts
│ │ ├── template-string.B.ts
│ │ ├── template-string.diffA-B.txt
│ │ ├── template-string.diffB-A.txt
│ │ ├── template-string.parseA.txt
│ │ ├── template-string.parseB.txt
│ │ ├── ternary.A.ts
│ │ ├── ternary.B.ts
│ │ ├── ternary.diffA-B.txt
│ │ ├── ternary.diffB-A.txt
│ │ ├── ternary.parseA.txt
│ │ ├── ternary.parseB.txt
│ │ ├── this-expression.A.ts
│ │ ├── this-expression.B.ts
│ │ ├── this-expression.diffA-B.txt
│ │ ├── this-expression.diffB-A.txt
│ │ ├── this-expression.parseA.txt
│ │ ├── this-expression.parseB.txt
│ │ ├── throw-statement.A.ts
│ │ ├── throw-statement.B.ts
│ │ ├── throw-statement.diffA-B.txt
│ │ ├── throw-statement.diffB-A.txt
│ │ ├── throw-statement.parseA.txt
│ │ ├── throw-statement.parseB.txt
│ │ ├── true.A.ts
│ │ ├── true.B.ts
│ │ ├── true.diffA-B.txt
│ │ ├── true.diffB-A.txt
│ │ ├── true.parseA.txt
│ │ ├── true.parseB.txt
│ │ ├── try-statement.A.ts
│ │ ├── try-statement.B.ts
│ │ ├── try-statement.diffA-B.txt
│ │ ├── try-statement.diffB-A.txt
│ │ ├── try-statement.parseA.txt
│ │ ├── try-statement.parseB.txt
│ │ ├── tuple-type.A.ts
│ │ ├── tuple-type.B.ts
│ │ ├── tuple-type.diffA-B.txt
│ │ ├── tuple-type.diffB-A.txt
│ │ ├── tuple-type.parseA.txt
│ │ ├── tuple-type.parseB.txt
│ │ ├── type-assertions.A.ts
│ │ ├── type-assertions.B.ts
│ │ ├── type-assertions.diffA-B.txt
│ │ ├── type-assertions.diffB-A.txt
│ │ ├── type-assertions.parseA.txt
│ │ ├── type-assertions.parseB.txt
│ │ ├── type-operator.A.ts
│ │ ├── type-operator.B.ts
│ │ ├── type-operator.diffA-B.txt
│ │ ├── type-operator.diffB-A.txt
│ │ ├── type-operator.parseA.txt
│ │ ├── type-operator.parseB.txt
│ │ ├── typeof-types.A.ts
│ │ ├── typeof-types.B.ts
│ │ ├── typeof-types.diffA-B.txt
│ │ ├── typeof-types.diffB-A.txt
│ │ ├── typeof-types.parseA.txt
│ │ ├── typeof-types.parseB.txt
│ │ ├── undefined.A.ts
│ │ ├── undefined.B.ts
│ │ ├── undefined.diffA-B.txt
│ │ ├── undefined.diffB-A.txt
│ │ ├── undefined.parseA.txt
│ │ ├── undefined.parseB.txt
│ │ ├── union-type.A.ts
│ │ ├── union-type.B.ts
│ │ ├── union-type.diffA-B.txt
│ │ ├── union-type.diffB-A.txt
│ │ ├── union-type.parseA.txt
│ │ ├── union-type.parseB.txt
│ │ ├── var-declaration.A.ts
│ │ ├── var-declaration.B.ts
│ │ ├── var-declaration.diffA-B.txt
│ │ ├── var-declaration.diffB-A.txt
│ │ ├── var-declaration.parseA.txt
│ │ ├── var-declaration.parseB.txt
│ │ ├── variable.A.ts
│ │ ├── variable.B.ts
│ │ ├── variable.diffA-B.txt
│ │ ├── variable.diffB-A.txt
│ │ ├── variable.parseA.txt
│ │ ├── variable.parseB.txt
│ │ ├── void-operator.A.ts
│ │ ├── void-operator.B.ts
│ │ ├── void-operator.diffA-B.txt
│ │ ├── void-operator.diffB-A.txt
│ │ ├── void-operator.parseA.txt
│ │ ├── void-operator.parseB.txt
│ │ ├── while-statement.A.ts
│ │ ├── while-statement.B.ts
│ │ ├── while-statement.diffA-B.txt
│ │ ├── while-statement.diffB-A.txt
│ │ ├── while-statement.parseA.txt
│ │ ├── while-statement.parseB.txt
│ │ ├── yield.A.ts
│ │ ├── yield.B.ts
│ │ ├── yield.diffA-B.txt
│ │ ├── yield.diffB-A.txt
│ │ ├── yield.parseA.txt
│ │ └── yield.parseB.txt
│ ├── import-graph/
│ │ ├── app.json
│ │ └── app.ts
│ └── tags/
│ ├── class.ts
│ └── module.ts
├── semantic-analysis/
│ ├── .ghci.repl
│ ├── .gitignore
│ ├── BUILD.bazel
│ ├── LICENSE
│ ├── README.md
│ ├── Setup.hs
│ ├── cabal.project
│ ├── hie.yaml
│ ├── python.tsg
│ ├── script/
│ │ ├── ghci-flags
│ │ └── repl
│ ├── semantic-analysis.cabal
│ └── src/
│ └── Analysis/
│ ├── Analysis/
│ │ ├── Concrete.hs
│ │ ├── DeadCode.hs
│ │ ├── Exception.hs
│ │ └── Typecheck.hs
│ ├── Blob.hs
│ ├── Carrier/
│ │ ├── Env/
│ │ │ ├── Monovariant.hs
│ │ │ └── Precise.hs
│ │ ├── Fail/
│ │ │ └── WithLoc.hs
│ │ ├── Statement/
│ │ │ └── State.hs
│ │ └── Store/
│ │ ├── Monovariant.hs
│ │ └── Precise.hs
│ ├── Data/
│ │ └── Snoc.hs
│ ├── Effect/
│ │ ├── Domain.hs
│ │ ├── Env.hs
│ │ ├── Statement.hs
│ │ └── Store.hs
│ ├── File.hs
│ ├── FlowInsensitive.hs
│ ├── Functor/
│ │ └── Named.hs
│ ├── Module.hs
│ ├── Name.hs
│ ├── Project.hs
│ ├── Reference.hs
│ ├── Syntax/
│ │ └── Python.hs
│ ├── Syntax.hs
│ └── VM.hs
├── semantic-ast/
│ ├── BUILD.bazel
│ ├── CHANGELOG.md
│ ├── LICENSE
│ ├── README.md
│ ├── Setup.hs
│ ├── app/
│ │ └── Main.hs
│ ├── semantic-ast.cabal
│ └── src/
│ ├── AST/
│ │ ├── Deserialize.hs
│ │ ├── Element.hs
│ │ ├── GenerateSyntax.hs
│ │ ├── Grammar/
│ │ │ ├── Examples.hs
│ │ │ └── TH.hs
│ │ ├── Marshal/
│ │ │ └── JSON.hs
│ │ ├── Parse.hs
│ │ ├── TestHelpers.hs
│ │ ├── Token.hs
│ │ ├── Traversable1/
│ │ │ └── Class.hs
│ │ ├── Traversable1.hs
│ │ └── Unmarshal.hs
│ └── System/
│ └── Path/
│ └── Fixture.hs
├── semantic-codeql/
│ ├── BUILD.bazel
│ ├── LICENSE
│ ├── README.md
│ ├── Setup.hs
│ ├── semantic-codeql.cabal
│ ├── src/
│ │ └── Language/
│ │ ├── CodeQL/
│ │ │ ├── AST.hs
│ │ │ ├── Grammar.hs
│ │ │ └── Tags.hs
│ │ └── CodeQL.hs
│ └── test/
│ └── PreciseTest.hs
├── semantic-go/
│ ├── BUILD.bazel
│ ├── LICENSE
│ ├── README.md
│ ├── Setup.hs
│ ├── semantic-go.cabal
│ ├── src/
│ │ └── Language/
│ │ ├── Go/
│ │ │ ├── AST.hs
│ │ │ ├── Grammar.hs
│ │ │ └── Tags.hs
│ │ └── Go.hs
│ └── test/
│ └── PreciseTest.hs
├── semantic-java/
│ ├── BUILD.bazel
│ ├── LICENSE
│ ├── README.md
│ ├── Setup.hs
│ ├── semantic-java.cabal
│ ├── src/
│ │ └── Language/
│ │ ├── Java/
│ │ │ ├── AST.hs
│ │ │ ├── Grammar.hs
│ │ │ └── Tags.hs
│ │ └── Java.hs
│ └── test/
│ └── PreciseTest.hs
├── semantic-json/
│ ├── BUILD.bazel
│ ├── LICENSE
│ ├── README.md
│ ├── Setup.hs
│ ├── semantic-json.cabal
│ ├── src/
│ │ └── Language/
│ │ ├── JSON/
│ │ │ ├── AST.hs
│ │ │ └── Grammar.hs
│ │ └── JSON.hs
│ └── test/
│ └── PreciseTest.hs
├── semantic-parse/
│ ├── BUILD.bazel
│ ├── CHANGELOG.md
│ ├── LICENSE
│ ├── README.md
│ ├── Setup.hs
│ ├── app/
│ │ └── Main.hs
│ └── semantic-parse.cabal
├── semantic-php/
│ ├── BUILD.bazel
│ ├── CHANGELOG.md
│ ├── LICENSE
│ ├── README.md
│ ├── Setup.hs
│ ├── semantic-php.cabal
│ └── src/
│ └── Language/
│ ├── PHP/
│ │ ├── AST.hs
│ │ ├── Grammar.hs
│ │ └── Tags.hs
│ └── PHP.hs
├── semantic-proto/
│ ├── BUILD.bazel
│ ├── LICENSE
│ ├── README.md
│ ├── Setup.hs
│ ├── semantic-proto.cabal
│ └── src/
│ └── Proto/
│ ├── Semantic.hs
│ ├── Semantic_Fields.hs
│ └── Semantic_JSON.hs
├── semantic-python/
│ ├── BUILD.bazel
│ ├── LICENSE
│ ├── README.md
│ ├── Setup.hs
│ ├── bench/
│ │ └── Bench.hs
│ ├── semantic-python.cabal
│ ├── src/
│ │ ├── Language/
│ │ │ ├── Python/
│ │ │ │ ├── AST.hs
│ │ │ │ ├── Core.hs
│ │ │ │ ├── Failure.hs
│ │ │ │ ├── Grammar.hs
│ │ │ │ ├── Patterns.hs
│ │ │ │ ├── ScopeGraph.hs
│ │ │ │ └── Tags.hs
│ │ │ └── Python.hs
│ │ └── Prelude.score
│ ├── test/
│ │ ├── CoreTest.hs
│ │ ├── Directive.hs
│ │ ├── Instances.hs
│ │ ├── PreciseTest.hs
│ │ └── fixtures/
│ │ ├── 1-01-empty-module.py
│ │ ├── 1-02-pass-statement.py
│ │ ├── 1-03-empty-tuple.py
│ │ ├── 1-04-toplevel-assignment.py
│ │ ├── 1-05-exec-statement-fails.py
│ │ ├── 2-01-return-statement.py
│ │ ├── 2-02-return-doesnt-translate.py
│ │ ├── 2-03-return-in-if-statement.py
│ │ ├── 2-04-multiple-assign.py
│ │ ├── 2-05-function-call.py
│ │ ├── 2-06-nested-function-definition.py
│ │ ├── 2-07-closure-over-scope.py
│ │ ├── 2-08-function-decorator.py
│ │ ├── 3-01-empty-class-definition.py
│ │ ├── 3-02-defining-instance-method.py
│ │ ├── 3-03-functions-know-their-own-names.py
│ │ ├── 4-01-lambda-literals.py
│ │ ├── 4-02-nonetype.py
│ │ ├── 4-03-not-expression.py
│ │ ├── 5-01-simple-reference.py
│ │ ├── 5-02-simple-function.py
│ │ ├── 5-03-function-argument.py
│ │ └── cheese/
│ │ ├── 6-01-imports.py
│ │ ├── 6-01-qualified-imports.py
│ │ └── ints.py
│ └── test-graphing/
│ └── GraphTest.hs
├── semantic-ruby/
│ ├── BUILD.bazel
│ ├── LICENSE
│ ├── README.md
│ ├── Setup.hs
│ ├── app/
│ │ └── Main.hs
│ ├── bench/
│ │ ├── Main.hs
│ │ └── Parsing.hs
│ ├── semantic-ruby.cabal
│ ├── src/
│ │ └── Language/
│ │ ├── Ruby/
│ │ │ ├── AST.hs
│ │ │ ├── Grammar.hs
│ │ │ └── Tags.hs
│ │ └── Ruby.hs
│ └── test/
│ └── PreciseTest.hs
├── semantic-rust/
│ ├── BUILD.bazel
│ ├── LICENSE
│ ├── README.md
│ ├── Setup.hs
│ ├── semantic-rust.cabal
│ ├── src/
│ │ └── Language/
│ │ ├── Rust/
│ │ │ ├── AST.hs
│ │ │ ├── Grammar.hs
│ │ │ └── Tags.hs
│ │ └── Rust.hs
│ └── test/
│ └── Test.hs
├── semantic-scope-graph/
│ ├── BUILD.bazel
│ ├── CHANGELOG.md
│ ├── LICENSE
│ ├── README.md
│ ├── Setup.hs
│ ├── semantic-scope-graph.cabal
│ └── src/
│ ├── Control/
│ │ ├── Carrier/
│ │ │ └── Sketch/
│ │ │ └── ScopeGraph.hs
│ │ └── Effect/
│ │ ├── ScopeGraph/
│ │ │ └── Properties/
│ │ │ ├── Declaration.hs
│ │ │ ├── Function.hs
│ │ │ └── Reference.hs
│ │ └── ScopeGraph.hs
│ ├── Data/
│ │ ├── Hole.hs
│ │ ├── Module.hs
│ │ └── ScopeGraph.hs
│ └── Scope/
│ ├── Graph/
│ │ ├── AdjacencyList.hs
│ │ └── Convert.hs
│ ├── Info.hs
│ ├── Path.hs
│ ├── Reference.hs
│ ├── Scope.hs
│ └── Types.hs
├── semantic-source/
│ ├── BUILD.bazel
│ ├── CHANGELOG.md
│ ├── LICENSE
│ ├── README.md
│ ├── Setup.hs
│ ├── cabal.project
│ ├── cabal.project.ci
│ ├── semantic-source.cabal
│ ├── src/
│ │ └── Source/
│ │ ├── Language.hs
│ │ ├── Loc.hs
│ │ ├── Range.hs
│ │ ├── Source.hs
│ │ └── Span.hs
│ └── test/
│ ├── Range/
│ │ └── Test.hs
│ ├── Source/
│ │ └── Test.hs
│ └── Test.hs
├── semantic-tags/
│ ├── BUILD.bazel
│ ├── LICENSE
│ ├── README.md
│ ├── Setup.hs
│ ├── semantic-tags.cabal
│ ├── src/
│ │ └── Tags/
│ │ ├── Tag.hs
│ │ └── Tagging/
│ │ └── Precise.hs
│ └── test/
│ └── Test.hs
├── semantic-tsx/
│ ├── BUILD.bazel
│ ├── LICENSE
│ ├── README.md
│ ├── Setup.hs
│ ├── semantic-tsx.cabal
│ ├── src/
│ │ └── Language/
│ │ ├── TSX/
│ │ │ ├── AST.hs
│ │ │ ├── Grammar.hs
│ │ │ └── Tags.hs
│ │ └── TSX.hs
│ └── test/
│ └── PreciseTest.hs
├── semantic-typescript/
│ ├── BUILD.bazel
│ ├── LICENSE
│ ├── README.md
│ ├── Setup.hs
│ ├── semantic-typescript.cabal
│ ├── src/
│ │ └── Language/
│ │ ├── TypeScript/
│ │ │ ├── AST.hs
│ │ │ ├── Grammar.hs
│ │ │ └── Tags.hs
│ │ └── TypeScript.hs
│ └── test/
│ └── PreciseTest.hs
├── stack-snapshot.yaml
└── stackage_snapshot.json
================================================
FILE CONTENTS
================================================
================================================
FILE: .bazelignore
================================================
semantic/dist-newstyle
semantic-analysis/dist-newstyle
semantic-ast/dist-newstyle
semantic-codeql/dist-newstyle
semantic-go/dist-newstyle
semantic-java/dist-newstyle
semantic-json/dist-newstyle
semantic-parse/dist-newstyle
semantic-proto/dist-newstyle
semantic-python/dist-newstyle
semantic-ruby/dist-newstyle
semantic-scope-graph/dist-newstyle
semantic-source/dist-newstyle
semantic-tags/dist-newstyle
semantic-tsx/dist-newstyle
semantic-typescript/dist-newstyle
dist-newstyle
tmp
================================================
FILE: .bazelrc
================================================
build:ci --loading_phase_threads=1
build:ci --jobs=2
build:ci --verbose_failures
common:ci --color=no
test:ci --test_output=errors
build --disk_cache=.bazel-cache/bazel-disk
build --repository_cache=.bazel-cache/bazel-repo
build --color=yes
build --jobs=8
build --compilation_mode=fastbuild
# test environment does not propagate locales by default
# some tests reads files written in UTF8, we need to propagate the correct
# environment variables, such as LOCALE_ARCHIVE
# We also need to setup an utf8 locale
test --test_env=LANG=en_US.utf8 --test_env=LOCALE_ARCHIVE
test --test_output=errors
test --compilation_mode=fastbuild
try-import .bazelrc.local
================================================
FILE: .dockerignore
================================================
Dockerfile
/.licenses
/.git
.ghci
.ghci_history
.ghc.environment.x86_64-darwin-8.6.5
*.yaml
*.md
/bin
/dist
/dist-newstyle
/notices
/docs
/tmp
/semantic-source
/bench
/script
/test
================================================
FILE: .ghci.repl
================================================
-- GHCI settings for script/repl.
-- These live here instead of script/repl for ease of commenting.
-- These live here instead of .ghci so cabal repl remains unaffected.
-- These live here instead of script/ghci-flags so ghcide remains unaffected.
-- Basic verbosity
:set -v1
-- Compile to object code
:set -fwrite-interface -fobject-code
-- Bonus: silence “add these modules to your .cabal file” warnings for files we :load
:set -Wno-missing-home-modules
-- Warnings for code written in the repl
:seti -Weverything
:seti -Wno-all-missed-specialisations
:seti -Wno-implicit-prelude
:seti -Wno-missed-specialisations
:seti -Wno-missing-import-lists
:seti -Wno-missing-local-signatures
:seti -Wno-monomorphism-restriction
:seti -Wno-name-shadowing
:seti -Wno-safe
:seti -Wno-unsafe
:seti -Wno-star-is-type
-- 8.8+
:seti -Wno-missing-deriving-strategies
-- 8.10+
:seti -Wno-missing-safe-haskell-mode
:seti -Wno-prepositive-qualified-module
-- Turn on some language extensions you use a lot
:seti -XFlexibleContexts -XOverloadedStrings -XTypeApplications
-- Break on errors
:seti -fbreak-on-error
-- Automatically show the code around breakpoints
:set stop :list
-- Use a cyan lambda as the prompt
:set prompt "\ESC[1;36m\STXλ \ESC[m\STX"
-- Better errors
:set -ferror-spans -freverse-errors -fprint-expanded-synonyms
-- Better typed holes
:set -funclutter-valid-hole-fits -fabstract-refinement-hole-fits -frefinement-level-hole-fits=2
-- We have this one on in the project but not in the REPL to reduce noise
:seti -Wno-type-defaults
:set -Wno-unused-packages
================================================
FILE: .ghci.sample
================================================
-- Consider copying this to your ~/.ghc/ghci.conf file:
-- Pretty-printing
:set -package-id prtty-smpl-3.1.1.0-c89f0500
:set -interactive-print Text.Pretty.Simple.pPrint
-- Turn on some language extensions you use a lot
:seti -XFlexibleContexts -XOverloadedStrings -XTypeApplications
-- Break on errors
:seti -fbreak-on-error
-- Automatically show the code around breakpoints
:set stop :list
-- Use a cyan lambda as the prompt
:set prompt "\ESC[1;36m\STXλ \ESC[m\STX"
-- Better errors
:set -ferror-spans -freverse-errors -fprint-expanded-synonyms
-- Path-local ghci history
:set -flocal-ghci-history
-- Better typed holes
:set -funclutter-valid-hole-fits -fabstract-refinement-hole-fits -frefinement-level-hole-fits=2
================================================
FILE: .gitattributes
================================================
.licenses linguist-vendored
test/fixtures linguist-vendored
test/repos linguist-vendored
vendor linguist-vendored
*.protobuf.bin binary
================================================
FILE: .github/workflows/bazel.yml.disabled
================================================
name: Bazel CI
on:
# Trigger the workflow on push or pull request,
# but only for the master branch
push:
branches:
- master
pull_request: {}
jobs:
build:
name: Bazel
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
if: github.event.action == 'opened' || github.event.action == 'synchronize' || github.event.ref == 'refs/heads/master'
- uses: actions/cache@v2
id: caching-stage
name: Cache Bazel artifacts
with:
path: |
.bazel-cache
bin
key: ${{ runner.os }}-bazel-${{ github.run_id }}
restore-keys: |
${{ runner.os }}-bazel-
- name: Download/cache bazel version
if: steps.caching-stage.outputs.cache-hit != 'true'
run: |
if [ ! -f bin/bazel ]; then
curl -LO "https://github.com/bazelbuild/bazel/releases/download/3.1.0/bazel-3.1.0-linux-x86_64"
mv bazel-3.1.0-linux-x86_64 "bin/bazel"
chmod +x "bin/bazel"
fi
- name: Build & test
run: |
bin/bazel clean
bin/bazel test --config=ci --test_tag_filters=language-test //...
bin/bazel test --config=ci //semantic-source //semantic:spec
================================================
FILE: .github/workflows/haskell.yml
================================================
name: Haskell CI
on:
# Trigger the workflow on push or pull request,
# but only for the master branch
push:
branches:
- master
pull_request:
jobs:
build:
name: ghc ${{ matrix.ghc }}
runs-on: ubuntu-latest
strategy:
matrix:
ghc: ["8.10", "9.2"]
steps:
- uses: actions/checkout@v2
if: github.event.action == 'opened' || github.event.action == 'synchronize' || github.event.ref == 'refs/heads/master'
- uses: haskell/actions/setup@v1
name: Setup Haskell
with:
ghc-version: ${{ matrix.ghc }}
- uses: actions/cache@v1
id: cache-cabal
name: Cache Cabal artifacts
with:
path: dist-cache
key: ${{ runner.os }}-${{ matrix.ghc }}-${{ matrix.cabal }}-cabal-cache-${{ hashFiles('**/*.cabal') }}
restore-keys: |
${{ runner.os }}-${{ matrix.ghc }}-${{ matrix.cabal }}-cabal-cache-
${{ runner.os }}-${{ matrix.ghc }}-${{ matrix.cabal }}-
${{ runner.os }}-${{ matrix.ghc }}-
${{ runner.os }}-
- name: Get cabal-cache
run: |
curl -L https://github.com/haskell-works/cabal-cache/releases/download/v1.0.1.8/cabal-cache_x86_64_linux.tar.gz > ./cc.tar.gz
tar -xvf ./cc.tar.gz
- name: Configure project
run: |
cabal v2-update
cabal v2-configure --project-file=cabal.project.ci --disable-optimization --enable-tests --write-ghc-environment-files=always -j2
cd semantic-source && cabal v2-configure --project-file=cabal.project.ci --disable-optimization --enable-tests --write-ghc-environment-files=always -j2
- name: Restore from cache
run: ./cabal-cache sync-from-archive --threads=2 --archive-uri=dist-cache || true
- name: Build & test
run: |
cabal v2-build --project-file=cabal.project.ci semantic:exe:semantic
cabal v2-run --project-file=cabal.project.ci semantic:test
cabal v2-build --project-file=cabal.project.ci semantic-analysis
cabal v2-run --project-file=cabal.project.ci semantic-codeql:test
cabal v2-run --project-file=cabal.project.ci semantic-go:test
cabal v2-run --project-file=cabal.project.ci semantic-java:test
cabal v2-run --project-file=cabal.project.ci semantic-json:test
cabal v2-run --project-file=cabal.project.ci semantic-python:test
# cabal v2-run --project-file=cabal.project.ci semantic-python:test:compiling
# cabal v2-run --project-file=cabal.project.ci semantic-python:test:graphing
cabal v2-run --project-file=cabal.project.ci semantic-ruby:test
cabal v2-run --project-file=cabal.project.ci semantic-tags:test
cabal v2-run --project-file=cabal.project.ci semantic-tsx:test
cabal v2-run --project-file=cabal.project.ci semantic-typescript:test
cd semantic-source && cabal v2-run --project-file=cabal.project.ci semantic-source:test
- name: Write out cache
run: ./cabal-cache sync-to-archive --threads=2 --archive-uri=dist-cache
================================================
FILE: .gitignore
================================================
.DS_Store
.docsets
.stack-work
.stack-work-profiling
stack.yaml
stack.yaml.lock
profiles
/tags
cabal.project.local*
dist
dist-newstyle
dist-repl
.ghci
.ghc.environment.*
.ghci_history
tmp/
/bin/
/bazel-*
/.bazel-cache
/src/Semantic/Version.hs.bak
/semanticd/test/current
/semanticd/test/rover-example-config/semantic.log
/test/fixtures/*/examples
*.hp
*.prof
*.pyc
/test.*
/*.html
.bundle/
.licenses/bin
.licenses/vendor/gems
.licenses/log/
codex.tags
================================================
FILE: .gitmodules
================================================
================================================
FILE: .hlint.yaml
================================================
# HLint configuration file
# https://github.com/ndmitchell/hlint
- arguments: [--color=auto, -XStrictData]
# Blacklist some functions by default.
- functions:
- {name: unsafePerformIO, within: [Data.Scientific.Exts.attemptUnsafeArithmetic]}
- {name: unsafeCoerce, within: []}
- {name: head, within: []}
- {name: tail, within: []}
- {name: init, within: []}
- {name: last, within: []}
- {name: fromJust, within: []}
- {name: decodeUtf8, within: [], message: "Use decodeUtf8' or decodeUtf8With lenientDecode"}
# Replace a $ b $ c with a . b $ c
- group: {name: dollar, enabled: true}
# Generalise map to fmap, ++ to <>
- group: {name: generalise, enabled: true}
# Change the severity of the default group to warning
- warn: {group: {name: default}}
# Ignore the highly noisy module export list hint
- ignore: {name: Use explicit module export list}
# Ignore some builtin hints
- ignore: {name: Use mappend}
- ignore: {name: Redundant do}
- ignore: {name: Use lambda-case} # TODO: investigate whether cost-center analysis is better with lambda-case than it was
- ignore: {name: Use fmap} # Ignored because map has better type inference.
# Change the severity of hints we don’t want to fail CI for
- suggest: {name: Eta reduce}
# While I think DerivingStrategies is good, it's too noisy to suggest by default
- ignore:
name: Use DerivingStrategies
# Ignore eta reduce in the assignment modules
- ignore:
name: Eta reduce
within:
- Language.Go.Assignment
- Language.Python.Assignment
- Language.Ruby.Assignment
- ignore: {name: Use ., within: [Analysis.Abstract.Graph.graphingModules, Semantic.Distribute]}
- ignore:
within:
- Proto.Semantic
- Proto.Semantic_Fields
- Proto.Semantic_JSON
- ignore:
name: Reduce duplication
within:
- Semantic.Util
- Language.Ruby.Tags
# hlint has issues with QuantifiedConstraints (see https://github.com/ndmitchell/hlint/issues/759)
# Once the above is fixed, we can drop this error.
- ignore: { name: Parse error }
# hlint is too paranoid about NonEmpty functions (https://github.com/ndmitchell/hlint/issues/787)
- ignore:
name: Avoid restricted function
within:
- Language.Python.Syntax
- Data.Syntax.Expression
# Our customized warnings
# AMP fallout
- warning: {lhs: mapM, rhs: traverse, name: Generalize mapM}
- warning: {lhs: mapM_, rhs: traverse_, name: Generalize mapM_}
- warning: {lhs: forM, rhs: for, name: Generalize forM}
- warning: {lhs: forM_, rhs: for_, name: Generalize forM_}
- warning: {lhs: sequence, rhs: sequenceA, name: Generalize sequence}
- warning: {lhs: sequence_, rhs: sequenceA_, name: Generalize sequence_}
- warning: {lhs: return, rhs: pure, name: Avoid return}
# Terms
- warning: {lhs: termFAnnotation . unTerm, rhs: termAnnotation, name: Use termAnnotation}
- warning: {lhs: termFOut . unTerm, rhs: termOut, name: Use termOut}
- warning: {lhs: project . termOut, rhs: projectTerm, name: Use projectTerm}
# Conveniences
- warning: {lhs: maybe a pure, rhs: maybeM a, name: Use maybeM}
- warning: {lhs: either (const a) id, rhs: fromRight a, name: use fromRight}
- warning: {lhs: either id (const a), rhs: fromLeft a, name: use fromLeft}
# Applicative style
- warning: {lhs: f <$> pure a <*> b, rhs: f a <$> b, name: Avoid redundant pure}
- warning: {lhs: f <$> pure a <* b, rhs: f a <$ b, name: Avoid redundant pure}
================================================
FILE: .hspec
================================================
--depth=1000
================================================
FILE: .licenses/semantic/cabal/MonadRandom.txt
================================================
---
type: cabal
name: MonadRandom
version: 0.5.1.1
summary: Random-number generation monad.
homepage:
license: bsd-3-clause
---
Copyright (c) 2016, Brent Yorgey
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of Brent Yorgey nor the names of other
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Previous versions of this package were distributed under the simple
permissive license used on the Haskell Wiki; see OLD-LICENSE for
details.
================================================
FILE: .licenses/semantic/cabal/QuickCheck.txt
================================================
---
type: cabal
name: QuickCheck
version: 2.12.6.1
summary: Automatic testing of Haskell programs
homepage: https://github.com/nick8325/quickcheck
license: bsd-3-clause
---
(The following is the 3-clause BSD license.)
Copyright (c) 2000-2018, Koen Claessen
Copyright (c) 2006-2008, Björn Bringert
Copyright (c) 2009-2018, Nick Smallbone
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the names of the copyright owners nor the names of the
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/StateVar.txt
================================================
---
type: cabal
name: StateVar
version: 1.1.1.1
summary: State variables
homepage: https://github.com/haskell-opengl/StateVar
license: bsd-3-clause
---
Copyright (c) 2014-2015, Edward Kmett
Copyright (c) 2009-2018, Sven Panne
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the author nor the names of its contributors may be
used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/adjunctions.txt
================================================
---
type: cabal
name: adjunctions
version: '4.4'
summary: Adjunctions and representable functors
homepage: https://github.com/ekmett/adjunctions/
license: bsd-2-clause
---
Copyright 2011-2014 Edward Kmett
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/aeson-pretty.txt
================================================
---
type: cabal
name: aeson-pretty
version: 0.8.7
summary: JSON pretty-printing library and command-line tool.
homepage: https://github.com/informatikr/aeson-pretty
license: bsd-3-clause
---
Copyright (c)2011, Falko Peters
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of Falko Peters nor the names of other
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/aeson.txt
================================================
---
type: cabal
name: aeson
version: 1.4.2.0
summary: Fast JSON parsing and encoding
homepage: https://github.com/bos/aeson
license: bsd-3-clause
---
Copyright (c) 2011, MailRank, Inc.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the author nor the names of his contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND ANY EXPRESS
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/algebraic-graphs.txt
================================================
---
type: cabal
name: algebraic-graphs
version: '0.3'
summary: A library for algebraic graph construction and transformation
homepage: https://github.com/snowleopard/alga
license: mit
---
MIT License
Copyright (c) 2016-2018 Andrey Mokhov
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: .licenses/semantic/cabal/ansi-terminal.txt
================================================
---
type: cabal
name: ansi-terminal
version: 0.8.2
summary: Simple ANSI terminal support, with Windows compatibility
homepage: https://github.com/feuerbach/ansi-terminal
license: bsd-3-clause
---
Copyright (c) 2008, Maximilian Bolingbroke
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted
provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of
conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of
conditions and the following disclaimer in the documentation and/or other materials
provided with the distribution.
* Neither the name of Maximilian Bolingbroke nor the names of other contributors may be used to
endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/ansi-wl-pprint.txt
================================================
---
type: cabal
name: ansi-wl-pprint
version: 0.6.8.2
summary: The Wadler/Leijen Pretty Printer for colored ANSI terminal output
homepage: https://github.com/ekmett/ansi-wl-pprint
license: bsd-2-clause
---
Copyright 2008, Daan Leijen and Max Bolingbroke. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
distribution.
This software is provided by the copyright holders "as is" and any
express or implied warranties, including, but not limited to, the
implied warranties of merchantability and fitness for a particular
purpose are disclaimed. In no event shall the copyright holders be
liable for any direct, indirect, incidental, special, exemplary, or
consequential damages (including, but not limited to, procurement of
substitute goods or services; loss of use, data, or profits; or
business interruption) however caused and on any theory of liability,
whether in contract, strict liability, or tort (including negligence
or otherwise) arising in any way out of the use of this software, even
if advised of the possibility of such damage.
================================================
FILE: .licenses/semantic/cabal/array.txt
================================================
---
type: cabal
name: array
version: 0.5.3.0
summary: Mutable and immutable arrays
homepage:
license: bsd-3-clause
---
This library (libraries/base) is derived from code from several
sources:
* Code from the GHC project which is largely (c) The University of
Glasgow, and distributable under a BSD-style license (see below),
* Code from the Haskell 98 Report which is (c) Simon Peyton Jones
and freely redistributable (but see the full license for
restrictions).
* Code from the Haskell Foreign Function Interface specification,
which is (c) Manuel M. T. Chakravarty and freely redistributable
(but see the full license for restrictions).
The full text of these licenses is reproduced below. All of the
licenses are BSD-style or compatible.
-----------------------------------------------------------------------------
The Glasgow Haskell Compiler License
Copyright 2004, The University Court of the University of Glasgow.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
- Neither name of the University nor the names of its contributors may be
used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF
GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW OR THE CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.
-----------------------------------------------------------------------------
Code derived from the document "Report on the Programming Language
Haskell 98", is distributed under the following license:
Copyright (c) 2002 Simon Peyton Jones
The authors intend this Report to belong to the entire Haskell
community, and so we grant permission to copy and distribute it for
any purpose, provided that it is reproduced in its entirety,
including this Notice. Modified versions of this Report may also be
copied and distributed for any purpose, provided that the modified
version is clearly presented as such, and that it does not claim to
be a definition of the Haskell 98 Language.
-----------------------------------------------------------------------------
Code derived from the document "The Haskell 98 Foreign Function
Interface, An Addendum to the Haskell 98 Report" is distributed under
the following license:
Copyright (c) 2002 Manuel M. T. Chakravarty
The authors intend this Report to belong to the entire Haskell
community, and so we grant permission to copy and distribute it for
any purpose, provided that it is reproduced in its entirety,
including this Notice. Modified versions of this Report may also be
copied and distributed for any purpose, provided that the modified
version is clearly presented as such, and that it does not claim to
be a definition of the Haskell 98 Foreign Function Interface.
-----------------------------------------------------------------------------
================================================
FILE: .licenses/semantic/cabal/asn1-encoding.txt
================================================
---
type: cabal
name: asn1-encoding
version: 0.9.5
summary: ASN1 data reader and writer in RAW, BER and DER forms
homepage: https://github.com/vincenthz/hs-asn1
license: bsd-3-clause
---
Copyright (c) 2010-2013 Vincent Hanquez <vincent@snarc.org>
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the author nor the names of his contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/asn1-parse.txt
================================================
---
type: cabal
name: asn1-parse
version: 0.9.4
summary: Simple monadic parser for ASN1 stream types.
homepage: https://github.com/vincenthz/hs-asn1
license: bsd-3-clause
---
Copyright (c) 2010-2013 Vincent Hanquez <vincent@snarc.org>
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the author nor the names of his contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/asn1-types.txt
================================================
---
type: cabal
name: asn1-types
version: 0.3.2
summary: ASN.1 types
homepage: https://github.com/vincenthz/hs-asn1-types
license: bsd-3-clause
---
Copyright (c) 2010-2013 Vincent Hanquez <vincent@snarc.org>
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the author nor the names of his contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/async.txt
================================================
---
type: cabal
name: async
version: 2.2.1
summary: Run IO operations asynchronously and wait for their results
homepage: https://github.com/simonmar/async
license: bsd-3-clause
---
Copyright (c) 2012, Simon Marlow
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of Simon Marlow nor the names of other
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/attoparsec-iso8601.txt
================================================
---
type: cabal
name: attoparsec-iso8601
version: 1.0.1.0
summary: Parsing of ISO 8601 dates, originally from aeson.
homepage: https://github.com/bos/aeson
license: bsd-3-clause
---
Copyright (c) 2011, MailRank, Inc.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the author nor the names of his contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND ANY EXPRESS
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/attoparsec.txt
================================================
---
type: cabal
name: attoparsec
version: 0.13.2.2
summary: Fast combinator parsing for bytestrings and text
homepage: https://github.com/bos/attoparsec
license: bsd-3-clause
---
Copyright (c) Lennart Kolmodin
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the author nor the names of his contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND ANY EXPRESS
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/base-compat-batteries.txt
================================================
---
type: cabal
name: base-compat-batteries
version: 0.10.5
summary: base-compat with extra batteries
homepage:
license: mit
---
Copyright (c) 2012-2018 Simon Hengel <sol@typeful.net> and Ryan Scott <ryan.gl.scott@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
================================================
FILE: .licenses/semantic/cabal/base-compat.txt
================================================
---
type: cabal
name: base-compat
version: 0.10.5
summary: A compatibility layer for base
homepage:
license: mit
---
Copyright (c) 2012-2018 Simon Hengel <sol@typeful.net> and Ryan Scott <ryan.gl.scott@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
================================================
FILE: .licenses/semantic/cabal/base-orphans.txt
================================================
---
type: cabal
name: base-orphans
version: '0.8'
summary: Backwards-compatible orphan instances for base
homepage: https://github.com/haskell-compat/base-orphans
license: mit
---
Copyright (c) 2015-2017 Simon Hengel <sol@typeful.net>, João Cristóvão <jmacristovao@gmail.com>, Ryan Scott <ryan.gl.scott@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
================================================
FILE: .licenses/semantic/cabal/base-prelude.txt
================================================
---
type: cabal
name: base-prelude
version: '1.3'
summary: The most complete prelude formed solely from the "base" package
homepage: https://github.com/nikita-volkov/base-prelude
license: mit
---
Copyright (c) 2014, Nikita Volkov
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
================================================
FILE: .licenses/semantic/cabal/base.txt
================================================
---
type: cabal
name: base
version: 4.12.0.0
summary: Basic libraries
homepage:
license: bsd-3-clause
---
This library (libraries/base) is derived from code from several
sources:
* Code from the GHC project which is largely (c) The University of
Glasgow, and distributable under a BSD-style license (see below),
* Code from the Haskell 98 Report which is (c) Simon Peyton Jones
and freely redistributable (but see the full license for
restrictions).
* Code from the Haskell Foreign Function Interface specification,
which is (c) Manuel M. T. Chakravarty and freely redistributable
(but see the full license for restrictions).
The full text of these licenses is reproduced below. All of the
licenses are BSD-style or compatible.
-----------------------------------------------------------------------------
The Glasgow Haskell Compiler License
Copyright 2004, The University Court of the University of Glasgow.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
- Neither name of the University nor the names of its contributors may be
used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF
GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW OR THE CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.
-----------------------------------------------------------------------------
Code derived from the document "Report on the Programming Language
Haskell 98", is distributed under the following license:
Copyright (c) 2002 Simon Peyton Jones
The authors intend this Report to belong to the entire Haskell
community, and so we grant permission to copy and distribute it for
any purpose, provided that it is reproduced in its entirety,
including this Notice. Modified versions of this Report may also be
copied and distributed for any purpose, provided that the modified
version is clearly presented as such, and that it does not claim to
be a definition of the Haskell 98 Language.
-----------------------------------------------------------------------------
Code derived from the document "The Haskell 98 Foreign Function
Interface, An Addendum to the Haskell 98 Report" is distributed under
the following license:
Copyright (c) 2002 Manuel M. T. Chakravarty
The authors intend this Report to belong to the entire Haskell
community, and so we grant permission to copy and distribute it for
any purpose, provided that it is reproduced in its entirety,
including this Notice. Modified versions of this Report may also be
copied and distributed for any purpose, provided that the modified
version is clearly presented as such, and that it does not claim to
be a definition of the Haskell 98 Foreign Function Interface.
-----------------------------------------------------------------------------
================================================
FILE: .licenses/semantic/cabal/base64-bytestring.txt
================================================
---
type: cabal
name: base64-bytestring
version: 1.0.0.2
summary: Fast base64 encoding and decoding for ByteStrings
homepage: https://github.com/haskell/base64-bytestring
license: bsd-3-clause
---
Copyright (c) 2010 Bryan O'Sullivan <bos@serpentine.com>
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the author nor the names of his contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND ANY EXPRESS
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/basement.txt
================================================
---
type: cabal
name: basement
version: 0.0.10
summary: Foundation scrap box of array & string
homepage: https://github.com/haskell-foundation/foundation
license: bsd-3-clause
---
Copyright (c) 2015-2017 Vincent Hanquez <vincent@snarc.org>
Copyright (c) 2017 Foundation Maintainers
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the author nor the names of his contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/bifunctors.txt
================================================
---
type: cabal
name: bifunctors
version: 5.5.3
summary: Bifunctors
homepage: https://github.com/ekmett/bifunctors/
license: bsd-2-clause
---
Copyright 2008-2016 Edward Kmett
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/binary.txt
================================================
---
type: cabal
name: binary
version: 0.8.6.0
summary: Binary serialisation for Haskell values using lazy ByteStrings
homepage: https://github.com/kolmodin/binary
license: bsd-3-clause
---
Copyright (c) Lennart Kolmodin
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the author nor the names of his contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND ANY EXPRESS
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/blaze-builder.txt
================================================
---
type: cabal
name: blaze-builder
version: 0.4.1.0
summary: Efficient buffered output.
homepage: https://github.com/lpsmith/blaze-builder
license: bsd-3-clause
---
Copyright Jasper Van der Jeugt 2010, Simon Meier 2010 & 2011
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of Jasper Van der Jeugt nor the names of other
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/byteable.txt
================================================
---
type: cabal
name: byteable
version: 0.1.1
summary: Type class for sequence of bytes
homepage: https://github.com/vincenthz/hs-byteable
license: bsd-3-clause
---
Copyright (c) 2013 Vincent Hanquez <vincent@snarc.org>
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the author nor the names of his contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/bytestring.txt
================================================
---
type: cabal
name: bytestring
version: 0.10.8.2
summary: Fast, compact, strict and lazy byte strings with a list interface
homepage: https://github.com/haskell/bytestring
license: bsd-3-clause
---
Copyright (c) Don Stewart 2005-2009
(c) Duncan Coutts 2006-2015
(c) David Roundy 2003-2005
(c) Simon Meier 2010-2011
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the author nor the names of his contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/call-stack.txt
================================================
---
type: cabal
name: call-stack
version: 0.1.0
summary: Use GHC call-stacks in a backward compatible way
homepage: https://github.com/sol/call-stack
license: mit
---
Copyright (c) 2016 Simon Hengel <sol@typeful.net>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
================================================
FILE: .licenses/semantic/cabal/case-insensitive.txt
================================================
---
type: cabal
name: case-insensitive
version: 1.2.0.11
summary: Case insensitive string comparison
homepage: https://github.com/basvandijk/case-insensitive
license: bsd-3-clause
---
Copyright (c) 2011-2013 Bas van Dijk
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* The name of Bas van Dijk and the names of contributors may NOT
be used to endorse or promote products derived from this
software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/cereal.txt
================================================
---
type: cabal
name: cereal
version: 0.5.8.0
summary: A binary serialization library
homepage: https://github.com/GaloisInc/cereal
license: bsd-3-clause
---
Copyright (c) Lennart Kolmodin, Galois, Inc.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the author nor the names of his contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND ANY EXPRESS
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/charset.txt
================================================
---
type: cabal
name: charset
version: 0.3.7.1
summary: Fast unicode character sets based on complemented PATRICIA tries
homepage: https://github.com/ekmett/charset
license: bsd-3-clause
---
Copyright (c) 2010, Edward Kmett
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of Edward Kmett nor the names of other
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/clock.txt
================================================
---
type: cabal
name: clock
version: 0.7.2
summary: 'High-resolution clock functions: monotonic, realtime, cputime.'
homepage: https://github.com/corsis/clock
license: bsd-3-clause
---
Copyright (c) 2009-2012, Cetin Sert
Copyright (c) 2010, Eugene Kirpichov
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* The names of contributors may not be used to endorse or promote
products derived from this software without specific prior
written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/cmark-gfm.txt
================================================
---
type: cabal
name: cmark-gfm
version: 0.1.8
summary: Fast, accurate GitHub Flavored Markdown parser and renderer
homepage: https://github.com/kivikakk/cmark-gfm-hs
license: bsd-3-clause
---
Copyright (c) 2014, John MacFarlane
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of John MacFarlane nor the names of other
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----
libcmark
Copyright (c) 2014, John MacFarlane
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----
houdini.h, houdini_href_e.c, houdini_html_e.c, houdini_html_u.c,
html_unescape.gperf, html_unescape.h
derive from https://github.com/vmg/houdini (with some modifications)
Copyright (C) 2012 Vicent Martí
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
-----
buffer.h, buffer.c, chunk.h
are derived from code (C) 2012 Github, Inc.
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
-----
utf8.c and utf8.c
are derived from utf8proc
(<http://www.public-software-group.org/utf8proc>),
(C) 2009 Public Software Group e. V., Berlin, Germany.
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
================================================
FILE: .licenses/semantic/cabal/colour.txt
================================================
---
type: cabal
name: colour
version: 2.3.4
summary: A model for human colour/color perception
homepage: https://www.haskell.org/haskellwiki/Colour
license: mit
---
Copyright (c) 2008, 2009
Russell O'Connor
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
================================================
FILE: .licenses/semantic/cabal/comonad.txt
================================================
---
type: cabal
name: comonad
version: 5.0.4
summary: Comonads
homepage: https://github.com/ekmett/comonad/
license: bsd-2-clause
---
Copyright 2008-2014 Edward Kmett
Copyright 2004-2008 Dave Menendez
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/connection.txt
================================================
---
type: cabal
name: connection
version: 0.2.8
summary: Simple and easy network connections API
homepage: https://github.com/vincenthz/hs-connection
license: bsd-3-clause
---
Copyright (c) 2012 Vincent Hanquez <vincent@snarc.org>
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the author nor the names of his contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/constraints.txt
================================================
---
homepage: http://github.com/ekmett/constraints/
summary: Constraint manipulation
name: constraints
version: 0.10.1
license: bsd-2-clause
---
Copyright 2011-2015 Edward Kmett
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/containers.txt
================================================
---
type: cabal
name: containers
version: 0.6.0.1
summary: Assorted concrete container types
homepage:
license: bsd-3-clause
---
The Glasgow Haskell Compiler License
Copyright 2004, The University Court of the University of Glasgow.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
- Neither name of the University nor the names of its contributors may be
used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF
GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW OR THE CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.
================================================
FILE: .licenses/semantic/cabal/contravariant.txt
================================================
---
type: cabal
name: contravariant
version: '1.5'
summary: Contravariant functors
homepage: https://github.com/ekmett/contravariant/
license: bsd-3-clause
---
Copyright 2007-2015 Edward Kmett
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the author nor the names of his contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/cookie.txt
================================================
---
type: cabal
name: cookie
version: 0.4.4
summary: HTTP cookie parsing and rendering
homepage: https://github.com/snoyberg/cookie
license: mit
---
Copyright (c) 2010 Michael Snoyman, http://www.yesodweb.com/
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
================================================
FILE: .licenses/semantic/cabal/cryptonite.txt
================================================
---
type: cabal
name: cryptonite
version: '0.25'
summary: Cryptography Primitives sink
homepage: https://github.com/haskell-crypto/cryptonite
license: bsd-3-clause
---
Copyright (c) 2006-2015 Vincent Hanquez <vincent@snarc.org>
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the author nor the names of his contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/data-default-class.txt
================================================
---
type: cabal
name: data-default-class
version: 0.1.2.0
summary: A class for types with a default value
homepage: https://github.com/mauke/data-default
license: bsd-3-clause
---
Copyright (c) 2013 Lukas Mai
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of the author nor the names of his contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/deepseq-generics.txt
================================================
---
type: cabal
name: deepseq-generics
version: 0.2.0.0
summary: GHC.Generics-based Control.DeepSeq.rnf implementation
homepage: https://github.com/hvr/deepseq-generics
license: bsd-3-clause
---
Copyright (c) 2012, Herbert Valerio Riedel
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of Herbert Valerio Riedel nor the names of other
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/deepseq.txt
================================================
---
type: cabal
name: deepseq
version: 1.4.4.0
summary: Deep evaluation of data structures
homepage: https://github.com/haskell/deepseq
license: bsd-3-clause
---
This library (deepseq) is derived from code from the GHC project which
is largely (c) The University of Glasgow, and distributable under a
BSD-style license (see below).
-----------------------------------------------------------------------------
The Glasgow Haskell Compiler License
Copyright 2001-2009, The University Court of the University of Glasgow.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
- Neither name of the University nor the names of its contributors may be
used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF
GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW OR THE CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.
-----------------------------------------------------------------------------
================================================
FILE: .licenses/semantic/cabal/directory-tree.txt
================================================
---
type: cabal
name: directory-tree
version: 0.12.1
summary: A simple directory-like tree datatype, with useful IO functions
homepage: https://brandon.si/code/directory-tree-module-released/
license: bsd-2-clause
---
Copyright (c) 2009 Brandon Simmons
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/directory.txt
================================================
---
type: cabal
name: directory
version: 1.3.3.0
summary: Platform-agnostic library for filesystem operations
homepage:
license: bsd-3-clause
---
This library (libraries/base) is derived from code from two
sources:
* Code from the GHC project which is largely (c) The University of
Glasgow, and distributable under a BSD-style license (see below),
* Code from the Haskell 98 Report which is (c) Simon Peyton Jones
and freely redistributable (but see the full license for
restrictions).
The full text of these licenses is reproduced below. Both of the
licenses are BSD-style or compatible.
-----------------------------------------------------------------------------
The Glasgow Haskell Compiler License
Copyright 2004, The University Court of the University of Glasgow.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
- Neither name of the University nor the names of its contributors may be
used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF
GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW OR THE CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.
-----------------------------------------------------------------------------
Code derived from the document "Report on the Programming Language
Haskell 98", is distributed under the following license:
Copyright (c) 2002 Simon Peyton Jones
The authors intend this Report to belong to the entire Haskell
community, and so we grant permission to copy and distribute it for
any purpose, provided that it is reproduced in its entirety,
including this Notice. Modified versions of this Report may also be
copied and distributed for any purpose, provided that the modified
version is clearly presented as such, and that it does not claim to
be a definition of the Haskell 98 Language.
-----------------------------------------------------------------------------
================================================
FILE: .licenses/semantic/cabal/distributive.txt
================================================
---
type: cabal
name: distributive
version: '0.6'
summary: Distributive functors -- Dual to Traversable
homepage: https://github.com/ekmett/distributive/
license: bsd-2-clause
---
Copyright 2011-2016 Edward Kmett
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/dlist.txt
================================================
---
type: cabal
name: dlist
version: 0.8.0.5
summary: Difference lists
homepage: https://github.com/spl/dlist
license: bsd-3-clause
---
Copyright (c) 2006-2009 Don Stewart, 2013-2016 Sean Leather
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of Don Stewart nor the names of other
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/enclosed-exceptions.txt
================================================
---
homepage: https://github.com/jcristovao/enclosed-exceptions
summary: Catching all exceptions from within an enclosed computation
name: enclosed-exceptions
version: 1.0.3
license: mit
---
Copyright (c) 2012 Michael Snoyman, http://www.yesodweb.com/
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
================================================
FILE: .licenses/semantic/cabal/erf.txt
================================================
---
type: cabal
name: erf
version: 2.0.0.0
summary: The error function, erf, and related functions.
homepage:
license: bsd-3-clause
---
Copyright (c) Lennart Augustsson
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the author nor the names of his contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND ANY EXPRESS
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/exceptions.txt
================================================
---
type: cabal
name: exceptions
version: 0.10.0
summary: Extensible optionally-pure exceptions
homepage: https://github.com/ekmett/exceptions/
license: bsd-3-clause
---
Copyright 2013-2015 Edward Kmett
Copyright 2012 Google Inc.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the author nor the names of his contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/fastsum.txt
================================================
---
type: cabal
name: fastsum
version: 0.1.1.0
summary: A fast open-union type suitable for 100+ contained alternatives
homepage: https://github.com/patrickt/fastsum
license: bsd-3-clause
---
Original work Copyright (c) 2016, Allele Dev
Modified work Copyright (c) 2016, Patrick Thomson and Josh Vera
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of Allele Dev nor the names of other
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/filepath.txt
================================================
---
type: cabal
name: filepath
version: 1.4.2.1
summary: Library for manipulating FilePaths in a cross platform way.
homepage: https://github.com/haskell/filepath
license: bsd-3-clause
---
Copyright Neil Mitchell 2005-2018.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of Neil Mitchell nor the names of other
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/fingertree.txt
================================================
---
type: cabal
name: fingertree
version: 0.1.4.2
summary: Generic finger-tree structure, with example instances
homepage:
license: bsd-3-clause
---
The Glasgow Haskell Compiler License
Copyright 2006, The University Court of the University of Glasgow.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
- Neither name of the University nor the names of its contributors may be
used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF
GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW OR THE CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.
================================================
FILE: .licenses/semantic/cabal/foldl.txt
================================================
---
type: cabal
name: foldl
version: 1.4.5
summary: Composable, streaming, and efficient left folds
homepage:
license: bsd-3-clause
---
Copyright (c) 2013 Gabriel Gonzalez
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of Gabriel Gonzalez nor the names of other contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/freer-cofreer.txt
================================================
---
type: cabal
name: freer-cofreer
version: 0.0.0.1
summary: Freer monads and Cofreer comonads.
homepage: https://github.com/robrix/freer-cofreer
license: bsd-3-clause
---
Copyright Rob Rix (c) 2017
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of Rob Rix nor the names of other contributors
may be used to endorse or promote products derived from this
software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/fused-effects.txt
================================================
---
type: cabal
name: fused-effects
version: 0.4.0.0
summary: A fast, flexible, fused effect system.
homepage: https://github.com/robrix/fused-effects
license: bsd-3-clause
---
BSD 3-Clause License
Copyright (c) 2018, Nicolas Wu, Tom Schrijvers, Rob Rix, and Patrick Thomson
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/generic-monoid.txt
================================================
---
type: cabal
name: generic-monoid
version: '0.1.0.0'
summary: Derive monoid instances for product types.
homepage: https://github.com/luke-clifton/generic-monoid
license: bsd-3-clause
---
Copyright (c) 2018, Luke Clifton
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of Luke Clifton nor the names of other
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/generics-sop.txt
================================================
---
type: cabal
name: generics-sop
version: 0.4.0.1
summary: Generic Programming using True Sums of Products
homepage:
license: bsd-3-clause
---
Copyright (c) 2014-2015, Well-Typed LLP, Edsko de Vries, Andres Löh
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/ghc-boot-th.txt
================================================
---
type: cabal
name: ghc-boot-th
version: 8.6.4
summary: Shared functionality between GHC and the @template-haskell@
license: bsd-3-clause
---
The Glasgow Haskell Compiler License
Copyright 2002, The University Court of the University of Glasgow.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
- Neither name of the University nor the names of its contributors may be
used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF
GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW OR THE CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.
================================================
FILE: .licenses/semantic/cabal/ghc-boot.txt
================================================
---
type: cabal
name: ghc-boot
version: 8.6.4
summary: Shared functionality between GHC and its boot libraries
license: bsd-3-clause
---
The Glasgow Haskell Compiler License
Copyright 2002, The University Court of the University of Glasgow.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
- Neither name of the University nor the names of its contributors may be
used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF
GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW OR THE CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.
================================================
FILE: .licenses/semantic/cabal/ghc-heap.txt
================================================
---
type: cabal
name: ghc-heap
version: 8.6.4
summary: Functions for walking GHC's heap
license: bsd-3-clause
---
Copyright (c) 2012-2013, Joachim Breitner
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of Joachim Breitner nor the names of other
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/ghc-prim.txt
================================================
---
type: cabal
name: ghc-prim
version: 0.5.3
summary: GHC primitives
homepage:
license: bsd-3-clause
---
This library (libraries/ghc-prim) is derived from code from several
sources:
* Code from the GHC project which is largely (c) The University of
Glasgow, and distributable under a BSD-style license (see below),
* Code from the Haskell 98 Report which is (c) Simon Peyton Jones
and freely redistributable (but see the full license for
restrictions).
The full text of these licenses is reproduced below. All of the
licenses are BSD-style or compatible.
-----------------------------------------------------------------------------
The Glasgow Haskell Compiler License
Copyright 2004, The University Court of the University of Glasgow.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
- Neither name of the University nor the names of its contributors may be
used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF
GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW OR THE CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.
-----------------------------------------------------------------------------
Code derived from the document "Report on the Programming Language
Haskell 98", is distributed under the following license:
Copyright (c) 2002 Simon Peyton Jones
The authors intend this Report to belong to the entire Haskell
community, and so we grant permission to copy and distribute it for
any purpose, provided that it is reproduced in its entirety,
including this Notice. Modified versions of this Report may also be
copied and distributed for any purpose, provided that the modified
version is clearly presented as such, and that it does not claim to
be a definition of the Haskell 98 Language.
================================================
FILE: .licenses/semantic/cabal/ghc-tcplugins-extra.txt
================================================
---
type: cabal
name: ghc-tcplugins-extra
version: '0.3'
summary: Utilities for writing GHC type-checker plugins
homepage: https://github.com/clash-lang/ghc-tcplugins-extra
license: bsd-2-clause
---
Copyright (c) 2015-2016, University of Twente,
2017-2018, QBayLogic
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the
distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/ghc-typelits-extra.txt
================================================
---
type: cabal
name: ghc-typelits-extra
version: '0.3'
summary: Additional type-level operations on GHC.TypeLits.Nat
homepage: https://www.clash-lang.org/
license: bsd-2-clause
---
Copyright (c) 2015-2016, University of Twente,
2017-2018, QBayLogic B.V.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the
distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/ghc-typelits-knownnat.txt
================================================
---
type: cabal
name: ghc-typelits-knownnat
version: '0.6'
summary: Derive KnownNat constraints from other KnownNat constraints
homepage: https://clash-lang.org/
license: bsd-2-clause
---
Copyright (c) 2016 , University of Twente,
2017-2018, QBayLogic B.V.,
2017 , Google Inc.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the
distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/ghc-typelits-natnormalise.txt
================================================
---
type: cabal
name: ghc-typelits-natnormalise
version: 0.6.2
summary: GHC typechecker plugin for types of kind GHC.TypeLits.Nat
homepage: https://www.clash-lang.org/
license: bsd-2-clause
---
Copyright (c) 2015-2016, University of Twente,
2017-2018, QBayLogic B.V.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the
distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/ghc.txt
================================================
---
type: cabal
name: ghc
version: 8.6.4
summary: The GHC API
homepage: https://www.haskell.org/ghc/
license: bsd-3-clause
---
The Glasgow Haskell Compiler License
Copyright 2002, The University Court of the University of Glasgow.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
- Neither name of the University nor the names of its contributors may be
used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF
GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW OR THE CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.
================================================
FILE: .licenses/semantic/cabal/ghci.txt
================================================
---
type: cabal
name: ghci
version: 8.6.4
summary: The library supporting GHC's interactive interpreter
license: bsd-3-clause
---
The Glasgow Haskell Compiler License
Copyright 2002, The University Court of the University of Glasgow.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
- Neither name of the University nor the names of its contributors may be
used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF
GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW OR THE CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.
================================================
FILE: .licenses/semantic/cabal/gitrev.txt
================================================
---
type: cabal
name: gitrev
version: 1.3.1
summary: Compile git revision info into Haskell projects
homepage: https://github.com/acfoltzer/gitrev
license: bsd-3-clause
---
Copyright (c) 2015, Adam C. Foltzer
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of gitrev nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/hashable.txt
================================================
---
type: cabal
name: hashable
version: 1.2.7.0
summary: A class for types that can be converted to a hash value
homepage: https://github.com/tibbe/hashable
license: bsd-3-clause
---
Copyright Milan Straka 2010
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of Milan Straka nor the names of other
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/haskeline.txt
================================================
---
type: cabal
name: haskeline
version: 0.7.5.0
summary: A command-line interface for user input, written in Haskell.
homepage: https://github.com/judah/haskeline
license: bsd-2-clause
---
Copyright 2007-2009, Judah Jacobson.
All Rights Reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
- Redistribution of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
- Redistribution in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS" AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR THE CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/haskell-lexer.txt
================================================
---
type: cabal
name: haskell-lexer
version: 1.0.2
summary: A fully compliant Haskell 98 lexer.
homepage: https://github.com/yav/haskell-lexer
license: mit
---
Copyright (c) 2008 Thomas Hallgren
Copyright (c) 2008 Iavor S. Diatchki
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
================================================
FILE: .licenses/semantic/cabal/haskell-src.txt
================================================
---
type: cabal
name: haskell-src
version: 1.0.3.0
summary: Support for manipulating Haskell source code
homepage:
license: bsd-3-clause
---
The Glasgow Haskell Compiler License
Copyright 2004, The University Court of the University of Glasgow.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
- Neither name of the University nor the names of its contributors may be
used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF
GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW OR THE CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.
================================================
FILE: .licenses/semantic/cabal/haskell-tree-sitter.txt
================================================
---
type: cabal
name: haskell-tree-sitter
version: 0.1.0
summary: haskell tree-sitter bindings
homepage: https://github.com/tree-sitter/haskell-tree-sitter
license: bsd-3-clause
---
Copyright GitHub (c) 2015
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of Author name here nor the names of other
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/heap.txt
================================================
---
type: cabal
name: heap
version: 1.0.4
summary: Heaps in Haskell
homepage:
license: bsd-2-clause
---
Copyright (c) 2008-2009, Stephan Friedrichs
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/hostname.txt
================================================
---
type: cabal
name: hostname
version: '1.0'
summary: A very simple package providing a cross-platform means of determining the
hostname
homepage:
license: bsd-3-clause
---
Copyright (c) 2008, Maximilian Bolingbroke
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted
provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of
conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of
conditions and the following disclaimer in the documentation and/or other materials
provided with the distribution.
* Neither the name of Maximilian Bolingbroke nor the names of other contributors may be used to
endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/hourglass.txt
================================================
---
type: cabal
name: hourglass
version: 0.2.12
summary: simple performant time related library
homepage: https://github.com/vincenthz/hs-hourglass
license: bsd-3-clause
---
Copyright (c) 2014 Vincent Hanquez <vincent@snarc.org>
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the author nor the names of his contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/hpc.txt
================================================
---
type: cabal
name: hpc
version: 0.6.0.3
summary: Code Coverage Library for Haskell
homepage:
license: bsd-3-clause
---
Copyright (c) 2006 Andy Gill, Colin Runciman
Copyright (c) 2007 Andy Gill
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The names of the authors may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/http-api-data.txt
================================================
---
type: cabal
name: http-api-data
version: '0.4'
summary: Converting to/from HTTP API data like URL pieces, headers and query parameters.
homepage: https://github.com/fizruk/http-api-data
license: bsd-2-clause
---
The following license covers this documentation, and the source code, except
where otherwise indicated.
Copyright 2015, Nickolay Kudasov. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS "AS IS" AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/insert-ordered-containers.txt
================================================
---
type: cabal
name: insert-ordered-containers
version: 0.2.1.0
summary: Associative containers retaining insertion order for traversals.
homepage: https://github.com/phadej/insert-ordered-containers
license: bsd-3-clause
---
Copyright (c) 2015, Oleg Grenrus
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of Oleg Grenrus nor the names of other
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/integer-gmp.txt
================================================
---
type: cabal
name: integer-gmp
version: 1.0.2.0
summary: Integer library based on GMP
homepage:
license: bsd-3-clause
---
Copyright (c) 2014, Herbert Valerio Riedel
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of Herbert Valerio Riedel nor the names of other
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/integer-logarithms.txt
================================================
---
type: cabal
name: integer-logarithms
version: 1.0.2.2
summary: Integer logarithms.
homepage: https://github.com/Bodigrim/integer-logarithms
license: mit
---
Copyright (c) 2011 Daniel Fischer, 2017 Oleg Grenrus
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
associated documentation files (the "Software"), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge, publish, distribute,
sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or
substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
================================================
FILE: .licenses/semantic/cabal/invariant.txt
================================================
---
type: cabal
name: invariant
version: 0.5.1
summary: Haskell98 invariant functors
homepage: https://github.com/nfrisby/invariant-functors
license: bsd-2-clause
---
Copyright (c) 2012-2017, University of Kansas
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/kan-extensions.txt
================================================
---
type: cabal
name: kan-extensions
version: '5.2'
summary: Kan extensions, Kan lifts, the Yoneda lemma, and (co)density (co)monads
homepage: https://github.com/ekmett/kan-extensions/
license: bsd-3-clause
---
Copyright 2008-2016 Edward Kmett
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the author nor the names of his contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/kdt.txt
================================================
---
type: cabal
name: kdt
version: 0.2.4
summary: Fast and flexible k-d trees for various types of point queries.
homepage: https://github.com/giogadi/kdt
license: mit
---
Copyright (c) 2014 Luis G. Torres
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
================================================
FILE: .licenses/semantic/cabal/keys.txt
================================================
---
type: cabal
name: keys
version: 3.12.1
summary: Keyed functors and containers
homepage: https://github.com/ekmett/keys/
license: bsd-3-clause
---
Copyright 2011-2016 Edward Kmett
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the author nor the names of his contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/lens.txt
================================================
---
type: cabal
name: lens
version: '4.17'
summary: Lenses, Folds and Traversals
homepage: https://github.com/ekmett/lens/
license: bsd-2-clause
---
Copyright 2012-2016 Edward Kmett
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/lifted-async.txt
================================================
---
homepage: https://github.com/maoe/lifted-async
summary: Run lifted IO operations asynchronously and wait for their results
name: lifted-async
version: 0.10.0.3
license: bsd-3-clause
---
Copyright (c) 2012-2017, Mitsutoshi Aoe
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of Mitsutoshi Aoe nor the names of other
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/lifted-base.txt
================================================
---
homepage: https://github.com/basvandijk/lifted-base
summary: lifted IO operations from the base library
name: lifted-base
version: 0.2.3.12
license: bsd-3-clause
---
Copyright © 2010-2012, Bas van Dijk, Anders Kaseorg
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
• Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
• Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
• Neither the name of the author nor the names of other contributors
may be used to endorse or promote products derived from this
software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
“AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/machines.txt
================================================
---
type: cabal
name: machines
version: 0.6.4
summary: Networked stream transducers
homepage: https://github.com/ekmett/machines/
license: bsd-3-clause
---
Copyright 2012-2015 Edward Kmett, Runar Bjarnason, Paul Chiusano
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the author nor the names of his contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/managed.txt
================================================
---
type: cabal
name: managed
version: 1.0.6
summary: A monad for managed values
homepage:
license: bsd-3-clause
---
Copyright (c) 2014 Gabriel Gonzalez
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of Gabriel Gonzalez nor the names of other contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/math-functions.txt
================================================
---
type: cabal
name: math-functions
version: '0.3.1.0'
summary: Collection of tools for numeric computations
homepage: https://github.com/bos/math-functions/
license: bsd-2-clause
---
Copyright (c) 2009, 2010 Bryan O'Sullivan
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/megaparsec.txt
================================================
---
type: cabal
name: megaparsec
version: 7.0.4
summary: Monadic parser combinators
homepage: https://github.com/mrkkrp/megaparsec
license: bsd-2-clause
---
Copyright © 2015–2018 Megaparsec contributors<br>
Copyright © 2007 Paolo Martini<br>
Copyright © 1999–2000 Daan Leijen
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS “AS IS” AND ANY EXPRESS
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/memory.txt
================================================
---
type: cabal
name: memory
version: 0.14.18
summary: memory and related abstraction stuff
homepage: https://github.com/vincenthz/hs-memory
license: bsd-3-clause
---
Copyright (c) 2015-2018 Vincent Hanquez <vincent@snarc.org>
Copyright (c) 2017-2018 Nicolas Di Prima <nicolas@primetype.co.uk>
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the author nor the names of his contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/mersenne-random-pure64.txt
================================================
---
type: cabal
name: mersenne-random-pure64
version: 0.2.2.0
summary: Generate high quality pseudorandom numbers purely using a Mersenne Twister
homepage: https://code.haskell.org/~dons/code/mersenne-random-pure64/
license: bsd-3-clause
---
Copyright (c) Don Stewart <dons@galois.com> 2008
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the author nor the names of his contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/mime-types.txt
================================================
---
type: cabal
name: mime-types
version: 0.1.0.9
summary: Basic mime-type handling types and functions
homepage: https://github.com/yesodweb/wai
license: mit
---
Copyright (c) 2012 Michael Snoyman, http://www.yesodweb.com/
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
================================================
FILE: .licenses/semantic/cabal/mmorph.txt
================================================
---
type: cabal
name: mmorph
version: 1.1.2
summary: Monad morphisms
homepage:
license: bsd-3-clause
---
Copyright (c) 2013, Gabriel Gonzalez
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.
* Neither the name of Gabriel Gonzalez nor the names of other contributors may
be used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: .licenses/semantic/cabal/monad-control.txt
================================================
---
homepage: https://github.com/basvandijk/monad-control
summary: Lift control operations, like exception catching, through monad transformers
name: monad-control
version: 1.0.2.3
license: bsd-3-clause
---
Copyright © 2010, Bas van Dijk, Anders Kaseorg
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
• Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
• Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
• Neither the name of the author nor the names of other contributors
may be used to endorse or promote products derived from this
software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
“AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BU
gitextract_vw5g09h3/ ├── .bazelignore ├── .bazelrc ├── .dockerignore ├── .ghci.repl ├── .ghci.sample ├── .gitattributes ├── .github/ │ └── workflows/ │ ├── bazel.yml.disabled │ └── haskell.yml ├── .gitignore ├── .gitmodules ├── .hlint.yaml ├── .hspec ├── .licenses/ │ └── semantic/ │ └── cabal/ │ ├── MonadRandom.txt │ ├── QuickCheck.txt │ ├── StateVar.txt │ ├── adjunctions.txt │ ├── aeson-pretty.txt │ ├── aeson.txt │ ├── algebraic-graphs.txt │ ├── ansi-terminal.txt │ ├── ansi-wl-pprint.txt │ ├── array.txt │ ├── asn1-encoding.txt │ ├── asn1-parse.txt │ ├── asn1-types.txt │ ├── async.txt │ ├── attoparsec-iso8601.txt │ ├── attoparsec.txt │ ├── base-compat-batteries.txt │ ├── base-compat.txt │ ├── base-orphans.txt │ ├── base-prelude.txt │ ├── base.txt │ ├── base64-bytestring.txt │ ├── basement.txt │ ├── bifunctors.txt │ ├── binary.txt │ ├── blaze-builder.txt │ ├── byteable.txt │ ├── bytestring.txt │ ├── call-stack.txt │ ├── case-insensitive.txt │ ├── cereal.txt │ ├── charset.txt │ ├── clock.txt │ ├── cmark-gfm.txt │ ├── colour.txt │ ├── comonad.txt │ ├── connection.txt │ ├── constraints.txt │ ├── containers.txt │ ├── contravariant.txt │ ├── cookie.txt │ ├── cryptonite.txt │ ├── data-default-class.txt │ ├── deepseq-generics.txt │ ├── deepseq.txt │ ├── directory-tree.txt │ ├── directory.txt │ ├── distributive.txt │ ├── dlist.txt │ ├── enclosed-exceptions.txt │ ├── erf.txt │ ├── exceptions.txt │ ├── fastsum.txt │ ├── filepath.txt │ ├── fingertree.txt │ ├── foldl.txt │ ├── freer-cofreer.txt │ ├── fused-effects.txt │ ├── generic-monoid.txt │ ├── generics-sop.txt │ ├── ghc-boot-th.txt │ ├── ghc-boot.txt │ ├── ghc-heap.txt │ ├── ghc-prim.txt │ ├── ghc-tcplugins-extra.txt │ ├── ghc-typelits-extra.txt │ ├── ghc-typelits-knownnat.txt │ ├── ghc-typelits-natnormalise.txt │ ├── ghc.txt │ ├── ghci.txt │ ├── gitrev.txt │ ├── hashable.txt │ ├── haskeline.txt │ ├── haskell-lexer.txt │ ├── haskell-src.txt │ ├── haskell-tree-sitter.txt │ ├── heap.txt │ ├── hostname.txt │ ├── hourglass.txt │ ├── hpc.txt │ ├── http-api-data.txt │ ├── insert-ordered-containers.txt │ ├── integer-gmp.txt │ ├── integer-logarithms.txt │ ├── invariant.txt │ ├── kan-extensions.txt │ ├── kdt.txt │ ├── keys.txt │ ├── lens.txt │ ├── lifted-async.txt │ ├── lifted-base.txt │ ├── machines.txt │ ├── managed.txt │ ├── math-functions.txt │ ├── megaparsec.txt │ ├── memory.txt │ ├── mersenne-random-pure64.txt │ ├── mime-types.txt │ ├── mmorph.txt │ ├── monad-control.txt │ ├── mtl.txt │ ├── mwc-random.txt │ ├── neat-interpolation.txt │ ├── network-uri.txt │ ├── network.txt │ ├── old-locale.txt │ ├── old-time.txt │ ├── optional-args.txt │ ├── optparse-applicative.txt │ ├── parallel.txt │ ├── parsec.txt │ ├── parser-combinators.txt │ ├── parsers.txt │ ├── pem.txt │ ├── pointed.txt │ ├── pretty.txt │ ├── prettyprinter.txt │ ├── primitive.txt │ ├── process.txt │ ├── profunctors.txt │ ├── proto3-suite.txt │ ├── proto3-wire.txt │ ├── quickcheck-instances.txt │ ├── random.txt │ ├── recursion-schemes.txt │ ├── reducers.txt │ ├── reflection.txt │ ├── rts.txt │ ├── safe.txt │ ├── scientific.txt │ ├── semigroupoids.txt │ ├── semigroups.txt │ ├── semilattices.txt │ ├── servant.txt │ ├── shelly.txt │ ├── singleton-bool.txt │ ├── socks.txt │ ├── sop-core.txt │ ├── split.txt │ ├── stm-chans.txt │ ├── stm.txt │ ├── streaming-commons.txt │ ├── string-conversions.txt │ ├── swagger2.txt │ ├── syb.txt │ ├── system-fileio.txt │ ├── system-filepath.txt │ ├── tagged.txt │ ├── template-haskell.txt │ ├── temporary.txt │ ├── terminfo.txt │ ├── text.txt │ ├── tf-random.txt │ ├── th-abstraction.txt │ ├── these.txt │ ├── time-locale-compat.txt │ ├── time.txt │ ├── tls.txt │ ├── transformers-base.txt │ ├── transformers-compat.txt │ ├── transformers.txt │ ├── turtle.txt │ ├── unix-compat.txt │ ├── unix.txt │ ├── unliftio-core.txt │ ├── unordered-containers.txt │ ├── utf8-string.txt │ ├── uuid-types.txt │ ├── vault.txt │ ├── vector-builder.txt │ ├── vector-instances.txt │ ├── vector-th-unbox.txt │ ├── vector.txt │ ├── void.txt │ ├── x509-store.txt │ ├── x509-system.txt │ ├── x509-validation.txt │ ├── x509.txt │ └── zlib.txt ├── .stylish-haskell.yaml ├── BUILD.bazel ├── CODEOWNERS ├── CODE_OF_CONDUCT.md ├── CONTRIBUTING.md ├── Dockerfile ├── HACKING.md ├── README.md ├── WORKSPACE ├── build/ │ ├── common.bzl │ └── example_repos.bzl ├── cabal.project ├── cabal.project.ci ├── docs/ │ ├── adding-new-languages.md │ ├── build.md │ ├── codegen.md │ ├── coding-style.md │ ├── configuration.md │ ├── core-grammar.md │ ├── development.md │ ├── examples.md │ ├── grammar-development-guide.md │ ├── why-haskell.md │ ├── why-tree-sitter.md │ └── 💡ProTip!.md ├── hie.yaml ├── notices/ │ └── THIRD_PARTY_NOTICE.md ├── proto/ │ └── semantic.proto ├── script/ │ ├── astgen │ ├── bootstrap │ ├── bootstrap-bazel │ ├── build-and-upload │ ├── clone-example-repos │ ├── fix-broken-cabal-store │ ├── generate-example │ ├── ghci-flags │ ├── profile │ ├── protoc │ ├── publish │ └── repl ├── semantic/ │ ├── BUILD.bazel │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── app/ │ │ └── Main.hs │ ├── bench/ │ │ ├── Main.hs │ │ ├── Tagging.hs │ │ └── bench-fixtures/ │ │ ├── python/ │ │ │ ├── function-definition.py │ │ │ ├── if-statement-functions.py │ │ │ └── simple-assignment.py │ │ └── ruby/ │ │ ├── function-definition.rb │ │ ├── if-statement-functions.rb │ │ └── simple-assignment.rb │ ├── semantic.cabal │ ├── src/ │ │ ├── Control/ │ │ │ ├── Carrier/ │ │ │ │ └── Parse/ │ │ │ │ ├── Measured.hs │ │ │ │ └── Simple.hs │ │ │ └── Effect/ │ │ │ ├── Parse.hs │ │ │ ├── Sum/ │ │ │ │ └── Project.hs │ │ │ └── Timeout.hs │ │ ├── Data/ │ │ │ ├── Blob/ │ │ │ │ └── IO.hs │ │ │ ├── Blob.hs │ │ │ ├── Duration.hs │ │ │ ├── Edit.hs │ │ │ ├── Error.hs │ │ │ ├── Flag.hs │ │ │ ├── Graph/ │ │ │ │ └── Algebraic.hs │ │ │ ├── Handle.hs │ │ │ ├── Maybe/ │ │ │ │ └── Exts.hs │ │ │ └── Semigroup/ │ │ │ └── App.hs │ │ ├── Parsing/ │ │ │ ├── Parser.hs │ │ │ └── TreeSitter.hs │ │ ├── Semantic/ │ │ │ ├── Api/ │ │ │ │ ├── Bridge.hs │ │ │ │ ├── StackGraph.hs │ │ │ │ ├── Symbols.hs │ │ │ │ └── Terms.hs │ │ │ ├── Api.hs │ │ │ ├── CLI.hs │ │ │ ├── Config.hs │ │ │ ├── Env.hs │ │ │ ├── IO.hs │ │ │ ├── Task/ │ │ │ │ └── Files.hs │ │ │ ├── Task.hs │ │ │ ├── Telemetry/ │ │ │ │ ├── AsyncQueue.hs │ │ │ │ ├── Error.hs │ │ │ │ ├── Log.hs │ │ │ │ └── Stat.hs │ │ │ ├── Telemetry.hs │ │ │ ├── Util/ │ │ │ │ └── Pretty.hs │ │ │ ├── Util.hs │ │ │ └── Version.hs │ │ └── Serializing/ │ │ ├── Format.hs │ │ └── SExpression/ │ │ └── Precise.hs │ └── test/ │ ├── Data/ │ │ ├── Graph/ │ │ │ └── Spec.hs │ │ ├── Language/ │ │ │ └── Spec.hs │ │ └── Semigroup/ │ │ └── App/ │ │ └── Spec.hs │ ├── Examples.hs │ ├── Generators.hs │ ├── Integration/ │ │ └── Spec.hs │ ├── Properties.hs │ ├── Semantic/ │ │ ├── CLI/ │ │ │ └── Spec.hs │ │ ├── IO/ │ │ │ └── Spec.hs │ │ ├── Spec.hs │ │ └── Stat/ │ │ └── Spec.hs │ ├── Spec.hs │ ├── SpecHelpers.hs │ ├── Tags/ │ │ └── Spec.hs │ └── fixtures/ │ ├── base.rb │ ├── cli/ │ │ ├── blank.json │ │ ├── diff-empty-language.json │ │ ├── diff-no-after.json │ │ ├── diff-no-before.json │ │ ├── diff-no-language.json │ │ ├── diff-null-after.json │ │ ├── diff-null-before.json │ │ ├── diff-null-both-sides.json │ │ ├── diff-tree.json │ │ ├── diff-tree.toc.json │ │ ├── diff-unsupported-language.json │ │ ├── diff.json │ │ ├── parse-tree-empty.json │ │ ├── parse-tree.json │ │ ├── parse-tree.symbols.json │ │ ├── parse-trees.json │ │ └── parse.json │ ├── go/ │ │ ├── analysis/ │ │ │ ├── bar/ │ │ │ │ ├── bar.go │ │ │ │ └── rab.go │ │ │ ├── foo/ │ │ │ │ └── foo.go │ │ │ ├── main.go │ │ │ └── main1.go │ │ ├── corpus/ │ │ │ ├── array-types.A.go │ │ │ ├── array-types.B.go │ │ │ ├── array-types.diffA-B.txt │ │ │ ├── array-types.diffB-A.txt │ │ │ ├── array-types.parseA.txt │ │ │ ├── array-types.parseB.txt │ │ │ ├── array-with-implicit-length.A.go │ │ │ ├── array-with-implicit-length.B.go │ │ │ ├── array-with-implicit-length.diffA-B.txt │ │ │ ├── array-with-implicit-length.diffB-A.txt │ │ │ ├── array-with-implicit-length.parseA.txt │ │ │ ├── array-with-implicit-length.parseB.txt │ │ │ ├── assignment-statements.A.go │ │ │ ├── assignment-statements.B.go │ │ │ ├── assignment-statements.diffA-B.txt │ │ │ ├── assignment-statements.diffB-A.txt │ │ │ ├── assignment-statements.parseA.txt │ │ │ ├── assignment-statements.parseB.txt │ │ │ ├── binary-expressions.A.go │ │ │ ├── binary-expressions.B.go │ │ │ ├── binary-expressions.diffA-B.txt │ │ │ ├── binary-expressions.diffB-A.txt │ │ │ ├── binary-expressions.parseA.txt │ │ │ ├── binary-expressions.parseB.txt │ │ │ ├── call-expressions.A.go │ │ │ ├── call-expressions.B.go │ │ │ ├── call-expressions.diffA-B.txt │ │ │ ├── call-expressions.diffB-A.txt │ │ │ ├── call-expressions.parseA.txt │ │ │ ├── call-expressions.parseB.txt │ │ │ ├── case-statements.A.go │ │ │ ├── case-statements.B.go │ │ │ ├── case-statements.diffA-B.txt │ │ │ ├── case-statements.diffB-A.txt │ │ │ ├── case-statements.parseA.txt │ │ │ ├── case-statements.parseB.txt │ │ │ ├── channel-types.A.go │ │ │ ├── channel-types.B.go │ │ │ ├── channel-types.diffA-B.txt │ │ │ ├── channel-types.diffB-A.txt │ │ │ ├── channel-types.parseA.txt │ │ │ ├── channel-types.parseB.txt │ │ │ ├── comment.A.go │ │ │ ├── comment.B.go │ │ │ ├── comment.diffA-B.txt │ │ │ ├── comment.diffB-A.txt │ │ │ ├── comment.parseA.txt │ │ │ ├── comment.parseB.txt │ │ │ ├── const-declarations-with-types.A.go │ │ │ ├── const-declarations-with-types.B.go │ │ │ ├── const-declarations-with-types.diffA-B.txt │ │ │ ├── const-declarations-with-types.diffB-A.txt │ │ │ ├── const-declarations-with-types.parseA.txt │ │ │ ├── const-declarations-with-types.parseB.txt │ │ │ ├── const-declarations-without-types.A.go │ │ │ ├── const-declarations-without-types.B.go │ │ │ ├── const-declarations-without-types.diffA-B.txt │ │ │ ├── const-declarations-without-types.diffB-A.txt │ │ │ ├── const-declarations-without-types.parseA.txt │ │ │ ├── const-declarations-without-types.parseB.txt │ │ │ ├── const-with-implicit-values.A.go │ │ │ ├── const-with-implicit-values.B.go │ │ │ ├── const-with-implicit-values.diffA-B.txt │ │ │ ├── const-with-implicit-values.diffB-A.txt │ │ │ ├── const-with-implicit-values.parseA.txt │ │ │ ├── const-with-implicit-values.parseB.txt │ │ │ ├── constructors.A.go │ │ │ ├── constructors.B.go │ │ │ ├── constructors.diffA-B.txt │ │ │ ├── constructors.diffB-A.txt │ │ │ ├── constructors.parseA.txt │ │ │ ├── constructors.parseB.txt │ │ │ ├── float-literals.A.go │ │ │ ├── float-literals.B.go │ │ │ ├── float-literals.diffA-B.txt │ │ │ ├── float-literals.diffB-A.txt │ │ │ ├── float-literals.parseA.txt │ │ │ ├── float-literals.parseB.txt │ │ │ ├── for-statements.A.go │ │ │ ├── for-statements.B.go │ │ │ ├── for-statements.diffA-B.txt │ │ │ ├── for-statements.diffB-A.txt │ │ │ ├── for-statements.parseA.txt │ │ │ ├── for-statements.parseB.txt │ │ │ ├── function-declarations.A.go │ │ │ ├── function-declarations.B.go │ │ │ ├── function-declarations.diffA-B.txt │ │ │ ├── function-declarations.diffB-A.txt │ │ │ ├── function-declarations.parseA.txt │ │ │ ├── function-declarations.parseB.txt │ │ │ ├── function-literals.A.go │ │ │ ├── function-literals.B.go │ │ │ ├── function-literals.diffA-B.txt │ │ │ ├── function-literals.diffB-A.txt │ │ │ ├── function-literals.parseA.txt │ │ │ ├── function-literals.parseB.txt │ │ │ ├── function-types.A.go │ │ │ ├── function-types.B.go │ │ │ ├── function-types.diffA-B.txt │ │ │ ├── function-types.diffB-A.txt │ │ │ ├── function-types.parseA.txt │ │ │ ├── function-types.parseB.txt │ │ │ ├── go-and-defer-statements.A.go │ │ │ ├── go-and-defer-statements.B.go │ │ │ ├── go-and-defer-statements.diffA-B.txt │ │ │ ├── go-and-defer-statements.diffB-A.txt │ │ │ ├── go-and-defer-statements.parseA.txt │ │ │ ├── go-and-defer-statements.parseB.txt │ │ │ ├── grouped-import-declarations.A.go │ │ │ ├── grouped-import-declarations.B.go │ │ │ ├── grouped-import-declarations.diffA-B.txt │ │ │ ├── grouped-import-declarations.diffB-A.txt │ │ │ ├── grouped-import-declarations.parseA.txt │ │ │ ├── grouped-import-declarations.parseB.txt │ │ │ ├── grouped-var-declarations.A.go │ │ │ ├── grouped-var-declarations.B.go │ │ │ ├── grouped-var-declarations.diffA-B.txt │ │ │ ├── grouped-var-declarations.diffB-A.txt │ │ │ ├── grouped-var-declarations.parseA.txt │ │ │ ├── grouped-var-declarations.parseB.txt │ │ │ ├── if-statements.A.go │ │ │ ├── if-statements.B.go │ │ │ ├── if-statements.diffA-B.txt │ │ │ ├── if-statements.diffB-A.txt │ │ │ ├── if-statements.parseA.txt │ │ │ ├── if-statements.parseB.txt │ │ │ ├── imaginary-literals.A.go │ │ │ ├── imaginary-literals.B.go │ │ │ ├── imaginary-literals.diffA-B.txt │ │ │ ├── imaginary-literals.diffB-A.txt │ │ │ ├── imaginary-literals.parseA.txt │ │ │ ├── imaginary-literals.parseB.txt │ │ │ ├── import-statements.A.go │ │ │ ├── import-statements.B.go │ │ │ ├── import-statements.diffA-B.txt │ │ │ ├── import-statements.diffB-A.txt │ │ │ ├── import-statements.parseA.txt │ │ │ ├── import-statements.parseB.txt │ │ │ ├── increment-decrement-statements.A.go │ │ │ ├── increment-decrement-statements.B.go │ │ │ ├── increment-decrement-statements.diffA-B.txt │ │ │ ├── increment-decrement-statements.diffB-A.txt │ │ │ ├── increment-decrement-statements.parseA.txt │ │ │ ├── increment-decrement-statements.parseB.txt │ │ │ ├── int-literals.A.go │ │ │ ├── int-literals.B.go │ │ │ ├── int-literals.diffA-B.txt │ │ │ ├── int-literals.diffB-A.txt │ │ │ ├── int-literals.parseA.txt │ │ │ ├── int-literals.parseB.txt │ │ │ ├── interface-types.A.go │ │ │ ├── interface-types.B.go │ │ │ ├── interface-types.diffA-B.txt │ │ │ ├── interface-types.diffB-A.txt │ │ │ ├── interface-types.parseA.txt │ │ │ ├── interface-types.parseB.txt │ │ │ ├── label-statements.A.go │ │ │ ├── label-statements.B.go │ │ │ ├── label-statements.diffA-B.txt │ │ │ ├── label-statements.diffB-A.txt │ │ │ ├── label-statements.parseA.txt │ │ │ ├── label-statements.parseB.txt │ │ │ ├── map-literals.A.go │ │ │ ├── map-literals.B.go │ │ │ ├── map-literals.diffA-B.txt │ │ │ ├── map-literals.diffB-A.txt │ │ │ ├── map-literals.parseA.txt │ │ │ ├── map-literals.parseB.txt │ │ │ ├── map-types.A.go │ │ │ ├── map-types.B.go │ │ │ ├── map-types.diffA-B.txt │ │ │ ├── map-types.diffB-A.txt │ │ │ ├── map-types.parseA.txt │ │ │ ├── map-types.parseB.txt │ │ │ ├── method-declarations.A.go │ │ │ ├── method-declarations.B.go │ │ │ ├── method-declarations.diffA-B.txt │ │ │ ├── method-declarations.diffB-A.txt │ │ │ ├── method-declarations.parseA.txt │ │ │ ├── method-declarations.parseB.txt │ │ │ ├── modifying-struct-fields.A.go │ │ │ ├── modifying-struct-fields.B.go │ │ │ ├── modifying-struct-fields.diffA-B.txt │ │ │ ├── modifying-struct-fields.diffB-A.txt │ │ │ ├── modifying-struct-fields.parseA.txt │ │ │ ├── modifying-struct-fields.parseB.txt │ │ │ ├── parameter-declarations-with-types.A.go │ │ │ ├── parameter-declarations-with-types.B.go │ │ │ ├── parameter-declarations-with-types.diffA-B.txt │ │ │ ├── parameter-declarations-with-types.diffB-A.txt │ │ │ ├── parameter-declarations-with-types.parseA.txt │ │ │ ├── parameter-declarations-with-types.parseB.txt │ │ │ ├── pointer-types.A.go │ │ │ ├── pointer-types.B.go │ │ │ ├── pointer-types.diffA-B.txt │ │ │ ├── pointer-types.diffB-A.txt │ │ │ ├── pointer-types.parseA.txt │ │ │ ├── pointer-types.parseB.txt │ │ │ ├── qualified-types.A.go │ │ │ ├── qualified-types.B.go │ │ │ ├── qualified-types.diffA-B.txt │ │ │ ├── qualified-types.diffB-A.txt │ │ │ ├── qualified-types.parseA.txt │ │ │ ├── qualified-types.parseB.txt │ │ │ ├── rune-literals.A.go │ │ │ ├── rune-literals.B.go │ │ │ ├── rune-literals.diffA-B.txt │ │ │ ├── rune-literals.diffB-A.txt │ │ │ ├── rune-literals.parseA.txt │ │ │ ├── rune-literals.parseB.txt │ │ │ ├── select-statements.A.go │ │ │ ├── select-statements.B.go │ │ │ ├── select-statements.diffA-B.txt │ │ │ ├── select-statements.diffB-A.txt │ │ │ ├── select-statements.parseA.txt │ │ │ ├── select-statements.parseB.txt │ │ │ ├── selector-expressions.A.go │ │ │ ├── selector-expressions.B.go │ │ │ ├── selector-expressions.diffA-B.txt │ │ │ ├── selector-expressions.diffB-A.txt │ │ │ ├── selector-expressions.parseA.txt │ │ │ ├── selector-expressions.parseB.txt │ │ │ ├── send-statements.A.go │ │ │ ├── send-statements.B.go │ │ │ ├── send-statements.diffA-B.txt │ │ │ ├── send-statements.diffB-A.txt │ │ │ ├── send-statements.parseA.txt │ │ │ ├── send-statements.parseB.txt │ │ │ ├── short-var-declarations.A.go │ │ │ ├── short-var-declarations.B.go │ │ │ ├── short-var-declarations.diffA-B.txt │ │ │ ├── short-var-declarations.diffB-A.txt │ │ │ ├── short-var-declarations.parseA.txt │ │ │ ├── short-var-declarations.parseB.txt │ │ │ ├── single-import-declarations.A.go │ │ │ ├── single-import-declarations.B.go │ │ │ ├── single-import-declarations.diffA-B.txt │ │ │ ├── single-import-declarations.diffB-A.txt │ │ │ ├── single-import-declarations.parseA.txt │ │ │ ├── single-import-declarations.parseB.txt │ │ │ ├── single-import-declarationsA.parseA.txt │ │ │ ├── single-line-function-declarations.A.go │ │ │ ├── single-line-function-declarations.B.go │ │ │ ├── single-line-function-declarations.diffA-B.txt │ │ │ ├── single-line-function-declarations.diffB-A.txt │ │ │ ├── single-line-function-declarations.parseA.txt │ │ │ ├── single-line-function-declarations.parseB.txt │ │ │ ├── slice-expressions.A.go │ │ │ ├── slice-expressions.B.go │ │ │ ├── slice-expressions.diffA-B.txt │ │ │ ├── slice-expressions.diffB-A.txt │ │ │ ├── slice-expressions.parseA.txt │ │ │ ├── slice-expressions.parseB.txt │ │ │ ├── slice-literals.A.go │ │ │ ├── slice-literals.B.go │ │ │ ├── slice-literals.diffA-B.txt │ │ │ ├── slice-literals.diffB-A.txt │ │ │ ├── slice-literals.parseA.txt │ │ │ ├── slice-literals.parseB.txt │ │ │ ├── slice-types.A.go │ │ │ ├── slice-types.B.go │ │ │ ├── slice-types.diffA-B.txt │ │ │ ├── slice-types.diffB-A.txt │ │ │ ├── slice-types.parseA.txt │ │ │ ├── slice-types.parseB.txt │ │ │ ├── string-literals.A.go │ │ │ ├── string-literals.B.go │ │ │ ├── string-literals.diffA-B.txt │ │ │ ├── string-literals.diffB-A.txt │ │ │ ├── string-literals.parseA.txt │ │ │ ├── string-literals.parseB.txt │ │ │ ├── struct-field-declarations.A.go │ │ │ ├── struct-field-declarations.B.go │ │ │ ├── struct-field-declarations.diffA-B.txt │ │ │ ├── struct-field-declarations.diffB-A.txt │ │ │ ├── struct-field-declarations.parseA.txt │ │ │ ├── struct-field-declarations.parseB.txt │ │ │ ├── struct-literals.A.go │ │ │ ├── struct-literals.B.go │ │ │ ├── struct-literals.diffA-B.txt │ │ │ ├── struct-literals.diffB-A.txt │ │ │ ├── struct-literals.parseA.txt │ │ │ ├── struct-literals.parseB.txt │ │ │ ├── struct-types.A.go │ │ │ ├── struct-types.B.go │ │ │ ├── struct-types.diffA-B.txt │ │ │ ├── struct-types.diffB-A.txt │ │ │ ├── struct-types.parseA.txt │ │ │ ├── struct-types.parseB.txt │ │ │ ├── switch-statement.parseA.txt │ │ │ ├── switch-statements.A.go │ │ │ ├── switch-statements.B.go │ │ │ ├── switch-statements.diffA-B.txt │ │ │ ├── switch-statements.diffB-A.txt │ │ │ ├── switch-statements.parseA.txt │ │ │ ├── switch-statements.parseB.txt │ │ │ ├── type-aliases.A.go │ │ │ ├── type-aliases.B.go │ │ │ ├── type-aliases.diffA-B.txt │ │ │ ├── type-aliases.diffB-A.txt │ │ │ ├── type-aliases.parseA.txt │ │ │ ├── type-aliases.parseB.txt │ │ │ ├── type-assertion-expressions.A.go │ │ │ ├── type-assertion-expressions.B.go │ │ │ ├── type-assertion-expressions.diffA-B.txt │ │ │ ├── type-assertion-expressions.diffB-A.txt │ │ │ ├── type-assertion-expressions.parseA.txt │ │ │ ├── type-assertion-expressions.parseB.txt │ │ │ ├── type-conversion-expressions.A.go │ │ │ ├── type-conversion-expressions.B.go │ │ │ ├── type-conversion-expressions.diffA-B.txt │ │ │ ├── type-conversion-expressions.diffB-A.txt │ │ │ ├── type-conversion-expressions.parseA.txt │ │ │ ├── type-conversion-expressions.parseB.txt │ │ │ ├── type-declarations.A.go │ │ │ ├── type-declarations.B.go │ │ │ ├── type-declarations.diffA-B.txt │ │ │ ├── type-declarations.diffB-A.txt │ │ │ ├── type-declarations.parseA.txt │ │ │ ├── type-declarations.parseB.txt │ │ │ ├── type-switch-statements.A.go │ │ │ ├── type-switch-statements.B.go │ │ │ ├── type-switch-statements.diffA-B.txt │ │ │ ├── type-switch-statements.diffB-A.txt │ │ │ ├── type-switch-statements.parseA.txt │ │ │ ├── type-switch-statements.parseB.txt │ │ │ ├── unary-expressions.A.go │ │ │ ├── unary-expressions.B.go │ │ │ ├── unary-expressions.diffA-B.txt │ │ │ ├── unary-expressions.diffB-A.txt │ │ │ ├── unary-expressions.parseA.txt │ │ │ ├── unary-expressions.parseB.txt │ │ │ ├── var-declarations-with-no-expressions.A.go │ │ │ ├── var-declarations-with-no-expressions.B.go │ │ │ ├── var-declarations-with-no-expressions.diffA-B.txt │ │ │ ├── var-declarations-with-no-expressions.diffB-A.txt │ │ │ ├── var-declarations-with-no-expressions.parseA.txt │ │ │ ├── var-declarations-with-no-expressions.parseB.txt │ │ │ ├── var-declarations-with-types.A.go │ │ │ ├── var-declarations-with-types.B.go │ │ │ ├── var-declarations-with-types.diffA-B.txt │ │ │ ├── var-declarations-with-types.diffB-A.txt │ │ │ ├── var-declarations-with-types.parseA.txt │ │ │ ├── var-declarations-with-types.parseB.txt │ │ │ ├── var-declarations-without-types.A.go │ │ │ ├── var-declarations-without-types.B.go │ │ │ ├── var-declarations-without-types.diffA-B.txt │ │ │ ├── var-declarations-without-types.diffB-A.txt │ │ │ ├── var-declarations-without-types.parseA.txt │ │ │ ├── var-declarations-without-types.parseB.txt │ │ │ ├── variadic-function-declarations.A.go │ │ │ ├── variadic-function-declarations.B.go │ │ │ ├── variadic-function-declarations.diffA-B.txt │ │ │ ├── variadic-function-declarations.diffB-A.txt │ │ │ ├── variadic-function-declarations.parseA.txt │ │ │ └── variadic-function-declarations.parseB.txt │ │ ├── import-graph/ │ │ │ ├── main.go │ │ │ └── main.json │ │ ├── matching/ │ │ │ ├── for.go │ │ │ └── integers.go │ │ ├── tags/ │ │ │ ├── method.go │ │ │ └── simple_functions.go │ │ └── toc/ │ │ ├── method-with-receiver.A.go │ │ └── method-with-receiver.B.go │ ├── haskell/ │ │ └── corpus/ │ │ ├── algebraic-datatype-declarations.A.hs │ │ ├── algebraic-datatype-declarations.B.hs │ │ ├── algebraic-datatype-declarations.diffA-B.txt │ │ ├── algebraic-datatype-declarations.diffB-A.txt │ │ ├── algebraic-datatype-declarations.parseA.txt │ │ ├── algebraic-datatype-declarations.parseB.txt │ │ ├── blank.A.hs │ │ ├── blank.parseA.txt │ │ ├── cpp-directives.A.hs │ │ ├── cpp-directives.B.hs │ │ ├── cpp-directives.diffA-B.txt │ │ ├── cpp-directives.diffB-A.txt │ │ ├── cpp-directives.parseA.txt │ │ ├── cpp-directives.parseB.txt │ │ ├── default-declaration.A.hs │ │ ├── default-declaration.B.hs │ │ ├── default-declaration.diffA-B.txt │ │ ├── default-declaration.diffB-A.txt │ │ ├── default-declaration.parseA.txt │ │ ├── default-declaration.parseB.txt │ │ ├── expressions.A.hs │ │ ├── expressions.B.hs │ │ ├── expressions.diffA-B.txt │ │ ├── expressions.diffB-A.txt │ │ ├── expressions.parseA.txt │ │ ├── expressions.parseB.txt │ │ ├── function-declarations.A.hs │ │ ├── function-declarations.B.hs │ │ ├── function-declarations.diffA-B.txt │ │ ├── function-declarations.diffB-A.txt │ │ ├── function-declarations.parseA.txt │ │ ├── function-declarations.parseB.txt │ │ ├── gadt-declarations.A.hs │ │ ├── gadt-declarations.B.hs │ │ ├── gadt-declarations.diffA-B.txt │ │ ├── gadt-declarations.diffB-A.txt │ │ ├── gadt-declarations.parseA.txt │ │ ├── gadt-declarations.parseB.txt │ │ ├── import-declaration.A.hs │ │ ├── import-declaration.B.hs │ │ ├── import-declaration.diffA-B.txt │ │ ├── import-declaration.diffB-A.txt │ │ ├── import-declaration.parseA.txt │ │ ├── import-declaration.parseB.txt │ │ ├── layout.A.hs │ │ ├── layout.B.hs │ │ ├── layout.diffA-B.txt │ │ ├── layout.diffB-A.txt │ │ ├── layout.parseA.txt │ │ ├── layout.parseB.txt │ │ ├── literals.A.hs │ │ ├── literals.B.hs │ │ ├── literals.diffA-B.txt │ │ ├── literals.diffB-A.txt │ │ ├── literals.parseA.txt │ │ ├── literals.parseB.txt │ │ ├── module-declaration1.A.hs │ │ ├── module-declaration1.B.hs │ │ ├── module-declaration1.diffA-B.txt │ │ ├── module-declaration1.diffB-A.txt │ │ ├── module-declaration1.parseA.txt │ │ ├── module-declaration1.parseB.txt │ │ ├── module-declaration2.A.hs │ │ ├── module-declaration2.B.hs │ │ ├── module-declaration2.diffA-B.txt │ │ ├── module-declaration2.diffB-A.txt │ │ ├── module-declaration2.parseA.txt │ │ ├── module-declaration2.parseB.txt │ │ ├── module-declaration3.A.hs │ │ ├── module-declaration3.B.hs │ │ ├── module-declaration3.diffA-B.txt │ │ ├── module-declaration3.diffB-A.txt │ │ ├── module-declaration3.parseA.txt │ │ ├── module-declaration3.parseB.txt │ │ ├── module-declaration4.A.hs │ │ ├── module-declaration4.B.hs │ │ ├── module-declaration4.diffA-B.txt │ │ ├── module-declaration4.diffB-A.txt │ │ ├── module-declaration4.parseA.txt │ │ ├── module-declaration4.parseB.txt │ │ ├── module-declaration5.A.hs │ │ ├── module-declaration5.B.hs │ │ ├── module-declaration5.diffA-B.txt │ │ ├── module-declaration5.diffB-A.txt │ │ ├── module-declaration5.parseA.txt │ │ ├── module-declaration5.parseB.txt │ │ ├── newtype-declaration.A.hs │ │ ├── newtype-declaration.B.hs │ │ ├── newtype-declaration.diffA-B.txt │ │ ├── newtype-declaration.diffB-A.txt │ │ ├── newtype-declaration.parseA.txt │ │ ├── newtype-declaration.parseB.txt │ │ ├── standalone-deriving-declaration.A.hs │ │ ├── standalone-deriving-declaration.B.hs │ │ ├── standalone-deriving-declaration.diffA-B.txt │ │ ├── standalone-deriving-declaration.diffB-A.txt │ │ ├── standalone-deriving-declaration.parseA.txt │ │ ├── standalone-deriving-declaration.parseB.txt │ │ ├── statements.A.hs │ │ ├── statements.B.hs │ │ ├── statements.diffA-B.txt │ │ ├── statements.diffB-A.txt │ │ ├── statements.parseA.txt │ │ ├── statements.parseB.txt │ │ ├── tempate-haskell.A.hs │ │ ├── tempate-haskell.parseA.txt │ │ ├── template-haskell.B.hs │ │ ├── type-class-declarations.A.hs │ │ ├── type-class-declarations.B.hs │ │ ├── type-class-declarations.diffA-B.txt │ │ ├── type-class-declarations.diffB-A.txt │ │ ├── type-class-declarations.parseA.txt │ │ ├── type-class-declarations.parseB.txt │ │ ├── type-class-instance-declarations.A.hs │ │ ├── type-class-instance-declarations.B.hs │ │ ├── type-class-instance-declarations.diffA-B.txt │ │ ├── type-class-instance-declarations.diffB-A.txt │ │ ├── type-class-instance-declarations.parseA.txt │ │ ├── type-class-instance-declarations.parseB.txt │ │ ├── type-family-declarations.A.hs │ │ ├── type-family-declarations.B.hs │ │ ├── type-family-declarations.diffA-B.txt │ │ ├── type-family-declarations.diffB-A.txt │ │ ├── type-family-declarations.parseA.txt │ │ ├── type-family-declarations.parseB.txt │ │ ├── type-signatures.A.hs │ │ ├── type-signatures.B.hs │ │ ├── type-signatures.diffA-B.txt │ │ ├── type-signatures.diffB-A.txt │ │ ├── type-signatures.parseA.txt │ │ ├── type-signatures.parseB.txt │ │ ├── type-synonyms.A.hs │ │ ├── type-synonyms.B.hs │ │ ├── type-synonyms.diffA-B.txt │ │ ├── type-synonyms.diffB-A.txt │ │ ├── type-synonyms.parseA.txt │ │ └── type-synonyms.parseB.txt │ ├── java/ │ │ └── corpus/ │ │ ├── ArrayAccess.A.java │ │ ├── ArrayAccess.B.java │ │ ├── ArrayAccess.diffA-B.txt │ │ ├── ArrayAccess.diffB-A.txt │ │ ├── ArrayAccess.parseA.txt │ │ ├── ArrayAccess.parseB.txt │ │ ├── AssertStatement.A.java │ │ ├── AssertStatement.B.java │ │ ├── AssertStatement.diffA-B.txt │ │ ├── AssertStatement.diffB-A.txt │ │ ├── AssertStatement.parseA.txt │ │ ├── AssertStatement.parseB.txt │ │ ├── Binary.A.java │ │ ├── Binary.B.java │ │ ├── Binary.diffA-B.txt │ │ ├── Binary.diffB-A.txt │ │ ├── Binary.parseA.txt │ │ ├── Binary.parseB.txt │ │ ├── Boolean.A.java │ │ ├── Boolean.B.java │ │ ├── Boolean.diffA-B.txt │ │ ├── Boolean.diffB-A.txt │ │ ├── Boolean.parseA.txt │ │ ├── Boolean.parseB.txt │ │ ├── Char.A.java │ │ ├── Char.B.java │ │ ├── Char.diffA-B.txt │ │ ├── Char.diffB-A.txt │ │ ├── Char.parseA.txt │ │ ├── Char.parseB.txt │ │ ├── ClassBody.A.java │ │ ├── ClassBody.B.java │ │ ├── ClassBody.diffA-B.txt │ │ ├── ClassBody.diffB-A.txt │ │ ├── ClassBody.parseA.txt │ │ ├── ClassBody.parseB.txt │ │ ├── ClassLiteral.A.java │ │ ├── ClassLiteral.B.java │ │ ├── ClassLiteral.diffA-B.txt │ │ ├── ClassLiteral.diffB-A.txt │ │ ├── ClassLiteral.parseA.txt │ │ ├── ClassLiteral.parseB.txt │ │ ├── Comment.A.java │ │ ├── Comment.B.java │ │ ├── Comment.diffA-B.txt │ │ ├── Comment.diffB-A.txt │ │ ├── Comment.parseA.txt │ │ ├── Comment.parseB.txt │ │ ├── Continue.A.java │ │ ├── Continue.B.java │ │ ├── Continue.diffA-B.txt │ │ ├── Continue.diffB-A.txt │ │ ├── Continue.parseA.txt │ │ ├── Continue.parseB.txt │ │ ├── Continue0.A.java │ │ ├── Continue1.A.java │ │ ├── Dims.A.java │ │ ├── Dims.B.java │ │ ├── Dims.diffA-B.txt │ │ ├── Dims.diffB-A.txt │ │ ├── Dims.parseA.txt │ │ ├── Dims.parseB.txt │ │ ├── DoWhile.A.java │ │ ├── DoWhile.B.java │ │ ├── DoWhile.diffA-B.txt │ │ ├── DoWhile.diffB-A.txt │ │ ├── DoWhile.parseA.txt │ │ ├── DoWhile.parseB.txt │ │ ├── EnumDeclaration.A.java │ │ ├── EnumDeclaration.B.java │ │ ├── EnumDeclaration.diffA-B.txt │ │ ├── EnumDeclaration.diffB-A.txt │ │ ├── EnumDeclaration.parseA.txt │ │ ├── EnumDeclaration.parseB.txt │ │ ├── FieldAccess.A.java │ │ ├── FieldAccess.B.java │ │ ├── FieldAccess.diffA-B.txt │ │ ├── FieldAccess.diffB-A.txt │ │ ├── FieldAccess.parseA.txt │ │ ├── FieldAccess.parseB.txt │ │ ├── Float.A.java │ │ ├── Float.B.java │ │ ├── Float.diffA-B.txt │ │ ├── Float.diffB-A.txt │ │ ├── Float.parseA.txt │ │ ├── Float.parseB.txt │ │ ├── For.A.java │ │ ├── For.B.java │ │ ├── For.diffA-B.txt │ │ ├── For.diffB-A.txt │ │ ├── For.parseA.txt │ │ ├── For.parseB.txt │ │ ├── If.A.java │ │ ├── If.B.java │ │ ├── If.diffA-B.txt │ │ ├── If.diffB-A.txt │ │ ├── If.parseA.txt │ │ ├── If.parseB.txt │ │ ├── Import.A.java │ │ ├── Import.B.java │ │ ├── Import.diffA-B.txt │ │ ├── Import.diffB-A.txt │ │ ├── Import.parseA.txt │ │ ├── Import.parseB.txt │ │ ├── Int.A.java │ │ ├── Int.B.java │ │ ├── Int.diffA-B.txt │ │ ├── Int.diffB-A.txt │ │ ├── Int.parseA.txt │ │ ├── Int.parseB.txt │ │ ├── Interface.A.java │ │ ├── Interface.B.java │ │ ├── Interface.diffA-B.txt │ │ ├── Interface.diffB-A.txt │ │ ├── Interface.parseA.txt │ │ ├── Interface.parseB.txt │ │ ├── Lambda.A.java │ │ ├── Lambda.B.java │ │ ├── Lambda.diffA-B.txt │ │ ├── Lambda.diffB-A.txt │ │ ├── Lambda.parseA.txt │ │ ├── Lambda.parseB.txt │ │ ├── ScopedIdentifier.A.java │ │ ├── ScopedIdentifier.B.java │ │ ├── ScopedIdentifier.diffA-B.txt │ │ ├── ScopedIdentifier.diffB-A.txt │ │ ├── ScopedIdentifier.parseA.txt │ │ ├── ScopedIdentifier.parseB.txt │ │ ├── SpreadParameter.A.java │ │ ├── SpreadParameter.B.java │ │ ├── SpreadParameter.diffA-B.txt │ │ ├── SpreadParameter.diffB-A.txt │ │ ├── SpreadParameter.parseA.txt │ │ ├── SpreadParameter.parseB.txt │ │ ├── String.A.java │ │ ├── String.B.java │ │ ├── String.diffA-B.txt │ │ ├── String.diffB-A.txt │ │ ├── String.parseA.txt │ │ ├── String.parseB.txt │ │ ├── Switch.A.java │ │ ├── Switch.B.java │ │ ├── Switch.diffA-B.txt │ │ ├── Switch.diffB-A.txt │ │ ├── Switch.parseA.txt │ │ ├── Switch.parseB.txt │ │ ├── Throws.A.java │ │ ├── Throws.B.java │ │ ├── TryCatches.A.java │ │ ├── TryCatches.B.java │ │ ├── TryWithResourcesStatement.A.java │ │ ├── TryWithResourcesStatement.B.java │ │ ├── TryWithResourcesStatement.diffA-B.txt │ │ ├── TryWithResourcesStatement.diffB-A.txt │ │ ├── TryWithResourcesStatement.parseA.txt │ │ ├── TryWithResourcesStatement.parseB.txt │ │ ├── TypeArgument.A.java │ │ ├── TypeArgument.B.java │ │ ├── TypeArgument.diffA-B.txt │ │ ├── TypeArgument.diffB-A.txt │ │ ├── TypeArgument.parseA.txt │ │ ├── TypeArgument.parseB.txt │ │ ├── Update.A.java │ │ ├── Update.B.java │ │ ├── Update.diffA-B.txt │ │ ├── Update.diffB-A.txt │ │ ├── Update.parseA.txt │ │ ├── Update.parseB.txt │ │ ├── VariableDeclaration.A.java │ │ ├── VariableDeclaration.B.java │ │ ├── VariableDeclaration.diffA-B.txt │ │ ├── VariableDeclaration.diffB-A.txt │ │ ├── VariableDeclaration.parseA.txt │ │ ├── VariableDeclaration.parseB.txt │ │ ├── While.A.java │ │ ├── While.B.java │ │ ├── While.diffA-B.txt │ │ ├── While.diffB-A.txt │ │ ├── While.parseA.txt │ │ ├── While.parseB.txt │ │ ├── Wildcard.A.java │ │ ├── Wildcard.B.java │ │ ├── Wildcard.diffA-B.txt │ │ ├── Wildcard.diffB-A.txt │ │ ├── Wildcard.parseA.txt │ │ ├── Wildcard.parseB.txt │ │ ├── array-access.java │ │ ├── assertStatement.java │ │ ├── assertStringLiteral.java │ │ ├── enum.java │ │ ├── methodReference.java │ │ ├── modifier-abstract.java │ │ ├── modifier-private.java │ │ ├── modifier-protected.java │ │ ├── modifier-public.java │ │ ├── modifier-static.java │ │ ├── null.java │ │ ├── package.java │ │ ├── return.java │ │ ├── try.java │ │ └── try_with_resources.java │ ├── javascript/ │ │ ├── analysis/ │ │ │ ├── exports/ │ │ │ │ ├── lib.js │ │ │ │ └── main.js │ │ │ ├── foo.js │ │ │ ├── main.js │ │ │ └── main2.js │ │ ├── corpus/ │ │ │ ├── anonymous-function.A.js │ │ │ ├── anonymous-function.B.js │ │ │ ├── anonymous-function.diffA-B.txt │ │ │ ├── anonymous-function.diffB-A.txt │ │ │ ├── anonymous-function.parseA.txt │ │ │ ├── anonymous-function.parseB.txt │ │ │ ├── anonymous-parameterless-function.A.js │ │ │ ├── anonymous-parameterless-function.B.js │ │ │ ├── anonymous-parameterless-function.diffA-B.txt │ │ │ ├── anonymous-parameterless-function.diffB-A.txt │ │ │ ├── anonymous-parameterless-function.parseA.txt │ │ │ ├── anonymous-parameterless-function.parseB.txt │ │ │ ├── array.A.js │ │ │ ├── array.B.js │ │ │ ├── array.diffA-B.txt │ │ │ ├── array.diffB-A.txt │ │ │ ├── array.parseA.txt │ │ │ ├── array.parseB.txt │ │ │ ├── arrow-function.A.js │ │ │ ├── arrow-function.B.js │ │ │ ├── arrow-function.diffA-B.txt │ │ │ ├── arrow-function.diffB-A.txt │ │ │ ├── arrow-function.parseA.txt │ │ │ ├── arrow-function.parseB.txt │ │ │ ├── assignment-pattern.A.js │ │ │ ├── assignment-pattern.B.js │ │ │ ├── assignment-pattern.diffA-B.txt │ │ │ ├── assignment-pattern.diffB-A.txt │ │ │ ├── assignment-pattern.parseA.txt │ │ │ ├── assignment-pattern.parseB.txt │ │ │ ├── assignment.A.js │ │ │ ├── assignment.B.js │ │ │ ├── assignment.diffA-B.txt │ │ │ ├── assignment.diffB-A.txt │ │ │ ├── assignment.parseA.txt │ │ │ ├── assignment.parseB.txt │ │ │ ├── bitwise-operator.A.js │ │ │ ├── bitwise-operator.B.js │ │ │ ├── bitwise-operator.diffA-B.txt │ │ │ ├── bitwise-operator.diffB-A.txt │ │ │ ├── bitwise-operator.parseA.txt │ │ │ ├── bitwise-operator.parseB.txt │ │ │ ├── boolean-operator.A.js │ │ │ ├── boolean-operator.B.js │ │ │ ├── boolean-operator.diffA-B.txt │ │ │ ├── boolean-operator.diffB-A.txt │ │ │ ├── boolean-operator.parseA.txt │ │ │ ├── boolean-operator.parseB.txt │ │ │ ├── break.A.js │ │ │ ├── break.B.js │ │ │ ├── break.diffA-B.txt │ │ │ ├── break.diffB-A.txt │ │ │ ├── break.parseA.txt │ │ │ ├── break.parseB.txt │ │ │ ├── chained-callbacks.A.js │ │ │ ├── chained-callbacks.B.js │ │ │ ├── chained-callbacks.diffA-B.txt │ │ │ ├── chained-callbacks.diffB-A.txt │ │ │ ├── chained-callbacks.parseA.txt │ │ │ ├── chained-callbacks.parseB.txt │ │ │ ├── chained-property-access.A.js │ │ │ ├── chained-property-access.B.js │ │ │ ├── chained-property-access.diffA-B.txt │ │ │ ├── chained-property-access.diffB-A.txt │ │ │ ├── chained-property-access.parseA.txt │ │ │ ├── chained-property-access.parseB.txt │ │ │ ├── class.A.js │ │ │ ├── class.B.js │ │ │ ├── class.diffA-B.txt │ │ │ ├── class.diffB-A.txt │ │ │ ├── class.parseA.txt │ │ │ ├── class.parseB.txt │ │ │ ├── comma-operator.A.js │ │ │ ├── comma-operator.B.js │ │ │ ├── comma-operator.diffA-B.txt │ │ │ ├── comma-operator.diffB-A.txt │ │ │ ├── comma-operator.parseA.txt │ │ │ ├── comma-operator.parseB.txt │ │ │ ├── comment.A.js │ │ │ ├── comment.B.js │ │ │ ├── comment.diffA-B.txt │ │ │ ├── comment.diffB-A.txt │ │ │ ├── comment.parseA.txt │ │ │ ├── comment.parseB.txt │ │ │ ├── constructor-call.A.js │ │ │ ├── constructor-call.B.js │ │ │ ├── constructor-call.diffA-B.txt │ │ │ ├── constructor-call.diffB-A.txt │ │ │ ├── constructor-call.parseA.txt │ │ │ ├── constructor-call.parseB.txt │ │ │ ├── continue.A.js │ │ │ ├── continue.B.js │ │ │ ├── continue.diffA-B.txt │ │ │ ├── continue.diffB-A.txt │ │ │ ├── continue.parseA.txt │ │ │ ├── continue.parseB.txt │ │ │ ├── delete-operator.A.js │ │ │ ├── delete-operator.B.js │ │ │ ├── delete-operator.diffA-B.txt │ │ │ ├── delete-operator.diffB-A.txt │ │ │ ├── delete-operator.parseA.txt │ │ │ ├── delete-operator.parseB.txt │ │ │ ├── do-while-statement.A.js │ │ │ ├── do-while-statement.B.js │ │ │ ├── do-while-statement.diffA-B.txt │ │ │ ├── do-while-statement.diffB-A.txt │ │ │ ├── do-while-statement.parseA.txt │ │ │ ├── do-while-statement.parseB.txt │ │ │ ├── export.A.js │ │ │ ├── export.B.js │ │ │ ├── export.diffA-B.txt │ │ │ ├── export.diffB-A.txt │ │ │ ├── export.parseA.txt │ │ │ ├── export.parseB.txt │ │ │ ├── false.A.js │ │ │ ├── false.B.js │ │ │ ├── false.diffA-B.txt │ │ │ ├── false.diffB-A.txt │ │ │ ├── false.parseA.txt │ │ │ ├── false.parseB.txt │ │ │ ├── for-in-statement.A.js │ │ │ ├── for-in-statement.B.js │ │ │ ├── for-in-statement.diffA-B.txt │ │ │ ├── for-in-statement.diffB-A.txt │ │ │ ├── for-in-statement.parseA.txt │ │ │ ├── for-in-statement.parseB.txt │ │ │ ├── for-loop-with-in-statement.A.js │ │ │ ├── for-loop-with-in-statement.B.js │ │ │ ├── for-loop-with-in-statement.diffA-B.txt │ │ │ ├── for-loop-with-in-statement.diffB-A.txt │ │ │ ├── for-loop-with-in-statement.parseA.txt │ │ │ ├── for-loop-with-in-statement.parseB.txt │ │ │ ├── for-of-statement.A.js │ │ │ ├── for-of-statement.B.js │ │ │ ├── for-of-statement.diffA-B.txt │ │ │ ├── for-of-statement.diffB-A.txt │ │ │ ├── for-of-statement.parseA.txt │ │ │ ├── for-of-statement.parseB.txt │ │ │ ├── for-statement.A.js │ │ │ ├── for-statement.B.js │ │ │ ├── for-statement.diffA-B.txt │ │ │ ├── for-statement.diffB-A.txt │ │ │ ├── for-statement.parseA.txt │ │ │ ├── for-statement.parseB.txt │ │ │ ├── function-call-args.A.js │ │ │ ├── function-call-args.B.js │ │ │ ├── function-call-args.diffA-B.txt │ │ │ ├── function-call-args.diffB-A.txt │ │ │ ├── function-call-args.parseA.txt │ │ │ ├── function-call-args.parseB.txt │ │ │ ├── function-call.A.js │ │ │ ├── function-call.B.js │ │ │ ├── function-call.diffA-B.txt │ │ │ ├── function-call.diffB-A.txt │ │ │ ├── function-call.parseA.txt │ │ │ ├── function-call.parseB.txt │ │ │ ├── function.A.js │ │ │ ├── function.B.js │ │ │ ├── function.diffA-B.txt │ │ │ ├── function.diffB-A.txt │ │ │ ├── function.parseA.txt │ │ │ ├── function.parseB.txt │ │ │ ├── generator-function.A.js │ │ │ ├── generator-function.B.js │ │ │ ├── generator-function.diffA-B.txt │ │ │ ├── generator-function.diffB-A.txt │ │ │ ├── generator-function.parseA.txt │ │ │ ├── generator-function.parseB.txt │ │ │ ├── identifier.A.js │ │ │ ├── identifier.B.js │ │ │ ├── identifier.diffA-B.txt │ │ │ ├── identifier.diffB-A.txt │ │ │ ├── identifier.parseA.txt │ │ │ ├── identifier.parseB.txt │ │ │ ├── if-else.A.js │ │ │ ├── if-else.B.js │ │ │ ├── if-else.diffA-B.txt │ │ │ ├── if-else.diffB-A.txt │ │ │ ├── if-else.parseA.txt │ │ │ ├── if-else.parseB.txt │ │ │ ├── if.A.js │ │ │ ├── if.B.js │ │ │ ├── if.diffA-B.txt │ │ │ ├── if.diffB-A.txt │ │ │ ├── if.parseA.txt │ │ │ ├── if.parseB.txt │ │ │ ├── import.A.js │ │ │ ├── import.B.js │ │ │ ├── import.diffA-B.txt │ │ │ ├── import.diffB-A.txt │ │ │ ├── import.parseA.txt │ │ │ ├── import.parseB.txt │ │ │ ├── jsx.A.js │ │ │ ├── jsx.B.js │ │ │ ├── jsx.diffA-B.txt │ │ │ ├── jsx.diffB-A.txt │ │ │ ├── jsx.parseA.txt │ │ │ ├── jsx.parseB.txt │ │ │ ├── math-assignment-operator.A.js │ │ │ ├── math-assignment-operator.B.js │ │ │ ├── math-assignment-operator.diffA-B.txt │ │ │ ├── math-assignment-operator.diffB-A.txt │ │ │ ├── math-assignment-operator.parseA.txt │ │ │ ├── math-assignment-operator.parseB.txt │ │ │ ├── math-operator.A.js │ │ │ ├── math-operator.B.js │ │ │ ├── math-operator.diffA-B.txt │ │ │ ├── math-operator.diffB-A.txt │ │ │ ├── math-operator.parseA.txt │ │ │ ├── math-operator.parseB.txt │ │ │ ├── member-access-assignment.A.js │ │ │ ├── member-access-assignment.B.js │ │ │ ├── member-access-assignment.diffA-B.txt │ │ │ ├── member-access-assignment.diffB-A.txt │ │ │ ├── member-access-assignment.parseA.txt │ │ │ ├── member-access-assignment.parseB.txt │ │ │ ├── member-access.A.js │ │ │ ├── member-access.B.js │ │ │ ├── member-access.diffA-B.txt │ │ │ ├── member-access.diffB-A.txt │ │ │ ├── member-access.parseA.txt │ │ │ ├── member-access.parseB.txt │ │ │ ├── method-call.A.js │ │ │ ├── method-call.B.js │ │ │ ├── method-call.diffA-B.txt │ │ │ ├── method-call.diffB-A.txt │ │ │ ├── method-call.parseA.txt │ │ │ ├── method-call.parseB.txt │ │ │ ├── named-function.A.js │ │ │ ├── named-function.B.js │ │ │ ├── named-function.diffA-B.txt │ │ │ ├── named-function.diffB-A.txt │ │ │ ├── named-function.parseA.txt │ │ │ ├── named-function.parseB.txt │ │ │ ├── nested-do-while-in-function.A.js │ │ │ ├── nested-do-while-in-function.B.js │ │ │ ├── nested-do-while-in-function.diffA-B.txt │ │ │ ├── nested-do-while-in-function.diffB-A.txt │ │ │ ├── nested-do-while-in-function.parseA.txt │ │ │ ├── nested-do-while-in-function.parseB.txt │ │ │ ├── nested-functions.A.js │ │ │ ├── nested-functions.B.js │ │ │ ├── nested-functions.diffA-B.txt │ │ │ ├── nested-functions.diffB-A.txt │ │ │ ├── nested-functions.parseA.txt │ │ │ ├── nested-functions.parseB.txt │ │ │ ├── null.A.js │ │ │ ├── null.B.js │ │ │ ├── null.diffA-B.txt │ │ │ ├── null.diffB-A.txt │ │ │ ├── null.parseA.txt │ │ │ ├── null.parseB.txt │ │ │ ├── number.A.js │ │ │ ├── number.B.js │ │ │ ├── number.diffA-B.txt │ │ │ ├── number.diffB-A.txt │ │ │ ├── number.parseA.txt │ │ │ ├── number.parseB.txt │ │ │ ├── object.A.js │ │ │ ├── object.B.js │ │ │ ├── object.diffA-B.txt │ │ │ ├── object.diffB-A.txt │ │ │ ├── object.parseA.txt │ │ │ ├── object.parseB.txt │ │ │ ├── objects-with-methods.A.js │ │ │ ├── objects-with-methods.B.js │ │ │ ├── objects-with-methods.diffA-B.txt │ │ │ ├── objects-with-methods.diffB-A.txt │ │ │ ├── objects-with-methods.parseA.txt │ │ │ ├── objects-with-methods.parseB.txt │ │ │ ├── regex.A.js │ │ │ ├── regex.B.js │ │ │ ├── regex.diffA-B.txt │ │ │ ├── regex.diffB-A.txt │ │ │ ├── regex.parseA.txt │ │ │ ├── regex.parseB.txt │ │ │ ├── relational-operator.A.js │ │ │ ├── relational-operator.B.js │ │ │ ├── relational-operator.diffA-B.txt │ │ │ ├── relational-operator.diffB-A.txt │ │ │ ├── relational-operator.parseA.txt │ │ │ ├── relational-operator.parseB.txt │ │ │ ├── return-statement.A.js │ │ │ ├── return-statement.B.js │ │ │ ├── return-statement.diffA-B.txt │ │ │ ├── return-statement.diffB-A.txt │ │ │ ├── return-statement.parseA.txt │ │ │ ├── return-statement.parseB.txt │ │ │ ├── string.A.js │ │ │ ├── string.B.js │ │ │ ├── string.diffA-B.txt │ │ │ ├── string.diffB-A.txt │ │ │ ├── string.parseA.txt │ │ │ ├── string.parseB.txt │ │ │ ├── subscript-access-assignment.A.js │ │ │ ├── subscript-access-assignment.B.js │ │ │ ├── subscript-access-assignment.diffA-B.txt │ │ │ ├── subscript-access-assignment.diffB-A.txt │ │ │ ├── subscript-access-assignment.parseA.txt │ │ │ ├── subscript-access-assignment.parseB.txt │ │ │ ├── subscript-access-string.A.js │ │ │ ├── subscript-access-string.B.js │ │ │ ├── subscript-access-string.diffA-B.txt │ │ │ ├── subscript-access-string.diffB-A.txt │ │ │ ├── subscript-access-string.parseA.txt │ │ │ ├── subscript-access-string.parseB.txt │ │ │ ├── subscript-access-variable.A.js │ │ │ ├── subscript-access-variable.B.js │ │ │ ├── subscript-access-variable.diffA-B.txt │ │ │ ├── subscript-access-variable.diffB-A.txt │ │ │ ├── subscript-access-variable.parseA.txt │ │ │ ├── subscript-access-variable.parseB.txt │ │ │ ├── switch-statement.A.js │ │ │ ├── switch-statement.B.js │ │ │ ├── switch-statement.diffA-B.txt │ │ │ ├── switch-statement.diffB-A.txt │ │ │ ├── switch-statement.parseA.txt │ │ │ ├── switch-statement.parseB.txt │ │ │ ├── template-string.A.js │ │ │ ├── template-string.B.js │ │ │ ├── template-string.diffA-B.txt │ │ │ ├── template-string.diffB-A.txt │ │ │ ├── template-string.parseA.txt │ │ │ ├── template-string.parseB.txt │ │ │ ├── ternary.A.js │ │ │ ├── ternary.B.js │ │ │ ├── ternary.diffA-B.txt │ │ │ ├── ternary.diffB-A.txt │ │ │ ├── ternary.parseA.txt │ │ │ ├── ternary.parseB.txt │ │ │ ├── this-expression.A.js │ │ │ ├── this-expression.B.js │ │ │ ├── this-expression.diffA-B.txt │ │ │ ├── this-expression.diffB-A.txt │ │ │ ├── this-expression.parseA.txt │ │ │ ├── this-expression.parseB.txt │ │ │ ├── throw-statement.A.js │ │ │ ├── throw-statement.B.js │ │ │ ├── throw-statement.diffA-B.txt │ │ │ ├── throw-statement.diffB-A.txt │ │ │ ├── throw-statement.parseA.txt │ │ │ ├── throw-statement.parseB.txt │ │ │ ├── true.A.js │ │ │ ├── true.B.js │ │ │ ├── true.diffA-B.txt │ │ │ ├── true.diffB-A.txt │ │ │ ├── true.parseA.txt │ │ │ ├── true.parseB.txt │ │ │ ├── try-statement.A.js │ │ │ ├── try-statement.B.js │ │ │ ├── try-statement.diffA-B.txt │ │ │ ├── try-statement.diffB-A.txt │ │ │ ├── try-statement.parseA.txt │ │ │ ├── try-statement.parseB.txt │ │ │ ├── type-operator.A.js │ │ │ ├── type-operator.B.js │ │ │ ├── type-operator.diffA-B.txt │ │ │ ├── type-operator.diffB-A.txt │ │ │ ├── type-operator.parseA.txt │ │ │ ├── type-operator.parseB.txt │ │ │ ├── undefined.A.js │ │ │ ├── undefined.B.js │ │ │ ├── undefined.diffA-B.txt │ │ │ ├── undefined.diffB-A.txt │ │ │ ├── undefined.parseA.txt │ │ │ ├── undefined.parseB.txt │ │ │ ├── var-declaration.A.js │ │ │ ├── var-declaration.B.js │ │ │ ├── var-declaration.diffA-B.txt │ │ │ ├── var-declaration.diffB-A.txt │ │ │ ├── var-declaration.parseA.txt │ │ │ ├── var-declaration.parseB.txt │ │ │ ├── variable.A.js │ │ │ ├── variable.B.js │ │ │ ├── variable.diffA-B.txt │ │ │ ├── variable.diffB-A.txt │ │ │ ├── variable.parseA.txt │ │ │ ├── variable.parseB.txt │ │ │ ├── variadic-function-declarations.parseA.txt │ │ │ ├── void-operator.A.js │ │ │ ├── void-operator.B.js │ │ │ ├── void-operator.diffA-B.txt │ │ │ ├── void-operator.diffB-A.txt │ │ │ ├── void-operator.parseA.txt │ │ │ ├── void-operator.parseB.txt │ │ │ ├── while-statement.A.js │ │ │ ├── while-statement.B.js │ │ │ ├── while-statement.diffA-B.txt │ │ │ ├── while-statement.diffB-A.txt │ │ │ ├── while-statement.parseA.txt │ │ │ ├── while-statement.parseB.txt │ │ │ ├── yield.A.js │ │ │ ├── yield.B.js │ │ │ ├── yield.diffA-B.txt │ │ │ ├── yield.diffB-A.txt │ │ │ ├── yield.parseA.txt │ │ │ └── yield.parseB.txt │ │ ├── reprinting/ │ │ │ └── map.json │ │ ├── tags/ │ │ │ └── simple_function_with_docs.js │ │ └── toc/ │ │ ├── duplicate-parent.A.js │ │ ├── duplicate-parent.B.js │ │ ├── erroneous-duplicate-method.A.js │ │ ├── erroneous-duplicate-method.B.js │ │ └── starts-with-newline.js │ ├── json/ │ │ ├── corpus/ │ │ │ ├── array.A.json │ │ │ ├── array.B.json │ │ │ ├── array.parseA.txt │ │ │ ├── array.parseB.txt │ │ │ ├── boolean.A.json │ │ │ ├── boolean.B.json │ │ │ ├── boolean.parseA.txt │ │ │ ├── boolean.parseB.txt │ │ │ ├── hash.A.json │ │ │ ├── hash.B.json │ │ │ ├── hash.parseA.txt │ │ │ ├── hash.parseB.txt │ │ │ ├── null.A.json │ │ │ ├── null.B.json │ │ │ ├── null.parseA.txt │ │ │ ├── null.parseB.txt │ │ │ ├── number.A.json │ │ │ ├── number.B.json │ │ │ ├── number.parseA.txt │ │ │ ├── number.parseB.txt │ │ │ ├── string.A.json │ │ │ ├── string.B.json │ │ │ ├── string.parseA.txt │ │ │ └── string.parseB.txt │ │ └── rewriting/ │ │ ├── add_keys.json │ │ └── add_keys_expected.json │ ├── markdown/ │ │ ├── corpus/ │ │ │ └── example.A.md │ │ └── toc/ │ │ ├── headings.A.md │ │ └── headings.B.md │ ├── php/ │ │ └── analysis/ │ │ ├── bar.php │ │ ├── foo.php │ │ ├── main.php │ │ ├── main_once.php │ │ └── namespaces.php │ ├── python/ │ │ ├── analysis/ │ │ │ ├── a.py │ │ │ ├── b/ │ │ │ │ ├── __init__.py │ │ │ │ └── c.py │ │ │ ├── c/ │ │ │ │ ├── __init__.py │ │ │ │ └── utils.py │ │ │ ├── main.py │ │ │ ├── main1.py │ │ │ ├── main2.py │ │ │ ├── main3.py │ │ │ ├── multiple_inheritance.py │ │ │ └── subclass.py │ │ ├── corpus/ │ │ │ ├── assert-statement.A.py │ │ │ ├── assert-statement.B.py │ │ │ ├── assert-statement.diffA-B.txt │ │ │ ├── assert-statement.diffB-A.txt │ │ │ ├── assert-statement.parseA.txt │ │ │ ├── assert-statement.parseB.txt │ │ │ ├── assignment.A.py │ │ │ ├── assignment.B.py │ │ │ ├── assignment.diffA-B.txt │ │ │ ├── assignment.diffB-A.txt │ │ │ ├── assignment.parseA.txt │ │ │ ├── assignment.parseB.txt │ │ │ ├── async-function-definition.A.py │ │ │ ├── async-function-definition.B.py │ │ │ ├── async-function-definition.diffA-B.txt │ │ │ ├── async-function-definition.diffB-A.txt │ │ │ ├── async-function-definition.parseA.txt │ │ │ ├── async-function-definition.parseB.txt │ │ │ ├── attribute.A.py │ │ │ ├── attribute.B.py │ │ │ ├── attribute.diffA-B.txt │ │ │ ├── attribute.diffB-A.txt │ │ │ ├── attribute.parseA.txt │ │ │ ├── attribute.parseB.txt │ │ │ ├── augmented-assignment.A.py │ │ │ ├── augmented-assignment.B.py │ │ │ ├── augmented-assignment.diffA-B.txt │ │ │ ├── augmented-assignment.diffB-A.txt │ │ │ ├── augmented-assignment.parseA.txt │ │ │ ├── augmented-assignment.parseB.txt │ │ │ ├── await.A.py │ │ │ ├── await.B.py │ │ │ ├── await.diffA-B.txt │ │ │ ├── await.diffB-A.txt │ │ │ ├── await.parseA.txt │ │ │ ├── await.parseB.txt │ │ │ ├── binary-operator.A.py │ │ │ ├── binary-operator.B.py │ │ │ ├── binary-operator.diffA-B.txt │ │ │ ├── binary-operator.diffB-A.txt │ │ │ ├── binary-operator.parseA.txt │ │ │ ├── binary-operator.parseB.txt │ │ │ ├── boolean-operator.A.py │ │ │ ├── boolean-operator.B.py │ │ │ ├── boolean-operator.diffA-B.txt │ │ │ ├── boolean-operator.diffB-A.txt │ │ │ ├── boolean-operator.parseA.txt │ │ │ ├── boolean-operator.parseB.txt │ │ │ ├── boolean.A.py │ │ │ ├── boolean.B.py │ │ │ ├── boolean.diffA-B.txt │ │ │ ├── boolean.diffB-A.txt │ │ │ ├── boolean.parseA.txt │ │ │ ├── boolean.parseB.txt │ │ │ ├── break-statement.A.py │ │ │ ├── break-statement.B.py │ │ │ ├── break-statement.diffA-B.txt │ │ │ ├── break-statement.diffB-A.txt │ │ │ ├── break-statement.parseA.txt │ │ │ ├── break-statement.parseB.txt │ │ │ ├── call.A.py │ │ │ ├── call.B.py │ │ │ ├── call.diffA-B.txt │ │ │ ├── call.diffB-A.txt │ │ │ ├── call.parseA.txt │ │ │ ├── call.parseB.txt │ │ │ ├── class-definition.A.py │ │ │ ├── class-definition.B.py │ │ │ ├── class-definition.diffA-B.txt │ │ │ ├── class-definition.diffB-A.txt │ │ │ ├── class-definition.parseA.txt │ │ │ ├── class-definition.parseB.txt │ │ │ ├── comment.A.py │ │ │ ├── comment.B.py │ │ │ ├── comment.diffA-B.txt │ │ │ ├── comment.diffB-A.txt │ │ │ ├── comment.parseA.txt │ │ │ ├── comment.parseB.txt │ │ │ ├── comparison-operator.A.py │ │ │ ├── comparison-operator.B.py │ │ │ ├── comparison-operator.diffA-B.txt │ │ │ ├── comparison-operator.diffB-A.txt │ │ │ ├── comparison-operator.parseA.txt │ │ │ ├── comparison-operator.parseB.txt │ │ │ ├── concatenated-string.A.py │ │ │ ├── concatenated-string.B.py │ │ │ ├── concatenated-string.diffA-B.txt │ │ │ ├── concatenated-string.diffB-A.txt │ │ │ ├── concatenated-string.parseA.txt │ │ │ ├── concatenated-string.parseB.txt │ │ │ ├── conditional-expression.A.py │ │ │ ├── conditional-expression.B.py │ │ │ ├── conditional-expression.diffA-B.txt │ │ │ ├── conditional-expression.diffB-A.txt │ │ │ ├── conditional-expression.parseA.txt │ │ │ ├── conditional-expression.parseB.txt │ │ │ ├── continue-statement.A.py │ │ │ ├── continue-statement.B.py │ │ │ ├── continue-statement.diffA-B.txt │ │ │ ├── continue-statement.diffB-A.txt │ │ │ ├── continue-statement.parseA.txt │ │ │ ├── continue-statement.parseB.txt │ │ │ ├── decorated-definition.A.py │ │ │ ├── decorated-definition.B.py │ │ │ ├── decorated-definition.diffA-B.txt │ │ │ ├── decorated-definition.diffB-A.txt │ │ │ ├── decorated-definition.parseA.txt │ │ │ ├── decorated-definition.parseB.txt │ │ │ ├── delete-statement.A.py │ │ │ ├── delete-statement.B.py │ │ │ ├── delete-statement.diffA-B.txt │ │ │ ├── delete-statement.diffB-A.txt │ │ │ ├── delete-statement.parseA.txt │ │ │ ├── delete-statement.parseB.txt │ │ │ ├── dictionary-comprehension.A.py │ │ │ ├── dictionary-comprehension.B.py │ │ │ ├── dictionary-comprehension.diffA-B.txt │ │ │ ├── dictionary-comprehension.diffB-A.txt │ │ │ ├── dictionary-comprehension.parseA.txt │ │ │ ├── dictionary-comprehension.parseB.txt │ │ │ ├── dictionary.A.py │ │ │ ├── dictionary.B.py │ │ │ ├── dictionary.diffA-B.txt │ │ │ ├── dictionary.diffB-A.txt │ │ │ ├── dictionary.parseA.txt │ │ │ ├── dictionary.parseB.txt │ │ │ ├── dotted-name.A.py │ │ │ ├── dotted-name.B.py │ │ │ ├── dotted-name.diffA-B.txt │ │ │ ├── dotted-name.diffB-A.txt │ │ │ ├── dotted-name.parseA.txt │ │ │ ├── dotted-name.parseB.txt │ │ │ ├── ellipsis.A.py │ │ │ ├── ellipsis.B.py │ │ │ ├── ellipsis.diffA-B.txt │ │ │ ├── ellipsis.diffB-A.txt │ │ │ ├── ellipsis.parseA.txt │ │ │ ├── ellipsis.parseB.txt │ │ │ ├── exec-statement.A.py │ │ │ ├── exec-statement.B.py │ │ │ ├── exec-statement.diffA-B.txt │ │ │ ├── exec-statement.diffB-A.txt │ │ │ ├── exec-statement.parseA.txt │ │ │ ├── exec-statement.parseB.txt │ │ │ ├── expression-statement.A.py │ │ │ ├── expression-statement.B.py │ │ │ ├── expression-statement.diffA-B.txt │ │ │ ├── expression-statement.diffB-A.txt │ │ │ ├── expression-statement.parseA.txt │ │ │ ├── expression-statement.parseB.txt │ │ │ ├── float.A.py │ │ │ ├── float.B.py │ │ │ ├── float.diffA-B.txt │ │ │ ├── float.diffB-A.txt │ │ │ ├── float.parseA.txt │ │ │ ├── float.parseB.txt │ │ │ ├── for-statement.A.py │ │ │ ├── for-statement.B.py │ │ │ ├── for-statement.diffA-B.txt │ │ │ ├── for-statement.diffB-A.txt │ │ │ ├── for-statement.parseA.txt │ │ │ ├── for-statement.parseB.txt │ │ │ ├── function-definition.A.py │ │ │ ├── function-definition.B.py │ │ │ ├── function-definition.diffA-B.txt │ │ │ ├── function-definition.diffB-A.txt │ │ │ ├── function-definition.parseA.txt │ │ │ ├── function-definition.parseB.txt │ │ │ ├── future_import_statement.A.py │ │ │ ├── future_import_statement.B.py │ │ │ ├── future_import_statement.diffA-B.txt │ │ │ ├── future_import_statement.diffB-A.txt │ │ │ ├── future_import_statement.parseA.txt │ │ │ ├── future_import_statement.parseB.txt │ │ │ ├── generator-expression.A.py │ │ │ ├── generator-expression.B.py │ │ │ ├── generator-expression.diffA-B.txt │ │ │ ├── generator-expression.diffB-A.txt │ │ │ ├── generator-expression.parseA.txt │ │ │ ├── generator-expression.parseB.txt │ │ │ ├── global-statement.A.py │ │ │ ├── global-statement.B.py │ │ │ ├── global-statement.diffA-B.txt │ │ │ ├── global-statement.diffB-A.txt │ │ │ ├── global-statement.parseA.txt │ │ │ ├── global-statement.parseB.txt │ │ │ ├── identifier.A.py │ │ │ ├── identifier.B.py │ │ │ ├── identifier.diffA-B.txt │ │ │ ├── identifier.diffB-A.txt │ │ │ ├── identifier.parseA.txt │ │ │ ├── identifier.parseB.txt │ │ │ ├── if-statement.A.py │ │ │ ├── if-statement.B.py │ │ │ ├── if-statement.diffA-B.txt │ │ │ ├── if-statement.diffB-A.txt │ │ │ ├── if-statement.parseA.txt │ │ │ ├── if-statement.parseB.txt │ │ │ ├── import-from-statement.A.py │ │ │ ├── import-from-statement.B.py │ │ │ ├── import-from-statement.diffA-B.txt │ │ │ ├── import-from-statement.diffB-A.txt │ │ │ ├── import-from-statement.parseA.txt │ │ │ ├── import-from-statement.parseB.txt │ │ │ ├── import-statement.A.py │ │ │ ├── import-statement.B.py │ │ │ ├── import-statement.diffA-B.txt │ │ │ ├── import-statement.diffB-A.txt │ │ │ ├── import-statement.parseA.txt │ │ │ ├── import-statement.parseB.txt │ │ │ ├── integer.A.py │ │ │ ├── integer.B.py │ │ │ ├── integer.diffA-B.txt │ │ │ ├── integer.diffB-A.txt │ │ │ ├── integer.parseA.txt │ │ │ ├── integer.parseB.txt │ │ │ ├── keyword-identifier.A.py │ │ │ ├── keyword-identifier.B.py │ │ │ ├── keyword-identifier.diffA-B.txt │ │ │ ├── keyword-identifier.diffB-A.txt │ │ │ ├── keyword-identifier.parseA.txt │ │ │ ├── keyword-identifier.parseB.txt │ │ │ ├── lambda.A.py │ │ │ ├── lambda.B.py │ │ │ ├── lambda.diffA-B.txt │ │ │ ├── lambda.diffB-A.txt │ │ │ ├── lambda.parseA.txt │ │ │ ├── lambda.parseB.txt │ │ │ ├── list-comprehension.A.py │ │ │ ├── list-comprehension.B.py │ │ │ ├── list-comprehension.diffA-B.txt │ │ │ ├── list-comprehension.diffB-A.txt │ │ │ ├── list-comprehension.parseA.txt │ │ │ ├── list-comprehension.parseB.txt │ │ │ ├── list.A.py │ │ │ ├── list.B.py │ │ │ ├── list.diffA-B.txt │ │ │ ├── list.diffB-A.txt │ │ │ ├── list.parseA.txt │ │ │ ├── list.parseB.txt │ │ │ ├── non-local-statement.A.py │ │ │ ├── non-local-statement.B.py │ │ │ ├── non-local-statement.diffA-B.txt │ │ │ ├── non-local-statement.diffB-A.txt │ │ │ ├── non-local-statement.parseA.txt │ │ │ ├── non-local-statement.parseB.txt │ │ │ ├── none.A.py │ │ │ ├── none.B.py │ │ │ ├── none.diffA-B.txt │ │ │ ├── none.diffB-A.txt │ │ │ ├── none.parseA.txt │ │ │ ├── none.parseB.txt │ │ │ ├── not.A.py │ │ │ ├── not.B.py │ │ │ ├── not.diffA-B.txt │ │ │ ├── not.diffB-A.txt │ │ │ ├── not.parseA.txt │ │ │ ├── not.parseB.txt │ │ │ ├── pass-statement.A.py │ │ │ ├── pass-statement.B.py │ │ │ ├── pass-statement.diffA-B.txt │ │ │ ├── pass-statement.diffB-A.txt │ │ │ ├── pass-statement.parseA.txt │ │ │ ├── pass-statement.parseB.txt │ │ │ ├── print-statement.A.py │ │ │ ├── print-statement.B.py │ │ │ ├── print-statement.diffA-B.txt │ │ │ ├── print-statement.diffB-A.txt │ │ │ ├── print-statement.parseA.txt │ │ │ ├── print-statement.parseB.txt │ │ │ ├── raise-statement.A.py │ │ │ ├── raise-statement.B.py │ │ │ ├── raise-statement.diffA-B.txt │ │ │ ├── raise-statement.diffB-A.txt │ │ │ ├── raise-statement.parseA.txt │ │ │ ├── raise-statement.parseB.txt │ │ │ ├── return-statement.A.py │ │ │ ├── return-statement.B.py │ │ │ ├── return-statement.diffA-B.txt │ │ │ ├── return-statement.diffB-A.txt │ │ │ ├── return-statement.parseA.txt │ │ │ ├── return-statement.parseB.txt │ │ │ ├── set-comprehension.A.py │ │ │ ├── set-comprehension.B.py │ │ │ ├── set-comprehension.diffA-B.txt │ │ │ ├── set-comprehension.diffB-A.txt │ │ │ ├── set-comprehension.parseA.txt │ │ │ ├── set-comprehension.parseB.txt │ │ │ ├── set.A.py │ │ │ ├── set.B.py │ │ │ ├── set.diffA-B.txt │ │ │ ├── set.diffB-A.txt │ │ │ ├── set.parseA.txt │ │ │ ├── set.parseB.txt │ │ │ ├── slice.A.py │ │ │ ├── slice.B.py │ │ │ ├── slice.diffA-B.txt │ │ │ ├── slice.diffB-A.txt │ │ │ ├── slice.parseA.txt │ │ │ ├── slice.parseB.txt │ │ │ ├── string.A.py │ │ │ ├── string.B.py │ │ │ ├── string.diffA-B.txt │ │ │ ├── string.diffB-A.txt │ │ │ ├── string.parseA.txt │ │ │ ├── string.parseB.txt │ │ │ ├── subscript.A.py │ │ │ ├── subscript.B.py │ │ │ ├── subscript.diffA-B.txt │ │ │ ├── subscript.diffB-A.txt │ │ │ ├── subscript.parseA.txt │ │ │ ├── subscript.parseB.txt │ │ │ ├── try-statement.A.py │ │ │ ├── try-statement.B.py │ │ │ ├── try-statement.diffA-B.txt │ │ │ ├── try-statement.diffB-A.txt │ │ │ ├── try-statement.parseA.txt │ │ │ ├── try-statement.parseB.txt │ │ │ ├── tuple.A.py │ │ │ ├── tuple.B.py │ │ │ ├── tuple.diffA-B.txt │ │ │ ├── tuple.diffB-A.txt │ │ │ ├── tuple.parseA.txt │ │ │ ├── tuple.parseB.txt │ │ │ ├── unary-operator.A.py │ │ │ ├── unary-operator.B.py │ │ │ ├── unary-operator.diffA-B.txt │ │ │ ├── unary-operator.diffB-A.txt │ │ │ ├── unary-operator.parseA.txt │ │ │ ├── unary-operator.parseB.txt │ │ │ ├── while-statement.A.py │ │ │ ├── while-statement.B.py │ │ │ ├── while-statement.diffA-B.txt │ │ │ ├── while-statement.diffB-A.txt │ │ │ ├── while-statement.parseA.txt │ │ │ ├── while-statement.parseB.txt │ │ │ ├── with-statement.A.py │ │ │ ├── with-statement.B.py │ │ │ ├── with-statement.diffA-B.txt │ │ │ ├── with-statement.diffB-A.txt │ │ │ ├── with-statement.parseA.txt │ │ │ ├── with-statement.parseB.txt │ │ │ ├── with.A.py │ │ │ ├── with.B.py │ │ │ ├── with.diffA-B.txt │ │ │ ├── with.diffB-A.txt │ │ │ ├── with.parseA.txt │ │ │ ├── with.parseB.txt │ │ │ ├── yield.A.py │ │ │ ├── yield.B.py │ │ │ ├── yield.diffA-B.txt │ │ │ ├── yield.diffB-A.txt │ │ │ ├── yield.parseA.txt │ │ │ └── yield.parseB.txt │ │ ├── graphing/ │ │ │ ├── conditional/ │ │ │ │ └── conditional.py │ │ │ ├── simple/ │ │ │ │ └── simple.py │ │ │ ├── typeerror/ │ │ │ │ └── typeerror.py │ │ │ └── unbound/ │ │ │ └── unbound.py │ │ ├── import-graph/ │ │ │ ├── main.json │ │ │ └── main.py │ │ ├── matching/ │ │ │ ├── docstrings.py │ │ │ └── docstrings_nested.py │ │ ├── reprinting/ │ │ │ ├── function.out.py │ │ │ └── function.py │ │ └── tags/ │ │ ├── class.py │ │ ├── multiline.py │ │ ├── simple_function_with_docs.py │ │ └── simple_functions.py │ ├── ruby/ │ │ ├── analysis/ │ │ │ ├── break.rb │ │ │ ├── call.rb │ │ │ ├── classes.rb │ │ │ ├── early-return.rb │ │ │ ├── foo.rb │ │ │ ├── line.rb │ │ │ ├── load-wrap.rb │ │ │ ├── load.rb │ │ │ ├── main.rb │ │ │ ├── modules.rb │ │ │ ├── next.rb │ │ │ ├── preluded.rb │ │ │ ├── puts.rb │ │ │ ├── src/ │ │ │ │ ├── foo.rb │ │ │ │ └── main.rb │ │ │ └── subclass.rb │ │ ├── corpus/ │ │ │ ├── alias.A.rb │ │ │ ├── alias.parseA.txt │ │ │ ├── and-or.A.rb │ │ │ ├── and-or.B.rb │ │ │ ├── and-or.diffA-B.txt │ │ │ ├── and-or.diffB-A.txt │ │ │ ├── and-or.parseA.txt │ │ │ ├── and-or.parseB.txt │ │ │ ├── array.A.rb │ │ │ ├── array.B.rb │ │ │ ├── array.diffA-B.txt │ │ │ ├── array.diffB-A.txt │ │ │ ├── array.parseA.txt │ │ │ ├── array.parseB.txt │ │ │ ├── assignment.A.rb │ │ │ ├── assignment.B.rb │ │ │ ├── assignment.diffA-B.txt │ │ │ ├── assignment.diffB-A.txt │ │ │ ├── assignment.parseA.txt │ │ │ ├── assignment.parseB.txt │ │ │ ├── begin-block.A.rb │ │ │ ├── begin-block.B.rb │ │ │ ├── begin-block.diffA-B.txt │ │ │ ├── begin-block.diffB-A.txt │ │ │ ├── begin-block.parseA.txt │ │ │ ├── begin-block.parseB.txt │ │ │ ├── begin.A.rb │ │ │ ├── begin.B.rb │ │ │ ├── begin.diffA-B.txt │ │ │ ├── begin.diffB-A.txt │ │ │ ├── begin.parseA.txt │ │ │ ├── begin.parseB.txt │ │ │ ├── binary.A.rb │ │ │ ├── binary.parseA.txt │ │ │ ├── bitwise-operator.A.rb │ │ │ ├── bitwise-operator.B.rb │ │ │ ├── bitwise-operator.diffA-B.txt │ │ │ ├── bitwise-operator.diffB-A.txt │ │ │ ├── bitwise-operator.parseA.txt │ │ │ ├── bitwise-operator.parseB.txt │ │ │ ├── boolean-operator.A.rb │ │ │ ├── boolean-operator.B.rb │ │ │ ├── boolean-operator.diffA-B.txt │ │ │ ├── boolean-operator.diffB-A.txt │ │ │ ├── boolean-operator.parseA.txt │ │ │ ├── boolean-operator.parseB.txt │ │ │ ├── break.A.rb │ │ │ ├── break.B.rb │ │ │ ├── break.diffA-B.txt │ │ │ ├── break.diffB-A.txt │ │ │ ├── break.parseA.txt │ │ │ ├── break.parseB.txt │ │ │ ├── calls.A.rb │ │ │ ├── calls.parseA.txt │ │ │ ├── chained-string.A.rb │ │ │ ├── chained-string.parseA.txt │ │ │ ├── class.A.rb │ │ │ ├── class.B.rb │ │ │ ├── class.diffA-B.txt │ │ │ ├── class.diffB-A.txt │ │ │ ├── class.parseA.txt │ │ │ ├── class.parseB.txt │ │ │ ├── comment.A.rb │ │ │ ├── comment.B.rb │ │ │ ├── comment.diffA-B.txt │ │ │ ├── comment.diffB-A.txt │ │ │ ├── comment.parseA.txt │ │ │ ├── comment.parseB.txt │ │ │ ├── comparision-operator.A.rb │ │ │ ├── comparision-operator.B.rb │ │ │ ├── comparision-operator.diffA-B.txt │ │ │ ├── comparision-operator.diffB-A.txt │ │ │ ├── comparision-operator.parseA.txt │ │ │ ├── comparision-operator.parseB.txt │ │ │ ├── conditional-assignment.A.rb │ │ │ ├── conditional-assignment.B.rb │ │ │ ├── conditional-assignment.diffA-B.txt │ │ │ ├── conditional-assignment.diffB-A.txt │ │ │ ├── conditional-assignment.parseA.txt │ │ │ ├── conditional-assignment.parseB.txt │ │ │ ├── delimiter.A.rb │ │ │ ├── delimiter.B.rb │ │ │ ├── delimiter.diffA-B.txt │ │ │ ├── delimiter.diffB-A.txt │ │ │ ├── delimiter.parseA.txt │ │ │ ├── delimiter.parseB.txt │ │ │ ├── element-reference.A.rb │ │ │ ├── element-reference.B.rb │ │ │ ├── element-reference.diffA-B.txt │ │ │ ├── element-reference.diffB-A.txt │ │ │ ├── element-reference.parseA.txt │ │ │ ├── element-reference.parseB.txt │ │ │ ├── else.A.rb │ │ │ ├── else.B.rb │ │ │ ├── else.diffA-B.txt │ │ │ ├── else.diffB-A.txt │ │ │ ├── else.parseA.txt │ │ │ ├── else.parseB.txt │ │ │ ├── elsif.A.rb │ │ │ ├── elsif.B.rb │ │ │ ├── elsif.diffA-B.txt │ │ │ ├── elsif.diffB-A.txt │ │ │ ├── elsif.parseA.txt │ │ │ ├── elsif.parseB.txt │ │ │ ├── empty-statement.A.rb │ │ │ ├── empty-statement.parseA.txt │ │ │ ├── end-block.A.rb │ │ │ ├── end-block.B.rb │ │ │ ├── end-block.diffA-B.txt │ │ │ ├── end-block.diffB-A.txt │ │ │ ├── end-block.parseA.txt │ │ │ ├── end-block.parseB.txt │ │ │ ├── ensure.A.rb │ │ │ ├── ensure.B.rb │ │ │ ├── ensure.diffA-B.txt │ │ │ ├── ensure.diffB-A.txt │ │ │ ├── ensure.parseA.txt │ │ │ ├── ensure.parseB.txt │ │ │ ├── for.A.rb │ │ │ ├── for.B.rb │ │ │ ├── for.diffA-B.txt │ │ │ ├── for.diffB-A.txt │ │ │ ├── for.parseA.txt │ │ │ ├── for.parseB.txt │ │ │ ├── hash.A.rb │ │ │ ├── hash.B.rb │ │ │ ├── hash.diffA-B.txt │ │ │ ├── hash.diffB-A.txt │ │ │ ├── hash.parseA.txt │ │ │ ├── hash.parseB.txt │ │ │ ├── heredoc.A.rb │ │ │ ├── heredoc.B.rb │ │ │ ├── heredoc.diffA-B.txt │ │ │ ├── heredoc.diffB-A.txt │ │ │ ├── heredoc.parseA.txt │ │ │ ├── heredoc.parseB.txt │ │ │ ├── if-unless-modifiers.A.rb │ │ │ ├── if-unless-modifiers.B.rb │ │ │ ├── if-unless-modifiers.diffA-B.txt │ │ │ ├── if-unless-modifiers.diffB-A.txt │ │ │ ├── if-unless-modifiers.parseA.txt │ │ │ ├── if-unless-modifiers.parseB.txt │ │ │ ├── if.A.rb │ │ │ ├── if.B.rb │ │ │ ├── if.diffA-B.txt │ │ │ ├── if.diffB-A.txt │ │ │ ├── if.parseA.txt │ │ │ ├── if.parseB.txt │ │ │ ├── interpolation.A.rb │ │ │ ├── interpolation.B.rb │ │ │ ├── interpolation.diffA-B.txt │ │ │ ├── interpolation.diffB-A.txt │ │ │ ├── interpolation.parseA.txt │ │ │ ├── interpolation.parseB.txt │ │ │ ├── keywords.A.rb │ │ │ ├── keywords.parseA.txt │ │ │ ├── lambda-dash-rocket.A.rb │ │ │ ├── lambda-dash-rocket.B.rb │ │ │ ├── lambda-dash-rocket.diffA-B.txt │ │ │ ├── lambda-dash-rocket.diffB-A.txt │ │ │ ├── lambda-dash-rocket.parseA.txt │ │ │ ├── lambda-dash-rocket.parseB.txt │ │ │ ├── lambda.A.rb │ │ │ ├── lambda.B.rb │ │ │ ├── lambda.diffA-B.txt │ │ │ ├── lambda.diffB-A.txt │ │ │ ├── lambda.parseA.txt │ │ │ ├── lambda.parseB.txt │ │ │ ├── literals.A.rb │ │ │ ├── literals.parseA.txt │ │ │ ├── math-assignment.A.rb │ │ │ ├── math-assignment.B.rb │ │ │ ├── math-assignment.diffA-B.txt │ │ │ ├── math-assignment.diffB-A.txt │ │ │ ├── math-assignment.parseA.txt │ │ │ ├── math-assignment.parseB.txt │ │ │ ├── method-calls-hash-args.A.rb │ │ │ ├── method-calls-hash-args.B.rb │ │ │ ├── method-calls-hash-args.diffA-B.txt │ │ │ ├── method-calls-hash-args.diffB-A.txt │ │ │ ├── method-calls-hash-args.parseA.txt │ │ │ ├── method-calls-hash-args.parseB.txt │ │ │ ├── method-calls-keyword-args.A.rb │ │ │ ├── method-calls-keyword-args.B.rb │ │ │ ├── method-calls-keyword-args.diffA-B.txt │ │ │ ├── method-calls-keyword-args.diffB-A.txt │ │ │ ├── method-calls-keyword-args.parseA.txt │ │ │ ├── method-calls-keyword-args.parseB.txt │ │ │ ├── method-calls.A.rb │ │ │ ├── method-calls.B.rb │ │ │ ├── method-calls.diffA-B.txt │ │ │ ├── method-calls.diffB-A.txt │ │ │ ├── method-calls.parseA.txt │ │ │ ├── method-calls.parseB.txt │ │ │ ├── method-declaration-keyword-param.A.rb │ │ │ ├── method-declaration-keyword-param.B.rb │ │ │ ├── method-declaration-keyword-param.diffA-B.txt │ │ │ ├── method-declaration-keyword-param.diffB-A.txt │ │ │ ├── method-declaration-keyword-param.parseA.txt │ │ │ ├── method-declaration-keyword-param.parseB.txt │ │ │ ├── method-declaration-param-default.A.rb │ │ │ ├── method-declaration-param-default.B.rb │ │ │ ├── method-declaration-param-default.diffA-B.txt │ │ │ ├── method-declaration-param-default.diffB-A.txt │ │ │ ├── method-declaration-param-default.parseA.txt │ │ │ ├── method-declaration-param-default.parseB.txt │ │ │ ├── method-declaration-params.A.rb │ │ │ ├── method-declaration-params.B.rb │ │ │ ├── method-declaration-params.diffA-B.txt │ │ │ ├── method-declaration-params.diffB-A.txt │ │ │ ├── method-declaration-params.parseA.txt │ │ │ ├── method-declaration-params.parseB.txt │ │ │ ├── method-declaration-required-keyword-param.A.rb │ │ │ ├── method-declaration-required-keyword-param.B.rb │ │ │ ├── method-declaration-required-keyword-param.diffA-B.txt │ │ │ ├── method-declaration-required-keyword-param.diffB-A.txt │ │ │ ├── method-declaration-required-keyword-param.parseA.txt │ │ │ ├── method-declaration-required-keyword-param.parseB.txt │ │ │ ├── method-declaration-unnamed-param.A.rb │ │ │ ├── method-declaration-unnamed-param.B.rb │ │ │ ├── method-declaration-unnamed-param.diffA-B.txt │ │ │ ├── method-declaration-unnamed-param.diffB-A.txt │ │ │ ├── method-declaration-unnamed-param.parseA.txt │ │ │ ├── method-declaration-unnamed-param.parseB.txt │ │ │ ├── method-declaration.A.rb │ │ │ ├── method-declaration.B.rb │ │ │ ├── method-declaration.diffA-B.txt │ │ │ ├── method-declaration.diffB-A.txt │ │ │ ├── method-declaration.parseA.txt │ │ │ ├── method-declaration.parseB.txt │ │ │ ├── method-invocation.A.rb │ │ │ ├── method-invocation.B.rb │ │ │ ├── method-invocation.diffA-B.txt │ │ │ ├── method-invocation.diffB-A.txt │ │ │ ├── method-invocation.parseA.txt │ │ │ ├── method-invocation.parseB.txt │ │ │ ├── methods.A.rb │ │ │ ├── methods.parseA.txt │ │ │ ├── misc.A.rb │ │ │ ├── misc.parseA.txt │ │ │ ├── module.A.rb │ │ │ ├── module.B.rb │ │ │ ├── module.diffA-B.txt │ │ │ ├── module.diffB-A.txt │ │ │ ├── module.parseA.txt │ │ │ ├── module.parseB.txt │ │ │ ├── multiple-assignments.A.rb │ │ │ ├── multiple-assignments.B.rb │ │ │ ├── multiple-assignments.diffA-B.txt │ │ │ ├── multiple-assignments.diffB-A.txt │ │ │ ├── multiple-assignments.parseA.txt │ │ │ ├── multiple-assignments.parseB.txt │ │ │ ├── next.A.rb │ │ │ ├── next.parseA.txt │ │ │ ├── number.A.rb │ │ │ ├── number.B.rb │ │ │ ├── number.diffA-B.txt │ │ │ ├── number.diffB-A.txt │ │ │ ├── number.parseA.txt │ │ │ ├── number.parseB.txt │ │ │ ├── percent-array.A.rb │ │ │ ├── percent-array.B.rb │ │ │ ├── percent-array.diffA-B.txt │ │ │ ├── percent-array.diffB-A.txt │ │ │ ├── percent-array.parseA.txt │ │ │ ├── percent-array.parseB.txt │ │ │ ├── pseudo-variables.A.rb │ │ │ ├── pseudo-variables.B.rb │ │ │ ├── pseudo-variables.diffA-B.txt │ │ │ ├── pseudo-variables.diffB-A.txt │ │ │ ├── pseudo-variables.parseA.txt │ │ │ ├── pseudo-variables.parseB.txt │ │ │ ├── regex.A.rb │ │ │ ├── regex.B.rb │ │ │ ├── regex.diffA-B.txt │ │ │ ├── regex.diffB-A.txt │ │ │ ├── regex.parseA.txt │ │ │ ├── regex.parseB.txt │ │ │ ├── relational-operator.A.rb │ │ │ ├── relational-operator.B.rb │ │ │ ├── relational-operator.diffA-B.txt │ │ │ ├── relational-operator.diffB-A.txt │ │ │ ├── relational-operator.parseA.txt │ │ │ ├── relational-operator.parseB.txt │ │ │ ├── require.A.rb │ │ │ ├── require.B.rb │ │ │ ├── require.diffA-B.txt │ │ │ ├── require.diffB-A.txt │ │ │ ├── require.parseA.txt │ │ │ ├── require.parseB.txt │ │ │ ├── rescue-empty.A.rb │ │ │ ├── rescue-empty.B.rb │ │ │ ├── rescue-empty.diffA-B.txt │ │ │ ├── rescue-empty.diffB-A.txt │ │ │ ├── rescue-empty.parseA.txt │ │ │ ├── rescue-empty.parseB.txt │ │ │ ├── rescue-last-ex.A.rb │ │ │ ├── rescue-last-ex.B.rb │ │ │ ├── rescue-last-ex.diffA-B.txt │ │ │ ├── rescue-last-ex.diffB-A.txt │ │ │ ├── rescue-last-ex.parseA.txt │ │ │ ├── rescue-last-ex.parseB.txt │ │ │ ├── rescue-modifier.A.rb │ │ │ ├── rescue-modifier.B.rb │ │ │ ├── rescue-modifier.diffA-B.txt │ │ │ ├── rescue-modifier.diffB-A.txt │ │ │ ├── rescue-modifier.parseA.txt │ │ │ ├── rescue-modifier.parseB.txt │ │ │ ├── rescue-modifier2.A.rb │ │ │ ├── rescue-modifier2.B.rb │ │ │ ├── rescue-modifier2.diffA-B.txt │ │ │ ├── rescue-modifier2.diffB-A.txt │ │ │ ├── rescue-modifier2.parseA.txt │ │ │ ├── rescue-modifier2.parseB.txt │ │ │ ├── rescue.A.rb │ │ │ ├── rescue.B.rb │ │ │ ├── rescue.diffA-B.txt │ │ │ ├── rescue.diffB-A.txt │ │ │ ├── rescue.parseA.txt │ │ │ ├── rescue.parseB.txt │ │ │ ├── return.A.rb │ │ │ ├── return.B.rb │ │ │ ├── return.diffA-B.txt │ │ │ ├── return.diffB-A.txt │ │ │ ├── return.parseA.txt │ │ │ ├── return.parseB.txt │ │ │ ├── singleton-class.A.rb │ │ │ ├── singleton-class.parseA.txt │ │ │ ├── string.A.rb │ │ │ ├── string.B.rb │ │ │ ├── string.diffA-B.txt │ │ │ ├── string.diffB-A.txt │ │ │ ├── string.parseA.txt │ │ │ ├── string.parseB.txt │ │ │ ├── subshell.A.rb │ │ │ ├── subshell.B.rb │ │ │ ├── subshell.diffA-B.txt │ │ │ ├── subshell.diffB-A.txt │ │ │ ├── subshell.parseA.txt │ │ │ ├── subshell.parseB.txt │ │ │ ├── symbol.A.rb │ │ │ ├── symbol.B.rb │ │ │ ├── symbol.diffA-B.txt │ │ │ ├── symbol.diffB-A.txt │ │ │ ├── symbol.parseA.txt │ │ │ ├── symbol.parseB.txt │ │ │ ├── ternary.A.rb │ │ │ ├── ternary.B.rb │ │ │ ├── ternary.diffA-B.txt │ │ │ ├── ternary.diffB-A.txt │ │ │ ├── ternary.parseA.txt │ │ │ ├── ternary.parseB.txt │ │ │ ├── unary.A.rb │ │ │ ├── unary.parseA.txt │ │ │ ├── undef.A.rb │ │ │ ├── undef.parseA.txt │ │ │ ├── unless.A.rb │ │ │ ├── unless.B.rb │ │ │ ├── unless.diffA-B.txt │ │ │ ├── unless.diffB-A.txt │ │ │ ├── unless.parseA.txt │ │ │ ├── unless.parseB.txt │ │ │ ├── until.A.rb │ │ │ ├── until.B.rb │ │ │ ├── until.diffA-B.txt │ │ │ ├── until.diffB-A.txt │ │ │ ├── until.parseA.txt │ │ │ ├── until.parseB.txt │ │ │ ├── when-else.A.rb │ │ │ ├── when-else.B.rb │ │ │ ├── when-else.diffA-B.txt │ │ │ ├── when-else.diffB-A.txt │ │ │ ├── when-else.parseA.txt │ │ │ ├── when-else.parseB.txt │ │ │ ├── when.A.rb │ │ │ ├── when.B.rb │ │ │ ├── when.diffA-B.txt │ │ │ ├── when.diffB-A.txt │ │ │ ├── when.parseA.txt │ │ │ ├── when.parseB.txt │ │ │ ├── while.A.rb │ │ │ ├── while.B.rb │ │ │ ├── while.diffA-B.txt │ │ │ ├── while.diffB-A.txt │ │ │ ├── while.parseA.txt │ │ │ ├── while.parseB.txt │ │ │ ├── yield.A.rb │ │ │ ├── yield.B.rb │ │ │ ├── yield.diffA-B.txt │ │ │ ├── yield.diffB-A.txt │ │ │ ├── yield.parseA.txt │ │ │ └── yield.parseB.txt │ │ ├── import-graph/ │ │ │ ├── app.json │ │ │ └── app.rb │ │ ├── reprinting/ │ │ │ ├── function.out.rb │ │ │ ├── function.rb │ │ │ └── infix.rb │ │ ├── tags/ │ │ │ ├── class_module.rb │ │ │ ├── simple_method.rb │ │ │ ├── simple_method_with_docs.rb │ │ │ └── unicode_identifiers.rb │ │ └── toc/ │ │ ├── classes.A.rb │ │ ├── classes.B.rb │ │ ├── lambda.A.rb │ │ ├── lambda.B.rb │ │ ├── method-starts-with-two-identifiers.A.rb │ │ ├── method-starts-with-two-identifiers.B.rb │ │ ├── methods.A.rb │ │ ├── methods.B.rb │ │ ├── methods.X.rb │ │ ├── unicode.A.rb │ │ └── unicode.B.rb │ ├── tsx/ │ │ └── corpus/ │ │ ├── jsx-elements.A.tsx │ │ ├── jsx-elements.B.tsx │ │ ├── jsx-elements.diffA-B.txt │ │ ├── jsx-elements.diffB-A.txt │ │ ├── jsx-elements.parseA.txt │ │ └── jsx-elements.parseB.txt │ └── typescript/ │ ├── analysis/ │ │ ├── .gitignore │ │ ├── a.ts │ │ ├── access_control/ │ │ │ ├── adder.ts │ │ │ ├── private_field_definition.ts │ │ │ ├── private_method.ts │ │ │ └── private_static_field_definition.ts │ │ ├── await.ts │ │ ├── bad-export.ts │ │ ├── band.ts │ │ ├── baz.ts │ │ ├── bor.ts │ │ ├── bxor.ts │ │ ├── class1.ts │ │ ├── class2.ts │ │ ├── complement.ts │ │ ├── delete.ts │ │ ├── early-return.ts │ │ ├── foo/ │ │ │ └── b.ts │ │ ├── foo.ts │ │ ├── foo2.ts │ │ ├── lshift.ts │ │ ├── main.ts │ │ ├── main1.ts │ │ ├── main2.ts │ │ ├── main3.ts │ │ ├── main4.ts │ │ ├── main5.ts │ │ ├── main6.ts │ │ ├── main7.ts │ │ ├── pip.ts │ │ ├── rshift.ts │ │ ├── sequence-expression.ts │ │ ├── unsignedrshift.ts │ │ └── void.ts │ ├── corpus/ │ │ ├── ambient-declarations.A.ts │ │ ├── ambient-declarations.B.ts │ │ ├── ambient-declarations.diffA-B.txt │ │ ├── ambient-declarations.diffB-A.txt │ │ ├── ambient-declarations.parseA.txt │ │ ├── ambient-declarations.parseB.txt │ │ ├── ambient-exports.A.ts │ │ ├── ambient-exports.B.ts │ │ ├── ambient-exports.diffA-B.txt │ │ ├── ambient-exports.diffB-A.txt │ │ ├── ambient-exports.parseA.txt │ │ ├── ambient-exports.parseB.txt │ │ ├── ambient-type-declarations.A.ts │ │ ├── ambient-type-declarations.B.ts │ │ ├── ambient-type-declarations.diffA-B.txt │ │ ├── ambient-type-declarations.diffB-A.txt │ │ ├── ambient-type-declarations.parseA.txt │ │ ├── ambient-type-declarations.parseB.txt │ │ ├── anonymous-function.A.ts │ │ ├── anonymous-function.B.ts │ │ ├── anonymous-function.diffA-B.txt │ │ ├── anonymous-function.diffB-A.txt │ │ ├── anonymous-function.parseA.txt │ │ ├── anonymous-function.parseB.txt │ │ ├── anonymous-parameterless-function.A.ts │ │ ├── anonymous-parameterless-function.B.ts │ │ ├── anonymous-parameterless-function.diffA-B.txt │ │ ├── anonymous-parameterless-function.diffB-A.txt │ │ ├── anonymous-parameterless-function.parseA.txt │ │ ├── anonymous-parameterless-function.parseB.txt │ │ ├── array-type.A.ts │ │ ├── array-type.B.ts │ │ ├── array-type.diffA-B.txt │ │ ├── array-type.diffB-A.txt │ │ ├── array-type.parseA.txt │ │ ├── array-type.parseB.txt │ │ ├── array.A.ts │ │ ├── array.B.ts │ │ ├── array.diffA-B.txt │ │ ├── array.diffB-A.txt │ │ ├── array.parseA.txt │ │ ├── array.parseB.txt │ │ ├── arrow-function.A.ts │ │ ├── arrow-function.B.ts │ │ ├── arrow-function.diffA-B.txt │ │ ├── arrow-function.diffB-A.txt │ │ ├── arrow-function.parseA.txt │ │ ├── arrow-function.parseB.txt │ │ ├── assignment-pattern.A.ts │ │ ├── assignment-pattern.B.ts │ │ ├── assignment-pattern.diffA-B.txt │ │ ├── assignment-pattern.diffB-A.txt │ │ ├── assignment-pattern.parseA.txt │ │ ├── assignment-pattern.parseB.txt │ │ ├── assignment.A.ts │ │ ├── assignment.B.ts │ │ ├── assignment.diffA-B.txt │ │ ├── assignment.diffB-A.txt │ │ ├── assignment.parseA.txt │ │ ├── assignment.parseB.txt │ │ ├── bitwise-operator.A.ts │ │ ├── bitwise-operator.B.ts │ │ ├── bitwise-operator.diffA-B.txt │ │ ├── bitwise-operator.diffB-A.txt │ │ ├── bitwise-operator.parseA.txt │ │ ├── bitwise-operator.parseB.txt │ │ ├── boolean-operator.A.ts │ │ ├── boolean-operator.B.ts │ │ ├── boolean-operator.diffA-B.txt │ │ ├── boolean-operator.diffB-A.txt │ │ ├── boolean-operator.parseA.txt │ │ ├── boolean-operator.parseB.txt │ │ ├── break.A.ts │ │ ├── break.B.ts │ │ ├── break.diffA-B.txt │ │ ├── break.diffB-A.txt │ │ ├── break.parseA.txt │ │ ├── break.parseB.txt │ │ ├── chained-callbacks.A.ts │ │ ├── chained-callbacks.B.ts │ │ ├── chained-callbacks.diffA-B.txt │ │ ├── chained-callbacks.diffB-A.txt │ │ ├── chained-callbacks.parseA.txt │ │ ├── chained-callbacks.parseB.txt │ │ ├── chained-property-access.A.ts │ │ ├── chained-property-access.B.ts │ │ ├── chained-property-access.diffA-B.txt │ │ ├── chained-property-access.diffB-A.txt │ │ ├── chained-property-access.parseA.txt │ │ ├── chained-property-access.parseB.txt │ │ ├── class.A.ts │ │ ├── class.B.ts │ │ ├── class.diffA-B.txt │ │ ├── class.diffB-A.txt │ │ ├── class.parseA.txt │ │ ├── class.parseB.txt │ │ ├── comma-operator.A.ts │ │ ├── comma-operator.B.ts │ │ ├── comma-operator.diffA-B.txt │ │ ├── comma-operator.diffB-A.txt │ │ ├── comma-operator.parseA.txt │ │ ├── comma-operator.parseB.txt │ │ ├── comment.A.ts │ │ ├── comment.B.ts │ │ ├── comment.diffA-B.txt │ │ ├── comment.diffB-A.txt │ │ ├── comment.parseA.txt │ │ ├── comment.parseB.txt │ │ ├── constructor-call.A.ts │ │ ├── constructor-call.B.ts │ │ ├── constructor-call.diffA-B.txt │ │ ├── constructor-call.diffB-A.txt │ │ ├── constructor-call.parseA.txt │ │ ├── constructor-call.parseB.txt │ │ ├── continue.A.ts │ │ ├── continue.B.ts │ │ ├── continue.diffA-B.txt │ │ ├── continue.diffB-A.txt │ │ ├── continue.parseA.txt │ │ ├── continue.parseB.txt │ │ ├── delete-operator.A.ts │ │ ├── delete-operator.B.ts │ │ ├── delete-operator.diffA-B.txt │ │ ├── delete-operator.diffB-A.txt │ │ ├── delete-operator.parseA.txt │ │ ├── delete-operator.parseB.txt │ │ ├── do-while-statement.A.ts │ │ ├── do-while-statement.B.ts │ │ ├── do-while-statement.diffA-B.txt │ │ ├── do-while-statement.diffB-A.txt │ │ ├── do-while-statement.parseA.txt │ │ ├── do-while-statement.parseB.txt │ │ ├── export-assignments.A.ts │ │ ├── export-assignments.B.ts │ │ ├── export-assignments.diffA-B.txt │ │ ├── export-assignments.diffB-A.txt │ │ ├── export-assignments.parseA.txt │ │ ├── export-assignments.parseB.txt │ │ ├── export.A.ts │ │ ├── export.B.ts │ │ ├── export.diffA-B.txt │ │ ├── export.diffB-A.txt │ │ ├── export.parseA.txt │ │ ├── export.parseB.txt │ │ ├── false.A.ts │ │ ├── false.B.ts │ │ ├── false.diffA-B.txt │ │ ├── false.diffB-A.txt │ │ ├── false.parseA.txt │ │ ├── false.parseB.txt │ │ ├── for-in-statement.A.ts │ │ ├── for-in-statement.B.ts │ │ ├── for-in-statement.diffA-B.txt │ │ ├── for-in-statement.diffB-A.txt │ │ ├── for-in-statement.parseA.txt │ │ ├── for-in-statement.parseB.txt │ │ ├── for-loop-with-in-statement.A.ts │ │ ├── for-loop-with-in-statement.B.ts │ │ ├── for-loop-with-in-statement.diffA-B.txt │ │ ├── for-loop-with-in-statement.diffB-A.txt │ │ ├── for-loop-with-in-statement.parseA.txt │ │ ├── for-loop-with-in-statement.parseB.txt │ │ ├── for-of-statement.A.ts │ │ ├── for-of-statement.B.ts │ │ ├── for-of-statement.diffA-B.txt │ │ ├── for-of-statement.diffB-A.txt │ │ ├── for-of-statement.parseA.txt │ │ ├── for-of-statement.parseB.txt │ │ ├── for-statement.A.ts │ │ ├── for-statement.B.ts │ │ ├── for-statement.diffA-B.txt │ │ ├── for-statement.diffB-A.txt │ │ ├── for-statement.parseA.txt │ │ ├── for-statement.parseB.txt │ │ ├── function-call-args.A.ts │ │ ├── function-call-args.B.ts │ │ ├── function-call-args.diffA-B.txt │ │ ├── function-call-args.diffB-A.txt │ │ ├── function-call-args.parseA.txt │ │ ├── function-call-args.parseB.txt │ │ ├── function-call.A.ts │ │ ├── function-call.B.ts │ │ ├── function-call.diffA-B.txt │ │ ├── function-call.diffB-A.txt │ │ ├── function-call.parseA.txt │ │ ├── function-call.parseB.txt │ │ ├── function-type.A.ts │ │ ├── function-type.B.ts │ │ ├── function-type.diffA-B.txt │ │ ├── function-type.diffB-A.txt │ │ ├── function-type.parseA.txt │ │ ├── function-type.parseB.txt │ │ ├── function.A.ts │ │ ├── function.B.ts │ │ ├── function.diffA-B.txt │ │ ├── function.diffB-A.txt │ │ ├── function.parseA.txt │ │ ├── function.parseB.txt │ │ ├── generator-function.A.ts │ │ ├── generator-function.B.ts │ │ ├── generator-function.diffA-B.txt │ │ ├── generator-function.diffB-A.txt │ │ ├── generator-function.parseA.txt │ │ ├── generator-function.parseB.txt │ │ ├── identifier.A.ts │ │ ├── identifier.B.ts │ │ ├── identifier.diffA-B.txt │ │ ├── identifier.diffB-A.txt │ │ ├── identifier.parseA.txt │ │ ├── identifier.parseB.txt │ │ ├── if-else.A.ts │ │ ├── if-else.B.ts │ │ ├── if-else.diffA-B.txt │ │ ├── if-else.diffB-A.txt │ │ ├── if-else.parseA.txt │ │ ├── if-else.parseB.txt │ │ ├── if.A.ts │ │ ├── if.B.ts │ │ ├── if.diffA-B.txt │ │ ├── if.diffB-A.txt │ │ ├── if.parseA.txt │ │ ├── if.parseB.txt │ │ ├── import.A.ts │ │ ├── import.B.ts │ │ ├── import.diffA-B.txt │ │ ├── import.diffB-A.txt │ │ ├── import.parseA.txt │ │ ├── import.parseB.txt │ │ ├── interface.A.ts │ │ ├── interface.B.ts │ │ ├── interface.diffA-B.txt │ │ ├── interface.diffB-A.txt │ │ ├── interface.parseA.txt │ │ ├── interface.parseB.txt │ │ ├── intersection-type.A.ts │ │ ├── intersection-type.B.ts │ │ ├── intersection-type.diffA-B.txt │ │ ├── intersection-type.diffB-A.txt │ │ ├── intersection-type.parseA.txt │ │ ├── intersection-type.parseB.txt │ │ ├── math-assignment-operator.A.ts │ │ ├── math-assignment-operator.B.ts │ │ ├── math-assignment-operator.diffA-B.txt │ │ ├── math-assignment-operator.diffB-A.txt │ │ ├── math-assignment-operator.parseA.txt │ │ ├── math-assignment-operator.parseB.txt │ │ ├── math-operator.A.ts │ │ ├── math-operator.B.ts │ │ ├── math-operator.diffA-B.txt │ │ ├── math-operator.diffB-A.txt │ │ ├── math-operator.parseA.txt │ │ ├── math-operator.parseB.txt │ │ ├── member-access-assignment.A.ts │ │ ├── member-access-assignment.B.ts │ │ ├── member-access-assignment.diffA-B.txt │ │ ├── member-access-assignment.diffB-A.txt │ │ ├── member-access-assignment.parseA.txt │ │ ├── member-access-assignment.parseB.txt │ │ ├── member-access.A.ts │ │ ├── member-access.B.ts │ │ ├── member-access.diffA-B.txt │ │ ├── member-access.diffB-A.txt │ │ ├── member-access.parseA.txt │ │ ├── member-access.parseB.txt │ │ ├── method-call.A.ts │ │ ├── method-call.B.ts │ │ ├── method-call.diffA-B.txt │ │ ├── method-call.diffB-A.txt │ │ ├── method-call.parseA.txt │ │ ├── method-call.parseB.txt │ │ ├── method-definition.A.ts │ │ ├── method-definition.B.ts │ │ ├── method-definition.diffA-B.txt │ │ ├── method-definition.diffB-A.txt │ │ ├── method-definition.parseA.txt │ │ ├── method-definition.parseB.txt │ │ ├── module-declarations.A.ts │ │ ├── module-declarations.B.ts │ │ ├── module-declarations.diffA-B.txt │ │ ├── module-declarations.diffB-A.txt │ │ ├── module-declarations.parseA.txt │ │ ├── module-declarations.parseB.txt │ │ ├── named-function.A.ts │ │ ├── named-function.B.ts │ │ ├── named-function.diffA-B.txt │ │ ├── named-function.diffB-A.txt │ │ ├── named-function.parseA.txt │ │ ├── named-function.parseB.txt │ │ ├── nested-do-while-in-function.A.ts │ │ ├── nested-do-while-in-function.B.ts │ │ ├── nested-do-while-in-function.diffA-B.txt │ │ ├── nested-do-while-in-function.diffB-A.txt │ │ ├── nested-do-while-in-function.parseA.txt │ │ ├── nested-do-while-in-function.parseB.txt │ │ ├── nested-functions.A.ts │ │ ├── nested-functions.B.ts │ │ ├── nested-functions.diffA-B.txt │ │ ├── nested-functions.diffB-A.txt │ │ ├── nested-functions.parseA.txt │ │ ├── nested-functions.parseB.txt │ │ ├── null.A.ts │ │ ├── null.B.ts │ │ ├── null.diffA-B.txt │ │ ├── null.diffB-A.txt │ │ ├── null.parseA.txt │ │ ├── null.parseB.txt │ │ ├── number.A.ts │ │ ├── number.B.ts │ │ ├── number.diffA-B.txt │ │ ├── number.diffB-A.txt │ │ ├── number.parseA.txt │ │ ├── number.parseB.txt │ │ ├── object.A.ts │ │ ├── object.B.ts │ │ ├── object.diffA-B.txt │ │ ├── object.diffB-A.txt │ │ ├── object.parseA.txt │ │ ├── object.parseB.txt │ │ ├── objects-with-methods.A.ts │ │ ├── objects-with-methods.B.ts │ │ ├── objects-with-methods.diffA-B.txt │ │ ├── objects-with-methods.diffB-A.txt │ │ ├── objects-with-methods.parseA.txt │ │ ├── objects-with-methods.parseB.txt │ │ ├── public-field-definition.A.ts │ │ ├── public-field-definition.B.ts │ │ ├── public-field-definition.diffA-B.txt │ │ ├── public-field-definition.diffB-A.txt │ │ ├── public-field-definition.parseA.txt │ │ ├── public-field-definition.parseB.txt │ │ ├── regex.A.ts │ │ ├── regex.B.ts │ │ ├── regex.diffA-B.txt │ │ ├── regex.diffB-A.txt │ │ ├── regex.parseA.txt │ │ ├── regex.parseB.txt │ │ ├── relational-operator.A.ts │ │ ├── relational-operator.B.ts │ │ ├── relational-operator.diffA-B.txt │ │ ├── relational-operator.diffB-A.txt │ │ ├── relational-operator.parseA.txt │ │ ├── relational-operator.parseB.txt │ │ ├── return-statement.A.ts │ │ ├── return-statement.B.ts │ │ ├── return-statement.diffA-B.txt │ │ ├── return-statement.diffB-A.txt │ │ ├── return-statement.parseA.txt │ │ ├── return-statement.parseB.txt │ │ ├── string.A.ts │ │ ├── string.B.ts │ │ ├── string.diffA-B.txt │ │ ├── string.diffB-A.txt │ │ ├── string.parseA.txt │ │ ├── string.parseB.txt │ │ ├── subscript-access-assignment.A.ts │ │ ├── subscript-access-assignment.B.ts │ │ ├── subscript-access-assignment.diffA-B.txt │ │ ├── subscript-access-assignment.diffB-A.txt │ │ ├── subscript-access-assignment.parseA.txt │ │ ├── subscript-access-assignment.parseB.txt │ │ ├── subscript-access-string.A.ts │ │ ├── subscript-access-string.B.ts │ │ ├── subscript-access-string.diffA-B.txt │ │ ├── subscript-access-string.diffB-A.txt │ │ ├── subscript-access-string.parseA.txt │ │ ├── subscript-access-string.parseB.txt │ │ ├── subscript-access-variable.A.ts │ │ ├── subscript-access-variable.B.ts │ │ ├── subscript-access-variable.diffA-B.txt │ │ ├── subscript-access-variable.diffB-A.txt │ │ ├── subscript-access-variable.parseA.txt │ │ ├── subscript-access-variable.parseB.txt │ │ ├── switch-statement.A.ts │ │ ├── switch-statement.B.ts │ │ ├── switch-statement.diffA-B.txt │ │ ├── switch-statement.diffB-A.txt │ │ ├── switch-statement.parseA.txt │ │ ├── switch-statement.parseB.txt │ │ ├── template-string.A.ts │ │ ├── template-string.B.ts │ │ ├── template-string.diffA-B.txt │ │ ├── template-string.diffB-A.txt │ │ ├── template-string.parseA.txt │ │ ├── template-string.parseB.txt │ │ ├── ternary.A.ts │ │ ├── ternary.B.ts │ │ ├── ternary.diffA-B.txt │ │ ├── ternary.diffB-A.txt │ │ ├── ternary.parseA.txt │ │ ├── ternary.parseB.txt │ │ ├── this-expression.A.ts │ │ ├── this-expression.B.ts │ │ ├── this-expression.diffA-B.txt │ │ ├── this-expression.diffB-A.txt │ │ ├── this-expression.parseA.txt │ │ ├── this-expression.parseB.txt │ │ ├── throw-statement.A.ts │ │ ├── throw-statement.B.ts │ │ ├── throw-statement.diffA-B.txt │ │ ├── throw-statement.diffB-A.txt │ │ ├── throw-statement.parseA.txt │ │ ├── throw-statement.parseB.txt │ │ ├── true.A.ts │ │ ├── true.B.ts │ │ ├── true.diffA-B.txt │ │ ├── true.diffB-A.txt │ │ ├── true.parseA.txt │ │ ├── true.parseB.txt │ │ ├── try-statement.A.ts │ │ ├── try-statement.B.ts │ │ ├── try-statement.diffA-B.txt │ │ ├── try-statement.diffB-A.txt │ │ ├── try-statement.parseA.txt │ │ ├── try-statement.parseB.txt │ │ ├── tuple-type.A.ts │ │ ├── tuple-type.B.ts │ │ ├── tuple-type.diffA-B.txt │ │ ├── tuple-type.diffB-A.txt │ │ ├── tuple-type.parseA.txt │ │ ├── tuple-type.parseB.txt │ │ ├── type-assertions.A.ts │ │ ├── type-assertions.B.ts │ │ ├── type-assertions.diffA-B.txt │ │ ├── type-assertions.diffB-A.txt │ │ ├── type-assertions.parseA.txt │ │ ├── type-assertions.parseB.txt │ │ ├── type-operator.A.ts │ │ ├── type-operator.B.ts │ │ ├── type-operator.diffA-B.txt │ │ ├── type-operator.diffB-A.txt │ │ ├── type-operator.parseA.txt │ │ ├── type-operator.parseB.txt │ │ ├── typeof-types.A.ts │ │ ├── typeof-types.B.ts │ │ ├── typeof-types.diffA-B.txt │ │ ├── typeof-types.diffB-A.txt │ │ ├── typeof-types.parseA.txt │ │ ├── typeof-types.parseB.txt │ │ ├── undefined.A.ts │ │ ├── undefined.B.ts │ │ ├── undefined.diffA-B.txt │ │ ├── undefined.diffB-A.txt │ │ ├── undefined.parseA.txt │ │ ├── undefined.parseB.txt │ │ ├── union-type.A.ts │ │ ├── union-type.B.ts │ │ ├── union-type.diffA-B.txt │ │ ├── union-type.diffB-A.txt │ │ ├── union-type.parseA.txt │ │ ├── union-type.parseB.txt │ │ ├── var-declaration.A.ts │ │ ├── var-declaration.B.ts │ │ ├── var-declaration.diffA-B.txt │ │ ├── var-declaration.diffB-A.txt │ │ ├── var-declaration.parseA.txt │ │ ├── var-declaration.parseB.txt │ │ ├── variable.A.ts │ │ ├── variable.B.ts │ │ ├── variable.diffA-B.txt │ │ ├── variable.diffB-A.txt │ │ ├── variable.parseA.txt │ │ ├── variable.parseB.txt │ │ ├── void-operator.A.ts │ │ ├── void-operator.B.ts │ │ ├── void-operator.diffA-B.txt │ │ ├── void-operator.diffB-A.txt │ │ ├── void-operator.parseA.txt │ │ ├── void-operator.parseB.txt │ │ ├── while-statement.A.ts │ │ ├── while-statement.B.ts │ │ ├── while-statement.diffA-B.txt │ │ ├── while-statement.diffB-A.txt │ │ ├── while-statement.parseA.txt │ │ ├── while-statement.parseB.txt │ │ ├── yield.A.ts │ │ ├── yield.B.ts │ │ ├── yield.diffA-B.txt │ │ ├── yield.diffB-A.txt │ │ ├── yield.parseA.txt │ │ └── yield.parseB.txt │ ├── import-graph/ │ │ ├── app.json │ │ └── app.ts │ └── tags/ │ ├── class.ts │ └── module.ts ├── semantic-analysis/ │ ├── .ghci.repl │ ├── .gitignore │ ├── BUILD.bazel │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── cabal.project │ ├── hie.yaml │ ├── python.tsg │ ├── script/ │ │ ├── ghci-flags │ │ └── repl │ ├── semantic-analysis.cabal │ └── src/ │ └── Analysis/ │ ├── Analysis/ │ │ ├── Concrete.hs │ │ ├── DeadCode.hs │ │ ├── Exception.hs │ │ └── Typecheck.hs │ ├── Blob.hs │ ├── Carrier/ │ │ ├── Env/ │ │ │ ├── Monovariant.hs │ │ │ └── Precise.hs │ │ ├── Fail/ │ │ │ └── WithLoc.hs │ │ ├── Statement/ │ │ │ └── State.hs │ │ └── Store/ │ │ ├── Monovariant.hs │ │ └── Precise.hs │ ├── Data/ │ │ └── Snoc.hs │ ├── Effect/ │ │ ├── Domain.hs │ │ ├── Env.hs │ │ ├── Statement.hs │ │ └── Store.hs │ ├── File.hs │ ├── FlowInsensitive.hs │ ├── Functor/ │ │ └── Named.hs │ ├── Module.hs │ ├── Name.hs │ ├── Project.hs │ ├── Reference.hs │ ├── Syntax/ │ │ └── Python.hs │ ├── Syntax.hs │ └── VM.hs ├── semantic-ast/ │ ├── BUILD.bazel │ ├── CHANGELOG.md │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── app/ │ │ └── Main.hs │ ├── semantic-ast.cabal │ └── src/ │ ├── AST/ │ │ ├── Deserialize.hs │ │ ├── Element.hs │ │ ├── GenerateSyntax.hs │ │ ├── Grammar/ │ │ │ ├── Examples.hs │ │ │ └── TH.hs │ │ ├── Marshal/ │ │ │ └── JSON.hs │ │ ├── Parse.hs │ │ ├── TestHelpers.hs │ │ ├── Token.hs │ │ ├── Traversable1/ │ │ │ └── Class.hs │ │ ├── Traversable1.hs │ │ └── Unmarshal.hs │ └── System/ │ └── Path/ │ └── Fixture.hs ├── semantic-codeql/ │ ├── BUILD.bazel │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── semantic-codeql.cabal │ ├── src/ │ │ └── Language/ │ │ ├── CodeQL/ │ │ │ ├── AST.hs │ │ │ ├── Grammar.hs │ │ │ └── Tags.hs │ │ └── CodeQL.hs │ └── test/ │ └── PreciseTest.hs ├── semantic-go/ │ ├── BUILD.bazel │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── semantic-go.cabal │ ├── src/ │ │ └── Language/ │ │ ├── Go/ │ │ │ ├── AST.hs │ │ │ ├── Grammar.hs │ │ │ └── Tags.hs │ │ └── Go.hs │ └── test/ │ └── PreciseTest.hs ├── semantic-java/ │ ├── BUILD.bazel │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── semantic-java.cabal │ ├── src/ │ │ └── Language/ │ │ ├── Java/ │ │ │ ├── AST.hs │ │ │ ├── Grammar.hs │ │ │ └── Tags.hs │ │ └── Java.hs │ └── test/ │ └── PreciseTest.hs ├── semantic-json/ │ ├── BUILD.bazel │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── semantic-json.cabal │ ├── src/ │ │ └── Language/ │ │ ├── JSON/ │ │ │ ├── AST.hs │ │ │ └── Grammar.hs │ │ └── JSON.hs │ └── test/ │ └── PreciseTest.hs ├── semantic-parse/ │ ├── BUILD.bazel │ ├── CHANGELOG.md │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── app/ │ │ └── Main.hs │ └── semantic-parse.cabal ├── semantic-php/ │ ├── BUILD.bazel │ ├── CHANGELOG.md │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── semantic-php.cabal │ └── src/ │ └── Language/ │ ├── PHP/ │ │ ├── AST.hs │ │ ├── Grammar.hs │ │ └── Tags.hs │ └── PHP.hs ├── semantic-proto/ │ ├── BUILD.bazel │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── semantic-proto.cabal │ └── src/ │ └── Proto/ │ ├── Semantic.hs │ ├── Semantic_Fields.hs │ └── Semantic_JSON.hs ├── semantic-python/ │ ├── BUILD.bazel │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── bench/ │ │ └── Bench.hs │ ├── semantic-python.cabal │ ├── src/ │ │ ├── Language/ │ │ │ ├── Python/ │ │ │ │ ├── AST.hs │ │ │ │ ├── Core.hs │ │ │ │ ├── Failure.hs │ │ │ │ ├── Grammar.hs │ │ │ │ ├── Patterns.hs │ │ │ │ ├── ScopeGraph.hs │ │ │ │ └── Tags.hs │ │ │ └── Python.hs │ │ └── Prelude.score │ ├── test/ │ │ ├── CoreTest.hs │ │ ├── Directive.hs │ │ ├── Instances.hs │ │ ├── PreciseTest.hs │ │ └── fixtures/ │ │ ├── 1-01-empty-module.py │ │ ├── 1-02-pass-statement.py │ │ ├── 1-03-empty-tuple.py │ │ ├── 1-04-toplevel-assignment.py │ │ ├── 1-05-exec-statement-fails.py │ │ ├── 2-01-return-statement.py │ │ ├── 2-02-return-doesnt-translate.py │ │ ├── 2-03-return-in-if-statement.py │ │ ├── 2-04-multiple-assign.py │ │ ├── 2-05-function-call.py │ │ ├── 2-06-nested-function-definition.py │ │ ├── 2-07-closure-over-scope.py │ │ ├── 2-08-function-decorator.py │ │ ├── 3-01-empty-class-definition.py │ │ ├── 3-02-defining-instance-method.py │ │ ├── 3-03-functions-know-their-own-names.py │ │ ├── 4-01-lambda-literals.py │ │ ├── 4-02-nonetype.py │ │ ├── 4-03-not-expression.py │ │ ├── 5-01-simple-reference.py │ │ ├── 5-02-simple-function.py │ │ ├── 5-03-function-argument.py │ │ └── cheese/ │ │ ├── 6-01-imports.py │ │ ├── 6-01-qualified-imports.py │ │ └── ints.py │ └── test-graphing/ │ └── GraphTest.hs ├── semantic-ruby/ │ ├── BUILD.bazel │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── app/ │ │ └── Main.hs │ ├── bench/ │ │ ├── Main.hs │ │ └── Parsing.hs │ ├── semantic-ruby.cabal │ ├── src/ │ │ └── Language/ │ │ ├── Ruby/ │ │ │ ├── AST.hs │ │ │ ├── Grammar.hs │ │ │ └── Tags.hs │ │ └── Ruby.hs │ └── test/ │ └── PreciseTest.hs ├── semantic-rust/ │ ├── BUILD.bazel │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── semantic-rust.cabal │ ├── src/ │ │ └── Language/ │ │ ├── Rust/ │ │ │ ├── AST.hs │ │ │ ├── Grammar.hs │ │ │ └── Tags.hs │ │ └── Rust.hs │ └── test/ │ └── Test.hs ├── semantic-scope-graph/ │ ├── BUILD.bazel │ ├── CHANGELOG.md │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── semantic-scope-graph.cabal │ └── src/ │ ├── Control/ │ │ ├── Carrier/ │ │ │ └── Sketch/ │ │ │ └── ScopeGraph.hs │ │ └── Effect/ │ │ ├── ScopeGraph/ │ │ │ └── Properties/ │ │ │ ├── Declaration.hs │ │ │ ├── Function.hs │ │ │ └── Reference.hs │ │ └── ScopeGraph.hs │ ├── Data/ │ │ ├── Hole.hs │ │ ├── Module.hs │ │ └── ScopeGraph.hs │ └── Scope/ │ ├── Graph/ │ │ ├── AdjacencyList.hs │ │ └── Convert.hs │ ├── Info.hs │ ├── Path.hs │ ├── Reference.hs │ ├── Scope.hs │ └── Types.hs ├── semantic-source/ │ ├── BUILD.bazel │ ├── CHANGELOG.md │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── cabal.project │ ├── cabal.project.ci │ ├── semantic-source.cabal │ ├── src/ │ │ └── Source/ │ │ ├── Language.hs │ │ ├── Loc.hs │ │ ├── Range.hs │ │ ├── Source.hs │ │ └── Span.hs │ └── test/ │ ├── Range/ │ │ └── Test.hs │ ├── Source/ │ │ └── Test.hs │ └── Test.hs ├── semantic-tags/ │ ├── BUILD.bazel │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── semantic-tags.cabal │ ├── src/ │ │ └── Tags/ │ │ ├── Tag.hs │ │ └── Tagging/ │ │ └── Precise.hs │ └── test/ │ └── Test.hs ├── semantic-tsx/ │ ├── BUILD.bazel │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── semantic-tsx.cabal │ ├── src/ │ │ └── Language/ │ │ ├── TSX/ │ │ │ ├── AST.hs │ │ │ ├── Grammar.hs │ │ │ └── Tags.hs │ │ └── TSX.hs │ └── test/ │ └── PreciseTest.hs ├── semantic-typescript/ │ ├── BUILD.bazel │ ├── LICENSE │ ├── README.md │ ├── Setup.hs │ ├── semantic-typescript.cabal │ ├── src/ │ │ └── Language/ │ │ ├── TypeScript/ │ │ │ ├── AST.hs │ │ │ ├── Grammar.hs │ │ │ └── Tags.hs │ │ └── TypeScript.hs │ └── test/ │ └── PreciseTest.hs ├── stack-snapshot.yaml └── stackage_snapshot.json
SYMBOL INDEX (790 symbols across 345 files)
FILE: semantic-python/test/fixtures/2-01-return-statement.py
function foo (line 2) | def foo(a):
FILE: semantic-python/test/fixtures/2-02-return-doesnt-translate.py
function foo (line 3) | def foo(a):
FILE: semantic-python/test/fixtures/2-03-return-in-if-statement.py
function foo (line 3) | def foo(a):
FILE: semantic-python/test/fixtures/2-05-function-call.py
function const (line 2) | def const(x, y): return x
FILE: semantic-python/test/fixtures/2-06-nested-function-definition.py
function const (line 3) | def const(a, b):
FILE: semantic-python/test/fixtures/2-07-closure-over-scope.py
function const (line 2) | def const(a, b):
FILE: semantic-python/test/fixtures/2-08-function-decorator.py
function passthru (line 2) | def passthru(x):
function decorated (line 6) | def decorated(x):
FILE: semantic-python/test/fixtures/3-01-empty-class-definition.py
class Foo (line 2) | class Foo():
FILE: semantic-python/test/fixtures/3-02-defining-instance-method.py
class Foo (line 3) | class Foo():
method identity (line 4) | def identity(self, x):
FILE: semantic-python/test/fixtures/3-03-functions-know-their-own-names.py
function recursive (line 2) | def recursive(a): return recursive
FILE: semantic-python/test/fixtures/5-02-simple-function.py
function foo (line 1) | def foo():
FILE: semantic-python/test/fixtures/5-03-function-argument.py
function foo (line 1) | def foo(x):
FILE: semantic-python/test/fixtures/cheese/ints.py
function one (line 1) | def one():
function two (line 4) | def two():
FILE: semantic/bench/bench-fixtures/python/function-definition.py
function a (line 1) | def a():
function c (line 4) | def c(d):
function g (line 7) | def g(g, *h):
function h (line 10) | def h(i=1):
function i (line 13) | def i(j="default", **c):
FILE: semantic/bench/bench-fixtures/python/if-statement-functions.py
function foo (line 1) | def foo(): return "bipp"
function bar (line 3) | def bar(): return foo()
function baz (line 5) | def baz(): return bar()
function why (line 7) | def why(): return "elle"
FILE: semantic/bench/bench-fixtures/ruby/function-definition.rb
function a (line 1) | def a()
function c (line 5) | def c(d)
function g (line 9) | def g(g_)
function h (line 13) | def h(i=1)
function i (line 17) | def i()
FILE: semantic/bench/bench-fixtures/ruby/if-statement-functions.rb
function foo (line 1) | def foo()
function bar (line 5) | def bar()
function baz (line 9) | def baz()
function why (line 13) | def why()
FILE: semantic/test/fixtures/base.rb
type Sinatra (line 22) | module Sinatra
class Request (line 25) | class Request < Rack::Request
method accept (line 30) | def accept
method accept? (line 41) | def accept?(type)
method preferred_type (line 45) | def preferred_type(*types)
method forwarded? (line 57) | def forwarded?
method safe? (line 61) | def safe?
method idempotent? (line 65) | def idempotent?
method link? (line 69) | def link?
method unlink? (line 73) | def unlink?
method params (line 77) | def params
class AcceptEntry (line 83) | class AcceptEntry
method initialize (line 87) | def initialize(entry)
method <=> (line 100) | def <=>(other)
method priority (line 104) | def priority
method to_str (line 109) | def to_str
method to_s (line 113) | def to_s(full = false)
method respond_to? (line 117) | def respond_to?(*args)
method method_missing (line 121) | def method_missing(*args, &block)
class MimeTypeEntry (line 126) | class MimeTypeEntry
method initialize (line 129) | def initialize(entry)
method accepts? (line 140) | def accepts?(entry)
method to_str (line 144) | def to_str
method matches_params? (line 148) | def matches_params?(params)
class Response (line 160) | class Response < Rack::Response
method body= (line 163) | def body=(value)
method each (line 168) | def each
method finish (line 172) | def finish
method calculate_content_length? (line 196) | def calculate_content_length?
method drop_content_info? (line 200) | def drop_content_info?
method drop_body? (line 204) | def drop_body?
class ExtendedRack (line 214) | class ExtendedRack < Struct.new(:app)
method call (line 215) | def call(env)
method setup_close (line 225) | def setup_close(env, status, headers, body)
method after_response (line 231) | def after_response(&block)
method async? (line 236) | def async?(status, headers, body)
class CommonLogger (line 244) | class CommonLogger < Rack::CommonLogger
method call (line 245) | def call(env)
method call (line 251) | def call(env)
class BadRequest (line 258) | class BadRequest < TypeError #:nodoc:
method http_status (line 259) | def http_status; 400 end
class NotFound (line 262) | class NotFound < NameError #:nodoc:
method http_status (line 263) | def http_status; 404 end
type Helpers (line 267) | module Helpers
function status (line 269) | def status(value = nil)
function body (line 276) | def body(value = nil, &block)
function redirect (line 293) | def redirect(uri, *args)
function uri (line 308) | def uri(addr = nil, absolute = true, add_script_name = true)
function error (line 328) | def error(code, body = nil)
function not_found (line 335) | def not_found(body = nil)
function headers (line 340) | def headers(hash = nil)
function session (line 346) | def session
function logger (line 351) | def logger
function mime_type (line 356) | def mime_type(type)
function content_type (line 362) | def content_type(type = nil, params = {})
function attachment (line 384) | def attachment(filename = nil, disposition = :attachment)
function send_file (line 395) | def send_file(path, opts = {})
class Stream (line 427) | class Stream
method schedule (line 428) | def self.schedule(*) yield end
method defer (line 429) | def self.defer(*) yield end
method initialize (line 431) | def initialize(scheduler = self.class, keep_open = false, &back)
method close (line 436) | def close
method each (line 442) | def each(&front)
method << (line 454) | def <<(data)
method callback (line 459) | def callback(&block)
method closed? (line 466) | def closed?
function stream (line 477) | def stream(keep_open = false)
function cache_control (line 493) | def cache_control(*values)
function expires (line 521) | def expires(amount, *values)
function last_modified (line 545) | def last_modified(time)
function etag (line 575) | def etag(value, options = {})
function back (line 601) | def back
function informational? (line 606) | def informational?
function success? (line 611) | def success?
function redirect? (line 616) | def redirect?
function client_error? (line 621) | def client_error?
function server_error? (line 626) | def server_error?
function not_found? (line 631) | def not_found?
function bad_request? (line 636) | def bad_request?
function time_for (line 642) | def time_for(value)
function etag_matches? (line 659) | def etag_matches?(list, new_resource = request.post?)
function with_params (line 664) | def with_params(temp_params)
type Templates (line 690) | module Templates
type ContentTyped (line 691) | module ContentTyped
function initialize (line 695) | def initialize
function erb (line 701) | def erb(template, options = {}, locals = {}, &block)
function erubis (line 705) | def erubis(template, options = {}, locals = {})
function haml (line 711) | def haml(template, options = {}, locals = {}, &block)
function sass (line 715) | def sass(template, options = {}, locals = {})
function scss (line 720) | def scss(template, options = {}, locals = {})
function less (line 725) | def less(template, options = {}, locals = {})
function stylus (line 730) | def stylus(template, options = {}, locals = {})
function builder (line 735) | def builder(template = nil, options = {}, locals = {}, &block)
function liquid (line 740) | def liquid(template, options = {}, locals = {}, &block)
function markdown (line 744) | def markdown(template, options = {}, locals = {})
function textile (line 749) | def textile(template, options = {}, locals = {})
function rdoc (line 753) | def rdoc(template, options = {}, locals = {})
function asciidoc (line 757) | def asciidoc(template, options = {}, locals = {})
function radius (line 761) | def radius(template, options = {}, locals = {})
function markaby (line 765) | def markaby(template = nil, options = {}, locals = {}, &block)
function coffee (line 769) | def coffee(template, options = {}, locals = {})
function nokogiri (line 774) | def nokogiri(template = nil, options = {}, locals = {}, &block)
function slim (line 779) | def slim(template, options = {}, locals = {}, &block)
function creole (line 783) | def creole(template, options = {}, locals = {})
function mediawiki (line 787) | def mediawiki(template, options = {}, locals = {})
function wlang (line 791) | def wlang(template, options = {}, locals = {}, &block)
function yajl (line 795) | def yajl(template, options = {}, locals = {})
function rabl (line 800) | def rabl(template, options = {}, locals = {})
function find_template (line 807) | def find_template(views, name, engine)
function render_ruby (line 818) | def render_ruby(engine, template, options = {}, locals = {}, &block)
function render (line 824) | def render(engine, data, options = {}, locals = {}, &block)
function compile_template (line 870) | def compile_template(engine, data, options, views)
class Base (line 909) | class Base
method initialize (line 919) | def initialize(app = nil)
method call (line 928) | def call(env)
method call! (line 932) | def call!(env) # :nodoc:
method settings (line 954) | def self.settings
method settings (line 959) | def settings
method options (line 963) | def options
method halt (line 971) | def halt(*response)
method pass (line 979) | def pass(&block)
method forward (line 984) | def forward
method filter! (line 997) | def filter!(type, base = settings)
method route! (line 1006) | def route!(base = settings, pass_block = nil)
method route_eval (line 1031) | def route_eval
method process_route (line 1040) | def process_route(pattern, conditions, block = nil, values = [])
method route_missing (line 1076) | def route_missing
method static! (line 1086) | def static!(options = {})
method invoke (line 1100) | def invoke
method dispatch! (line 1116) | def dispatch!
method handle_exception! (line 1142) | def handle_exception!(boom)
method error_block! (line 1184) | def error_block!(key, *block_params)
method dump_errors! (line 1199) | def dump_errors!(boom)
method reset! (line 1226) | def reset!
method extensions (line 1243) | def extensions
method middleware (line 1252) | def middleware
method set (line 1262) | def set(option, value = (not_set = true), ignore_setter = false, &bl...
method enable (line 1298) | def enable(*opts)
method disable (line 1303) | def disable(*opts)
method error (line 1310) | def error(*codes, &block)
method not_found (line 1319) | def not_found(&block)
method template (line 1324) | def template(name, &block)
method layout (line 1330) | def layout(name = :layout, &block)
method inline_templates= (line 1336) | def inline_templates=(file = nil)
method mime_type (line 1368) | def mime_type(type, value = nil)
method mime_types (line 1379) | def mime_types(type)
method before (line 1387) | def before(path = /.*/, **options, &block)
method after (line 1394) | def after(path = /.*/, **options, &block)
method add_filter (line 1399) | def add_filter(type, path = /.*/, **options, &block)
method condition (line 1405) | def condition(name = "#{caller.first[/`.*'/]} condition", &block)
method public= (line 1409) | def public=(value)
method public_dir= (line 1414) | def public_dir=(value)
method public_dir (line 1418) | def public_dir
method get (line 1424) | def get(path, opts = {}, &block)
method put (line 1432) | def put(path, opts = {}, &bk) route 'PUT', path, opts, &bk end
method post (line 1433) | def post(path, opts = {}, &bk) route 'POST', path, opts, &bk end
method delete (line 1434) | def delete(path, opts = {}, &bk) route 'DELETE', path, opts, &bk end
method head (line 1435) | def head(path, opts = {}, &bk) route 'HEAD', path, opts, &bk end
method options (line 1436) | def options(path, opts = {}, &bk) route 'OPTIONS', path, opts, &bk end
method patch (line 1437) | def patch(path, opts = {}, &bk) route 'PATCH', path, opts, &bk end
method link (line 1438) | def link(path, opts = {}, &bk) route 'LINK', path, opts, &bk end
method unlink (line 1439) | def unlink(path, opts = {}, &bk) route 'UNLINK', path, opts, &bk end
method helpers (line 1443) | def helpers(*extensions, &block)
method register (line 1450) | def register(*extensions, &block)
method development? (line 1459) | def development?; environment == :development end
method production? (line 1460) | def production?; environment == :production end
method test? (line 1461) | def test?; environment == :test end
method configure (line 1465) | def configure(*envs)
method use (line 1470) | def use(middleware, *args, &block)
method quit! (line 1476) | def quit!
method run! (line 1490) | def run!(options = {}, &block)
method running? (line 1511) | def running?
method prototype (line 1516) | def prototype
method new (line 1526) | def new(*args, &bk)
method build (line 1533) | def build(app)
method call (line 1541) | def call(env)
method caller_files (line 1547) | def caller_files
method caller_locations (line 1553) | def caller_locations
method start_server (line 1560) | def start_server(handler, server_settings, handler_name)
method suppress_messages? (line 1579) | def suppress_messages?
method setup_traps (line 1583) | def setup_traps
method define_singleton (line 1599) | def define_singleton(name, content = Proc.new)
method host_name (line 1607) | def host_name(pattern)
method user_agent (line 1613) | def user_agent(pattern)
method provides (line 1626) | def provides(*types)
method route (line 1642) | def route(verb, path, options = {}, &block)
method invoke_hook (line 1650) | def invoke_hook(name, *args)
method generate_method (line 1654) | def generate_method(method_name, &block)
method compile! (line 1661) | def compile!(verb, path, block, **options)
method compile (line 1680) | def compile(path, route_mustermann_opts = {})
method setup_default_middleware (line 1684) | def setup_default_middleware(builder)
method setup_middleware (line 1694) | def setup_middleware(builder)
method setup_logging (line 1698) | def setup_logging(builder)
method setup_null_logger (line 1707) | def setup_null_logger(builder)
method setup_common_logger (line 1711) | def setup_common_logger(builder)
method setup_custom_logger (line 1715) | def setup_custom_logger(builder)
method setup_protection (line 1723) | def setup_protection(builder)
method setup_sessions (line 1739) | def setup_sessions(builder)
method detect_rack_handler (line 1747) | def detect_rack_handler
method inherited (line 1758) | def inherited(subclass)
method synchronize (line 1765) | def synchronize(&block)
method warn (line 1774) | def warn(message)
method cleaned_caller (line 1779) | def cleaned_caller(keep = 3)
method force_encoding (line 1788) | def self.force_encoding(data, encoding = default_encoding)
method force_encoding (line 1800) | def force_encoding(*args) settings.force_encoding(*args) end
class Application (line 1938) | class Application < Base
method register (line 1944) | def self.register(*extensions, &block) #:nodoc:
type Delegator (line 1954) | module Delegator #:nodoc:
function delegate (line 1955) | def self.delegate(*methods)
class Wrapper (line 1977) | class Wrapper
method initialize (line 1978) | def initialize(stack, instance)
method settings (line 1982) | def settings
method helpers (line 1986) | def helpers
method call (line 1990) | def call(env)
method inspect (line 1994) | def inspect
function new (line 2000) | def self.new(base = Base, &block)
function register (line 2007) | def self.register(*extensions, &block)
function helpers (line 2012) | def self.helpers(*extensions, &block)
function use (line 2017) | def self.use(*args, &block)
FILE: semantic/test/fixtures/go/analysis/bar/bar.go
function Bar (line 3) | func Bar() string {
FILE: semantic/test/fixtures/go/analysis/bar/rab.go
function Rab (line 3) | func Rab() string {
FILE: semantic/test/fixtures/go/analysis/foo/foo.go
function New (line 3) | func New() string {
FILE: semantic/test/fixtures/go/analysis/main.go
function main (line 6) | func main() {
FILE: semantic/test/fixtures/go/analysis/main1.go
function main (line 8) | func main() {
FILE: semantic/test/fixtures/go/corpus/array-types.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/array-types.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/array-with-implicit-length.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/array-with-implicit-length.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/assignment-statements.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/assignment-statements.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/binary-expressions.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/binary-expressions.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/call-expressions.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/call-expressions.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/case-statements.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/case-statements.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/channel-types.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/channel-types.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/comment.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/comment.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/const-declarations-with-types.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/const-declarations-with-types.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/const-declarations-without-types.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/const-declarations-without-types.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/const-with-implicit-values.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/const-with-implicit-values.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/constructors.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/constructors.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/float-literals.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/float-literals.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/for-statements.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/for-statements.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/function-declarations.A.go
function main (line 3) | func main() {}
function f1 (line 4) | func f1() {}
function f2 (line 5) | func f2(a int, b, c, d string) int {}
function f2 (line 6) | func f2() (int, error) {}
function f2 (line 7) | func f2() (result int, err error) {}
function lockedOSThread (line 8) | func lockedOSThread() bool
function getcontext (line 9) | func getcontext(c *u) /* int32 */ {}
FILE: semantic/test/fixtures/go/corpus/function-declarations.B.go
function main (line 3) | func main() {}
function fa (line 4) | func fa() {}
function fb (line 5) | func fb(a int, b, c, d string) int {}
function fc (line 6) | func fc() (int, error) {}
function fd (line 7) | func fd() (result int, err error) {}
function fe (line 8) | func fe() () {;}
function lockOSThread (line 9) | func lockOSThread() int
function setcontext (line 10) | func setcontext(c *u) /* int32 */ {}
FILE: semantic/test/fixtures/go/corpus/function-literals.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/function-literals.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/function-types.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/function-types.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/go-and-defer-statements.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/go-and-defer-statements.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/grouped-import-declarations.A.go
function main (line 9) | func main() {
FILE: semantic/test/fixtures/go/corpus/grouped-import-declarations.B.go
function main (line 9) | func main() {
FILE: semantic/test/fixtures/go/corpus/grouped-var-declarations.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/grouped-var-declarations.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/if-statements.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/if-statements.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/imaginary-literals.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/imaginary-literals.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/import-statements.A.go
function main (line 10) | func main() {}
FILE: semantic/test/fixtures/go/corpus/import-statements.B.go
function main (line 10) | func main() {}
FILE: semantic/test/fixtures/go/corpus/increment-decrement-statements.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/increment-decrement-statements.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/int-literals.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/int-literals.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/interface-types.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/interface-types.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/label-statements.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/label-statements.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/map-literals.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/map-literals.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/map-types.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/map-types.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/method-declarations.A.go
function main (line 3) | func main() {}
method Method (line 5) | func (s) Method()
method Equals (line 7) | func (self Person) Equals(other Person) bool {}
method Length (line 9) | func (p *Point) Length() float64 {
method Scale (line 13) | func (p *Point) Scale(factor float64) {
method Alive (line 18) | func (f *Field) Alive(x, y int) bool { }
FILE: semantic/test/fixtures/go/corpus/method-declarations.B.go
function main (line 3) | func main() {}
method Methods (line 5) | func (s) Methods()
method Equals (line 7) | func (self Num) Equals(other Num) bool {}
method OtherLength (line 9) | func (p *Point) OtherLength() float64 {
method Scale (line 13) | func (q *Point) Scale(factor int) {
method Alive (line 18) | func (f *Field) Alive(z, h int) bool { }
FILE: semantic/test/fixtures/go/corpus/modifying-struct-fields.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/modifying-struct-fields.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/parameter-declarations-with-types.A.go
function main (line 3) | func main() {
function foo (line 6) | func foo(a int, b string) {
FILE: semantic/test/fixtures/go/corpus/parameter-declarations-with-types.B.go
function main (line 3) | func main() {
function foo (line 6) | func foo(x string, y uint64) {
FILE: semantic/test/fixtures/go/corpus/pointer-types.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/pointer-types.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/qualified-types.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/qualified-types.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/rune-literals.A.go
constant a (line 3) | a = 'δ'
constant b (line 4) | b = '⌘'
constant c (line 5) | c = '⌘'
constant d (line 6) | d = '⌘'
constant e (line 7) | e = '⌘'
constant f (line 8) | f = '⌘'
FILE: semantic/test/fixtures/go/corpus/rune-literals.B.go
constant a (line 3) | a = '©'
constant b (line 4) | b = '©'
constant c (line 5) | c = '©'
constant d (line 6) | d = '©'
constant e (line 7) | e = '©'
constant f (line 8) | f = '©'
FILE: semantic/test/fixtures/go/corpus/select-statements.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/select-statements.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/selector-expressions.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/selector-expressions.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/send-statements.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/send-statements.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/short-var-declarations.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/short-var-declarations.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/single-import-declarations.A.go
function main (line 7) | func main() {
FILE: semantic/test/fixtures/go/corpus/single-import-declarations.B.go
function main (line 7) | func main() {
FILE: semantic/test/fixtures/go/corpus/single-line-function-declarations.A.go
function main (line 3) | func main() {
function f1 (line 7) | func f1() { a() }
function f2 (line 8) | func f2() { a(); b() }
function f3 (line 9) | func f3() { a(); b(); }
FILE: semantic/test/fixtures/go/corpus/single-line-function-declarations.B.go
function main (line 3) | func main() {
function g1 (line 7) | func g1() { a() }
function g2 (line 8) | func g2() { a(); b() }
function g3 (line 9) | func g3() { a(); b(); }
FILE: semantic/test/fixtures/go/corpus/slice-expressions.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/slice-expressions.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/slice-literals.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/slice-literals.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/slice-types.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/slice-types.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/string-literals.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/string-literals.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/struct-field-declarations.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/struct-field-declarations.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/struct-literals.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/struct-literals.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/struct-types.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/struct-types.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/switch-statements.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/switch-statements.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/type-aliases.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/type-aliases.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/type-assertion-expressions.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/type-assertion-expressions.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/type-conversion-expressions.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/type-conversion-expressions.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/type-declarations.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/type-declarations.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/type-switch-statements.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/type-switch-statements.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/unary-expressions.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/unary-expressions.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/var-declarations-with-no-expressions.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/var-declarations-with-no-expressions.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/var-declarations-with-types.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/var-declarations-with-types.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/var-declarations-without-types.A.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/var-declarations-without-types.B.go
function main (line 3) | func main() {
FILE: semantic/test/fixtures/go/corpus/variadic-function-declarations.A.go
function main (line 3) | func main() {
function f1 (line 6) | func f1(a ...*int) {}
function f2 (line 7) | func f2(...int) {}
function f3 (line 8) | func f3(a, ...bool) {}
FILE: semantic/test/fixtures/go/corpus/variadic-function-declarations.B.go
function main (line 3) | func main() {
function g1 (line 6) | func g1(a ...*int) {}
function g2 (line 7) | func g2(...int) {}
function g3 (line 8) | func g3(a, ...bool) {}
FILE: semantic/test/fixtures/go/import-graph/main.go
function foo (line 12) | func foo() {}
function main (line 14) | func main() {
FILE: semantic/test/fixtures/go/matching/for.go
function merle (line 3) | func merle() {
FILE: semantic/test/fixtures/go/matching/integers.go
function taako (line 3) | func taako() {
FILE: semantic/test/fixtures/go/tags/method.go
method CheckAuth (line 3) | func (c *apiClient) CheckAuth(req *http.Request, user, repo string) (*au...
FILE: semantic/test/fixtures/go/tags/simple_functions.go
function TestFromBits (line 6) | func TestFromBits(t *testing.T) {
function Hi (line 10) | func Hi() {
FILE: semantic/test/fixtures/go/toc/method-with-receiver.B.go
method CheckAuth (line 3) | func (c *apiClient) CheckAuth(req *http.Request, user, repo string) (*au...
FILE: semantic/test/fixtures/java/corpus/ArrayAccess.A.java
class Dinosaur (line 1) | class Dinosaur {
method apply (line 2) | void apply() {
FILE: semantic/test/fixtures/java/corpus/ArrayAccess.B.java
class Dinosaur (line 1) | class Dinosaur {
method apply (line 2) | void apply() {
FILE: semantic/test/fixtures/java/corpus/AssertStatement.A.java
class Dino (line 1) | class Dino {
method fn (line 2) | void fn() {
FILE: semantic/test/fixtures/java/corpus/AssertStatement.B.java
class Dino (line 1) | class Dino {
method fn (line 2) | void fn() {
FILE: semantic/test/fixtures/java/corpus/Boolean.A.java
class Point (line 1) | public class Point {
method dinosaur (line 2) | void dinosaur() {
FILE: semantic/test/fixtures/java/corpus/Boolean.B.java
class Point (line 1) | public class Point {
method dinosaur (line 2) | void dinosaur() {
FILE: semantic/test/fixtures/java/corpus/Char.A.java
class Point (line 1) | public class Point {
method dinosaur (line 2) | void dinosaur() {
FILE: semantic/test/fixtures/java/corpus/Char.B.java
class Point (line 1) | class Point {
method dinosaur (line 2) | Char dinosaur() {
FILE: semantic/test/fixtures/java/corpus/ClassBody.A.java
class Dino (line 1) | class Dino {
method dispose (line 2) | public void dispose() {
FILE: semantic/test/fixtures/java/corpus/ClassBody.B.java
class Dino (line 1) | class Dino {
FILE: semantic/test/fixtures/java/corpus/ClassLiteral.A.java
class Dino (line 1) | class Dino {
method normalError (line 2) | void normalError() {
FILE: semantic/test/fixtures/java/corpus/ClassLiteral.B.java
class Dino (line 1) | class Dino {
method normalError (line 2) | public static void normalError() {
FILE: semantic/test/fixtures/java/corpus/Continue.A.java
class Test (line 1) | public class Test {
method main (line 3) | public static void main(String args[]) {
FILE: semantic/test/fixtures/java/corpus/Continue.B.java
class Test (line 1) | class Test {
method main (line 2) | public static void main(String[] args) {
FILE: semantic/test/fixtures/java/corpus/Continue0.A.java
class Test (line 1) | public class Test {
method main (line 3) | public static void main(String args[]) {
FILE: semantic/test/fixtures/java/corpus/Continue1.A.java
class Test (line 1) | public class Test {
method main (line 3) | public static void main(String args[]) {
FILE: semantic/test/fixtures/java/corpus/Dims.A.java
class ForDemo (line 1) | class ForDemo { int[] metrics; }
FILE: semantic/test/fixtures/java/corpus/Dims.B.java
class ForDemo (line 1) | class ForDemo {
method main (line 2) | void main(String[] args){
FILE: semantic/test/fixtures/java/corpus/DoWhile.A.java
class WhileDemo (line 1) | class WhileDemo {
method main (line 2) | public static void main(String[] args){
FILE: semantic/test/fixtures/java/corpus/DoWhile.B.java
class WhileDemo (line 1) | class WhileDemo {
method main (line 2) | public static void main(String[] args) {
FILE: semantic/test/fixtures/java/corpus/EnumDeclaration.A.java
type Colour (line 1) | public enum Colour {
FILE: semantic/test/fixtures/java/corpus/EnumDeclaration.B.java
type Colour (line 1) | enum Colour
FILE: semantic/test/fixtures/java/corpus/FieldAccess.A.java
class Grouped (line 1) | class Grouped {
method Flowable (line 2) | Flowable(K key) {
FILE: semantic/test/fixtures/java/corpus/FieldAccess.B.java
class Grouped (line 1) | class Grouped {
method Flowable (line 2) | Flowable(K key) {
FILE: semantic/test/fixtures/java/corpus/Float.A.java
class Point (line 1) | public class Point {
method dinosaur (line 2) | void dinosaur() {
FILE: semantic/test/fixtures/java/corpus/Float.B.java
class Point (line 1) | public class Point {
method dinosaur (line 2) | void dinosaur() {
FILE: semantic/test/fixtures/java/corpus/For.A.java
class ForDemo (line 1) | class ForDemo {
method main (line 2) | public static void main(String[] args){
FILE: semantic/test/fixtures/java/corpus/For.B.java
class ForDemo (line 1) | class ForDemo {
method main (line 2) | public static void main(String[] args){
FILE: semantic/test/fixtures/java/corpus/Int.A.java
class Point (line 1) | public class Point {
method dinosaur (line 2) | void dinosaur() {
FILE: semantic/test/fixtures/java/corpus/Int.B.java
class Point (line 1) | public class Point {
method dinosaur (line 2) | void dinosaur() {
FILE: semantic/test/fixtures/java/corpus/Interface.A.java
type Top (line 1) | interface Top {
FILE: semantic/test/fixtures/java/corpus/Lambda.A.java
class LambdaTest (line 1) | class LambdaTest {
method singleton (line 2) | void singleton() {
FILE: semantic/test/fixtures/java/corpus/Lambda.B.java
class LambdaTest (line 1) | class LambdaTest {
method singleton (line 2) | void singleton() {
FILE: semantic/test/fixtures/java/corpus/ScopedIdentifier.A.java
class Natural (line 1) | class Natural {
method compare (line 2) | int compare(Object a, Object b) {
FILE: semantic/test/fixtures/java/corpus/ScopedIdentifier.B.java
class EventLoopWorker (line 1) | static final class EventLoopWorker extends Scheduler.Worker {
FILE: semantic/test/fixtures/java/corpus/SpreadParameter.A.java
class Dinosaur (line 1) | class Dinosaur {
method Disposable (line 2) | Disposable(Disposable... resources) {
FILE: semantic/test/fixtures/java/corpus/SpreadParameter.B.java
class Dinosaur (line 1) | class Dinosaur {
method Disposable (line 2) | Disposable(int ...resources) {
FILE: semantic/test/fixtures/java/corpus/String.A.java
class Point (line 1) | public class Point {
method dinosaur (line 2) | void dinosaur() {
FILE: semantic/test/fixtures/java/corpus/String.B.java
class Point (line 1) | public class Point {
method dinosaur (line 2) | void dinosaur() {
FILE: semantic/test/fixtures/java/corpus/Switch.A.java
class Test (line 1) | public class Test
method main (line 3) | public static void main(String[] args)
FILE: semantic/test/fixtures/java/corpus/Switch.B.java
class Test (line 1) | public class Test
method main (line 3) | public static void main(String[] args)
FILE: semantic/test/fixtures/java/corpus/Throws.A.java
class Beyonce (line 1) | class Beyonce {
method x (line 2) | void x() {
FILE: semantic/test/fixtures/java/corpus/Throws.B.java
class Beyonce (line 1) | class Beyonce {
method newReader (line 2) | BufferedReader newReader() throws FileNotFoundException {
FILE: semantic/test/fixtures/java/corpus/TryCatches.A.java
class Example2 (line 1) | class Example2{
method main (line 2) | public static void main(String args[]){
FILE: semantic/test/fixtures/java/corpus/TryCatches.B.java
class Example2 (line 1) | class Example2{
method main (line 2) | public static void main(String args[]){
FILE: semantic/test/fixtures/java/corpus/TryWithResourcesStatement.A.java
class Dino (line 1) | class Dino {
method hi (line 2) | void hi() {
FILE: semantic/test/fixtures/java/corpus/TryWithResourcesStatement.B.java
class Dino (line 1) | class Dino {
method hi (line 2) | void hi() {
FILE: semantic/test/fixtures/java/corpus/TypeArgument.A.java
class Test (line 1) | class Test {
method printCollection (line 2) | void printCollection(Collection<String> c) {
FILE: semantic/test/fixtures/java/corpus/TypeArgument.B.java
class Test (line 1) | class Test {
method printCollection (line 2) | static void printCollection(Collection<?> c) {
FILE: semantic/test/fixtures/java/corpus/VariableDeclaration.A.java
class Dino (line 1) | class Dino {
method test (line 2) | void test() {
FILE: semantic/test/fixtures/java/corpus/VariableDeclaration.B.java
class Dino (line 1) | class Dino {
method test (line 2) | void test() {
FILE: semantic/test/fixtures/java/corpus/While.A.java
class WhileDemo (line 1) | class WhileDemo {
method main (line 2) | public static void main(String[] args){
FILE: semantic/test/fixtures/java/corpus/While.B.java
class WhileDemo (line 1) | class WhileDemo {
method main (line 2) | void main(String[] args){
FILE: semantic/test/fixtures/java/corpus/Wildcard.A.java
class Connectable (line 1) | class Connectable {
method connect (line 2) | void connect(Consumer<? super Disposable> connection);
FILE: semantic/test/fixtures/java/corpus/Wildcard.B.java
class Connectable (line 1) | class Connectable {
method connect (line 2) | void connect(C<? extends B> connection);
FILE: semantic/test/fixtures/java/corpus/array-access.java
class Dinosaur (line 1) | class Dinosaur {
method apply (line 2) | void apply() {
FILE: semantic/test/fixtures/java/corpus/assertStatement.java
class Dino (line 1) | class Dino {
method fn (line 2) | void fn() {
FILE: semantic/test/fixtures/java/corpus/assertStringLiteral.java
class Dino (line 1) | class Dino {
method hi (line 2) | void hi() {
FILE: semantic/test/fixtures/java/corpus/enum.java
type HandSign (line 1) | enum HandSign {
FILE: semantic/test/fixtures/java/corpus/methodReference.java
class TermsSetQueryBuilder (line 1) | class TermsSetQueryBuilder {
method Terms (line 2) | void Terms() {
method Terms (line 8) | void Terms() {
class TermsSetQueryBuilder (line 7) | class TermsSetQueryBuilder {
method Terms (line 2) | void Terms() {
method Terms (line 8) | void Terms() {
FILE: semantic/test/fixtures/java/corpus/modifier-abstract.java
class Point (line 1) | abstract class Point {
FILE: semantic/test/fixtures/java/corpus/modifier-protected.java
class Point (line 1) | protected class Point {
FILE: semantic/test/fixtures/java/corpus/modifier-public.java
class Point (line 1) | public class Point {
FILE: semantic/test/fixtures/java/corpus/modifier-static.java
class Point (line 1) | public static class Point {
FILE: semantic/test/fixtures/java/corpus/null.java
class Point (line 1) | public class Point {
method dinosaur (line 2) | void dinosaur() {
FILE: semantic/test/fixtures/java/corpus/return.java
class Point (line 1) | public class Point {
method dinosaur (line 2) | void dinosaur() {
FILE: semantic/test/fixtures/java/corpus/try.java
class Bar (line 1) | public class Bar {
method foo (line 2) | public void foo() {
FILE: semantic/test/fixtures/java/corpus/try_with_resources.java
class Bar (line 1) | public class Bar {
method foo (line 2) | public void foo() {
FILE: semantic/test/fixtures/javascript/analysis/exports/lib.js
function square (line 1) | function square(x) {
function area (line 4) | function area(x, y) {
FILE: semantic/test/fixtures/javascript/analysis/foo.js
function bar (line 3) | function bar() {
FILE: semantic/test/fixtures/javascript/corpus/class.A.js
class Foo (line 1) | class Foo { bar = 5; static one(a) { return a; }; two(b) { return b; } t...
method one (line 1) | static one(a) { return a; }
method two (line 1) | two(b) { return b; }
method three (line 1) | three(c) { return c; }
FILE: semantic/test/fixtures/javascript/corpus/class.B.js
class Foo (line 1) | class Foo { static foo(a) { return a; }; bar(b) { return b; } baz(c) { r...
method foo (line 1) | static foo(a) { return a; }
method bar (line 1) | bar(b) { return b; }
method baz (line 1) | baz(c) { return c; }
FILE: semantic/test/fixtures/javascript/corpus/export.A.js
function name1 (line 7) | function name1() { }
FILE: semantic/test/fixtures/javascript/corpus/export.B.js
function newName1 (line 6) | function newName1() {}
FILE: semantic/test/fixtures/javascript/corpus/jsx.A.js
function Something (line 1) | function Something() {
FILE: semantic/test/fixtures/javascript/corpus/jsx.B.js
function Something (line 1) | function Something() {
FILE: semantic/test/fixtures/javascript/corpus/named-function.A.js
function myFunction (line 1) | function myFunction(arg1, arg2) { arg2; }
FILE: semantic/test/fixtures/javascript/corpus/named-function.B.js
function anotherFunction (line 1) | function anotherFunction() { return false; }
FILE: semantic/test/fixtures/javascript/corpus/nested-do-while-in-function.A.js
function f (line 1) | function f(arg1, arg2) { do { something(arg1); } while (arg2); }
FILE: semantic/test/fixtures/javascript/corpus/nested-do-while-in-function.B.js
function f (line 1) | function f(arg1, arg2) { do { something(arg2); } while (arg1); }
FILE: semantic/test/fixtures/javascript/corpus/nested-functions.A.js
function parent (line 1) | function parent (arg1, arg2) { function child (arg3, arg4) { console.log...
FILE: semantic/test/fixtures/javascript/corpus/nested-functions.B.js
function parent (line 1) | function parent (arg1, arg2) { function child (arg3, arg4) { console.log...
FILE: semantic/test/fixtures/javascript/corpus/objects-with-methods.A.js
method add (line 1) | add(a, b) { return a + b; }
FILE: semantic/test/fixtures/javascript/corpus/objects-with-methods.B.js
method subtract (line 1) | subtract(a, b) { return a - b; }
FILE: semantic/test/fixtures/javascript/tags/simple_function_with_docs.js
function myFunction (line 2) | function myFunction() {
FILE: semantic/test/fixtures/javascript/toc/duplicate-parent.A.js
function myFunction (line 1) | function myFunction() {
FILE: semantic/test/fixtures/javascript/toc/duplicate-parent.B.js
function myFunction (line 1) | function myFunction() {
FILE: semantic/test/fixtures/javascript/toc/erroneous-duplicate-method.A.js
function performHealthcheck (line 10) | function performHealthcheck() {
FILE: semantic/test/fixtures/javascript/toc/erroneous-duplicate-method.B.js
function performHealthCheck (line 8) | function performHealthCheck(container, repoName) {
FILE: semantic/test/fixtures/php/analysis/bar.php
function bar (line 2) | function bar() {
FILE: semantic/test/fixtures/php/analysis/foo.php
function foo (line 2) | function foo() {
FILE: semantic/test/fixtures/php/analysis/namespaces.php
function f (line 5) | function f() {
function b (line 12) | function b() {
function c (line 18) | function c() {
FILE: semantic/test/fixtures/python/analysis/a.py
function foo (line 1) | def foo(x):
FILE: semantic/test/fixtures/python/analysis/b/c.py
function baz (line 1) | def baz(x):
FILE: semantic/test/fixtures/python/analysis/c/utils.py
function to_s (line 1) | def to_s():
FILE: semantic/test/fixtures/python/analysis/multiple_inheritance.py
class Foo (line 1) | class Foo:
method dang (line 2) | def dang(self):
class Bar (line 5) | class Bar:
method dang (line 6) | def dang(self):
class Baz (line 10) | class Baz(Foo, Bar): pass
FILE: semantic/test/fixtures/python/analysis/subclass.py
class Foo (line 1) | class Foo():
method dang (line 2) | def dang():
class Bar (line 5) | class Bar():
method dang (line 6) | def dang():
FILE: semantic/test/fixtures/python/corpus/async-function-definition.A.py
function a (line 1) | async def a():
function b (line 4) | async def b(h, i,):
function c (line 7) | async def c(d):
FILE: semantic/test/fixtures/python/corpus/async-function-definition.B.py
function g (line 1) | async def g(i, j,):
function a (line 4) | async def a():
function d (line 7) | async def d(c):
FILE: semantic/test/fixtures/python/corpus/class-definition.A.py
class A (line 1) | class A:
method b (line 2) | def b(self):
class C (line 5) | class C():
class B (line 8) | class B(method1):
method method1 (line 9) | def method1(self):
class D (line 12) | class D(e):
FILE: semantic/test/fixtures/python/corpus/class-definition.B.py
class D (line 1) | class D(method1):
method method1 (line 2) | def method1(self):
class B (line 5) | class B:
method b (line 6) | def b(self):
class E (line 9) | class E(e):
FILE: semantic/test/fixtures/python/corpus/decorated-definition.A.py
class C (line 2) | class C:
method f (line 10) | def f():
FILE: semantic/test/fixtures/python/corpus/decorated-definition.B.py
class D (line 2) | class D:
method f (line 7) | def f():
FILE: semantic/test/fixtures/python/corpus/function-definition.A.py
function a (line 1) | def a():
function c (line 4) | def c(d):
function g (line 7) | def g(g, *h,):
function h (line 10) | def h(i=j):
function i (line 13) | def i(j:str="default", **c):
FILE: semantic/test/fixtures/python/corpus/function-definition.B.py
function g (line 1) | def g(i, *j,):
function c (line 4) | def c():
function d (line 7) | def d(e):
function i (line 10) | def i(j:int=1, **d):
FILE: semantic/test/fixtures/python/graphing/conditional/conditional.py
function merle (line 4) | def merle(): pass
function taako (line 7) | def taako(): pass
FILE: semantic/test/fixtures/python/graphing/simple/simple.py
function magnus (line 1) | def magnus():
FILE: semantic/test/fixtures/python/graphing/typeerror/typeerror.py
function lup (line 3) | def lup(): pass
FILE: semantic/test/fixtures/python/graphing/unbound/unbound.py
function lucretia (line 3) | def lucretia(): pass
FILE: semantic/test/fixtures/python/import-graph/main.py
function print_cwd (line 11) | def print_cwd():
function create_array (line 14) | def create_array():
function sum_array (line 18) | def sum_array(x):
function sum_array2 (line 22) | def sum_array2(x):
FILE: semantic/test/fixtures/python/matching/docstrings.py
function foo (line 1) | def foo():
function bar (line 5) | def bar():
FILE: semantic/test/fixtures/python/matching/docstrings_nested.py
function foo (line 1) | def foo():
function bar (line 5) | def bar():
FILE: semantic/test/fixtures/python/reprinting/function.out.py
function Foo (line 1) | def Foo(x):
FILE: semantic/test/fixtures/python/reprinting/function.py
function Foo (line 1) | def Foo(x):
FILE: semantic/test/fixtures/python/tags/class.py
class Foo (line 1) | class Foo:
method f (line 3) | def f(self):
FILE: semantic/test/fixtures/python/tags/multiline.py
function Foo (line 1) | def Foo(x,
FILE: semantic/test/fixtures/python/tags/simple_function_with_docs.py
function Foo (line 1) | def Foo(x):
FILE: semantic/test/fixtures/python/tags/simple_functions.py
function Foo (line 1) | def Foo(x):
function Bar (line 7) | def Bar():
FILE: semantic/test/fixtures/ruby/analysis/call.rb
function foo (line 1) | def foo(x, y)
FILE: semantic/test/fixtures/ruby/analysis/classes.rb
class A (line 1) | class A
method hi (line 2) | def self.hi
method hi (line 8) | def self.hi
class B (line 11) | class B
method hi (line 12) | def self.hi
class A (line 7) | class A
method hi (line 2) | def self.hi
method hi (line 8) | def self.hi
class B (line 11) | class B
method hi (line 12) | def self.hi
FILE: semantic/test/fixtures/ruby/analysis/early-return.rb
function foo (line 1) | def foo
FILE: semantic/test/fixtures/ruby/analysis/foo.rb
function foo (line 1) | def foo(x)
FILE: semantic/test/fixtures/ruby/analysis/line.rb
function foo (line 3) | def foo
FILE: semantic/test/fixtures/ruby/analysis/modules.rb
type Bar (line 1) | module Bar
function hi (line 2) | def self.hi
function hi (line 8) | def self.hi
type Baz (line 11) | module Baz
function baz (line 12) | def self.baz
type Bar (line 7) | module Bar
function hi (line 2) | def self.hi
function hi (line 8) | def self.hi
type Baz (line 11) | module Baz
function baz (line 12) | def self.baz
FILE: semantic/test/fixtures/ruby/analysis/preluded.rb
class Foo (line 1) | class Foo < Object
method inspect (line 2) | def inspect
FILE: semantic/test/fixtures/ruby/analysis/src/foo.rb
function foo (line 1) | def foo()
FILE: semantic/test/fixtures/ruby/analysis/subclass.rb
class Foo (line 1) | class Foo
method inspect (line 2) | def inspect
method foo (line 6) | def foo
class Bar (line 11) | class Bar < Foo
method inspect (line 12) | def inspect
method baz (line 18) | def baz
class Bar (line 17) | class Bar
method inspect (line 12) | def inspect
method baz (line 18) | def baz
FILE: semantic/test/fixtures/ruby/corpus/begin.A.rb
function foo (line 1) | def foo
FILE: semantic/test/fixtures/ruby/corpus/begin.B.rb
function foo (line 1) | def foo
FILE: semantic/test/fixtures/ruby/corpus/class.A.rb
class Foo (line 1) | class Foo < Super
method test (line 2) | def test; end
class Foo::Bar (line 5) | class Foo::Bar
FILE: semantic/test/fixtures/ruby/corpus/class.B.rb
class Foo (line 1) | class Foo
method test (line 2) | def test; end
FILE: semantic/test/fixtures/ruby/corpus/method-declaration-keyword-param.A.rb
function foo (line 1) | def foo()
FILE: semantic/test/fixtures/ruby/corpus/method-declaration-keyword-param.B.rb
function foo (line 1) | def foo(name: nil)
FILE: semantic/test/fixtures/ruby/corpus/method-declaration-param-default.A.rb
function foo (line 1) | def foo()
FILE: semantic/test/fixtures/ruby/corpus/method-declaration-param-default.B.rb
function foo (line 1) | def foo(name = nil)
FILE: semantic/test/fixtures/ruby/corpus/method-declaration-params.A.rb
function foo (line 1) | def foo(a)
FILE: semantic/test/fixtures/ruby/corpus/method-declaration-params.B.rb
function foo (line 1) | def foo(a, b, c)
FILE: semantic/test/fixtures/ruby/corpus/method-declaration-required-keyword-param.A.rb
function foo (line 1) | def foo()
FILE: semantic/test/fixtures/ruby/corpus/method-declaration-required-keyword-param.B.rb
function foo (line 1) | def foo(name:)
FILE: semantic/test/fixtures/ruby/corpus/method-declaration-unnamed-param.A.rb
function foo (line 1) | def foo(name)
FILE: semantic/test/fixtures/ruby/corpus/method-declaration-unnamed-param.B.rb
function foo (line 1) | def foo(name, **)
FILE: semantic/test/fixtures/ruby/corpus/method-declaration.A.rb
function foo (line 1) | def foo
FILE: semantic/test/fixtures/ruby/corpus/method-declaration.B.rb
function bar (line 1) | def bar(a)
FILE: semantic/test/fixtures/ruby/corpus/methods.A.rb
function foo (line 1) | def foo
function bar= (line 4) | def bar=
function -@ (line 7) | def -@(a)
function foo (line 10) | def foo(a, b: false, c: nil, **)
function foo (line 13) | def foo(*args)
function foo (line 16) | def foo(&block)
function foo (line 19) | def self.foo
function foo (line 22) | def self.foo(a, b)
FILE: semantic/test/fixtures/ruby/corpus/module.A.rb
type Foo (line 1) | module Foo
type A::B (line 4) | module A::B
FILE: semantic/test/fixtures/ruby/corpus/module.B.rb
type Foo (line 1) | module Foo
function bar (line 2) | def bar
FILE: semantic/test/fixtures/ruby/corpus/rescue.A.rb
function foo (line 12) | def foo
FILE: semantic/test/fixtures/ruby/import-graph/app.rb
function foo (line 4) | def foo(x)
FILE: semantic/test/fixtures/ruby/reprinting/function.out.rb
function foo (line 1) | def foo(x)
FILE: semantic/test/fixtures/ruby/reprinting/function.rb
function foo (line 1) | def foo(x)
FILE: semantic/test/fixtures/ruby/tags/class_module.rb
type Foo (line 2) | module Foo
class Bar (line 5) | class Bar
method baz (line 8) | def baz(a)
class A::B::C (line 14) | class A::B::C
method foo (line 15) | def foo
method foo (line 18) | def self.foo
FILE: semantic/test/fixtures/ruby/tags/simple_method.rb
function foo (line 1) | def foo
FILE: semantic/test/fixtures/ruby/tags/simple_method_with_docs.rb
function foo (line 2) | def foo
FILE: semantic/test/fixtures/ruby/tags/unicode_identifiers.rb
function 日本語 (line 2) | def 日本語
FILE: semantic/test/fixtures/ruby/toc/classes.A.rb
class Baz (line 1) | class Baz
class Foo (line 4) | class Foo
FILE: semantic/test/fixtures/ruby/toc/classes.B.rb
class Foo (line 1) | class Foo
class Bar (line 5) | class Bar
FILE: semantic/test/fixtures/ruby/toc/method-starts-with-two-identifiers.A.rb
function foo (line 1) | def foo
FILE: semantic/test/fixtures/ruby/toc/method-starts-with-two-identifiers.B.rb
function foo (line 1) | def foo
FILE: semantic/test/fixtures/ruby/toc/methods.A.rb
function bar (line 1) | def bar
function baz (line 4) | def baz(x, y, z)
FILE: semantic/test/fixtures/ruby/toc/methods.B.rb
function foo (line 1) | def self.foo(a, *)
function bar (line 4) | def bar
FILE: semantic/test/fixtures/ruby/toc/methods.X.rb
function bar (line 1) | def bar
FILE: semantic/test/fixtures/ruby/toc/unicode.B.rb
function foo (line 6) | def foo(a, b, c)
FILE: semantic/test/fixtures/typescript/analysis/a.ts
function baz (line 1) | function baz() {
FILE: semantic/test/fixtures/typescript/analysis/access_control/adder.ts
class Adder (line 1) | class Adder {
method private_add (line 7) | private private_add() {}
method constructor (line 9) | constructor(x, y) {
FILE: semantic/test/fixtures/typescript/analysis/await.ts
function f2 (line 1) | async function f2() {
FILE: semantic/test/fixtures/typescript/analysis/class2.ts
class Adder (line 1) | class Adder {
method constructor (line 3) | constructor(summand: number) {
method add (line 6) | add() {
FILE: semantic/test/fixtures/typescript/analysis/early-return.ts
function foo (line 1) | function foo() {
FILE: semantic/test/fixtures/typescript/analysis/foo.ts
function foo (line 1) | function foo() {
function baz (line 5) | function baz() {
FILE: semantic/test/fixtures/typescript/analysis/foo/b.ts
function quz (line 1) | function quz() {
FILE: semantic/test/fixtures/typescript/analysis/foo2.ts
function foo (line 1) | function foo(x) {
FILE: semantic/test/fixtures/typescript/analysis/pip.ts
function pip (line 3) | function pip() {
FILE: semantic/test/fixtures/typescript/analysis/void.ts
function foo (line 1) | function foo() {
FILE: semantic/test/fixtures/typescript/corpus/ambient-declarations.A.ts
class Error (line 1) | class Error {
type LogOptions (line 13) | interface LogOptions {
type AlertOptions (line 16) | interface AlertOptions {
class Greeter (line 23) | class Greeter {
FILE: semantic/test/fixtures/typescript/corpus/ambient-declarations.B.ts
class Bar (line 4) | class Bar {
type LogOptions (line 7) | interface LogOptions {
class Greeter (line 11) | class Greeter {
FILE: semantic/test/fixtures/typescript/corpus/ambient-exports.A.ts
class Foo (line 1) | class Foo{}
FILE: semantic/test/fixtures/typescript/corpus/ambient-exports.B.ts
function bar (line 1) | function bar(x: number, y: number) {
FILE: semantic/test/fixtures/typescript/corpus/ambient-type-declarations.A.ts
type IndexableType (line 1) | type IndexableType = string | number | Date | Array<string | number | Da...
FILE: semantic/test/fixtures/typescript/corpus/ambient-type-declarations.B.ts
type IndexableType (line 1) | type IndexableType = string | number | Date | Array<string | number | Da...
FILE: semantic/test/fixtures/typescript/corpus/class.A.ts
class Foo (line 1) | class Foo<Bar> extends Baz { bar = 5; static one(a) { return a; }; two(b...
method one (line 1) | static one(a) { return a; }
method two (line 1) | two(b) { return b; }
method three (line 1) | three(c) { return c; }
FILE: semantic/test/fixtures/typescript/corpus/class.B.ts
class Bar (line 1) | class Bar<Z> extends A { static foo(a) { return a; }; bar(b) { return b;...
method foo (line 1) | static foo(a) { return a; }
method bar (line 1) | bar(b) { return b; }
method baz (line 1) | baz(c) { return c; }
FILE: semantic/test/fixtures/typescript/corpus/export.A.ts
function name1 (line 7) | function name1() { }
FILE: semantic/test/fixtures/typescript/corpus/export.B.ts
function newName1 (line 6) | function newName1() {}
FILE: semantic/test/fixtures/typescript/corpus/interface.A.ts
type IResult (line 1) | interface IResult<T> {
FILE: semantic/test/fixtures/typescript/corpus/interface.B.ts
type IError (line 1) | interface IError {
FILE: semantic/test/fixtures/typescript/corpus/method-definition.A.ts
class Foo (line 1) | class Foo {
method foo (line 2) | public foo(): Int {}
FILE: semantic/test/fixtures/typescript/corpus/method-definition.B.ts
class Foo (line 1) | class Foo {
method foo (line 2) | public static readonly async foo(): string {}
FILE: semantic/test/fixtures/typescript/corpus/named-function.A.ts
function myFunction (line 1) | function myFunction(arg1, arg2) { arg2; }
FILE: semantic/test/fixtures/typescript/corpus/named-function.B.ts
function anotherFunction (line 1) | function anotherFunction() { return false; }
FILE: semantic/test/fixtures/typescript/corpus/nested-do-while-in-function.A.ts
function f (line 1) | function f(arg1, arg2) { do { something(arg1); } while (arg2); }
FILE: semantic/test/fixtures/typescript/corpus/nested-do-while-in-function.B.ts
function f (line 1) | function f(arg1, arg2) { do { something(arg2); } while (arg1); }
FILE: semantic/test/fixtures/typescript/corpus/nested-functions.A.ts
function parent (line 1) | function parent (arg1, arg2) { function child (arg3, arg4) { console.log...
FILE: semantic/test/fixtures/typescript/corpus/nested-functions.B.ts
function parent (line 1) | function parent (arg1, arg2) { function child (arg3, arg4) { console.log...
FILE: semantic/test/fixtures/typescript/corpus/objects-with-methods.A.ts
method add (line 1) | add(a, b) { return a + b; }
FILE: semantic/test/fixtures/typescript/corpus/objects-with-methods.B.ts
method subtract (line 1) | subtract(a, b) { return a - b; }
FILE: semantic/test/fixtures/typescript/corpus/public-field-definition.A.ts
class Foo (line 1) | class Foo {
FILE: semantic/test/fixtures/typescript/corpus/public-field-definition.B.ts
class Foo (line 1) | class Foo {
FILE: semantic/test/fixtures/typescript/import-graph/app.ts
function someFunction (line 11) | function someFunction(arg1, arg2): string { arg2; }
FILE: semantic/test/fixtures/typescript/tags/class.ts
class FooBar (line 1) | class FooBar {}
Condensed preview — 3053 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (5,768K chars).
[
{
"path": ".bazelignore",
"chars": 482,
"preview": "semantic/dist-newstyle\nsemantic-analysis/dist-newstyle\nsemantic-ast/dist-newstyle\nsemantic-codeql/dist-newstyle\nsemantic"
},
{
"path": ".bazelrc",
"chars": 658,
"preview": "build:ci --loading_phase_threads=1\nbuild:ci --jobs=2\nbuild:ci --verbose_failures\ncommon:ci --color=no\ntest:ci --test_out"
},
{
"path": ".dockerignore",
"chars": 182,
"preview": "Dockerfile\n/.licenses\n/.git\n.ghci\n.ghci_history\n.ghc.environment.x86_64-darwin-8.6.5\n*.yaml\n*.md\n\n/bin\n/dist\n/dist-newst"
},
{
"path": ".ghci.repl",
"chars": 1568,
"preview": "-- GHCI settings for script/repl.\n-- These live here instead of script/repl for ease of commenting.\n-- These live here i"
},
{
"path": ".ghci.sample",
"chars": 726,
"preview": "-- Consider copying this to your ~/.ghc/ghci.conf file:\n\n-- Pretty-printing\n:set -package-id prtty-smpl-3.1.1.0-c89f0500"
},
{
"path": ".gitattributes",
"chars": 136,
"preview": ".licenses linguist-vendored\ntest/fixtures linguist-vendored\ntest/repos linguist-vendored\nvendor linguist-vendored\n*.prot"
},
{
"path": ".github/workflows/bazel.yml.disabled",
"chars": 1210,
"preview": "name: Bazel CI\n\non:\n # Trigger the workflow on push or pull request,\n # but only for the master branch\n push:\n bra"
},
{
"path": ".github/workflows/haskell.yml",
"chars": 3054,
"preview": "name: Haskell CI\n\non:\n # Trigger the workflow on push or pull request,\n # but only for the master branch\n push:\n b"
},
{
"path": ".gitignore",
"chars": 460,
"preview": ".DS_Store\n\n.docsets\n.stack-work\n.stack-work-profiling\nstack.yaml\nstack.yaml.lock\nprofiles\n/tags\n\ncabal.project.local*\ndi"
},
{
"path": ".gitmodules",
"chars": 0,
"preview": ""
},
{
"path": ".hlint.yaml",
"chars": 3401,
"preview": "# HLint configuration file\n# https://github.com/ndmitchell/hlint\n\n- arguments: [--color=auto, -XStrictData]\n\n# Blacklist"
},
{
"path": ".hspec",
"chars": 13,
"preview": "--depth=1000\n"
},
{
"path": ".licenses/semantic/cabal/MonadRandom.txt",
"chars": 1794,
"preview": "---\ntype: cabal\nname: MonadRandom\nversion: 0.5.1.1\nsummary: Random-number generation monad.\nhomepage: \nlicense: bsd-3-cl"
},
{
"path": ".licenses/semantic/cabal/QuickCheck.txt",
"chars": 1772,
"preview": "---\ntype: cabal\nname: QuickCheck\nversion: 2.12.6.1\nsummary: Automatic testing of Haskell programs\nhomepage: https://gith"
},
{
"path": ".licenses/semantic/cabal/StateVar.txt",
"chars": 1680,
"preview": "---\ntype: cabal\nname: StateVar\nversion: 1.1.1.1\nsummary: State variables\nhomepage: https://github.com/haskell-opengl/Sta"
},
{
"path": ".licenses/semantic/cabal/adjunctions.txt",
"chars": 1440,
"preview": "---\ntype: cabal\nname: adjunctions\nversion: '4.4'\nsummary: Adjunctions and representable functors\nhomepage: https://githu"
},
{
"path": ".licenses/semantic/cabal/aeson-pretty.txt",
"chars": 1712,
"preview": "---\ntype: cabal\nname: aeson-pretty\nversion: 0.8.7\nsummary: JSON pretty-printing library and command-line tool.\nhomepage:"
},
{
"path": ".licenses/semantic/cabal/aeson.txt",
"chars": 1613,
"preview": "---\ntype: cabal\nname: aeson\nversion: 1.4.2.0\nsummary: Fast JSON parsing and encoding\nhomepage: https://github.com/bos/ae"
},
{
"path": ".licenses/semantic/cabal/algebraic-graphs.txt",
"chars": 1262,
"preview": "---\ntype: cabal\nname: algebraic-graphs\nversion: '0.3'\nsummary: A library for algebraic graph construction and transforma"
},
{
"path": ".licenses/semantic/cabal/ansi-terminal.txt",
"chars": 1744,
"preview": "---\ntype: cabal\nname: ansi-terminal\nversion: 0.8.2\nsummary: Simple ANSI terminal support, with Windows compatibility\nhom"
},
{
"path": ".licenses/semantic/cabal/ansi-wl-pprint.txt",
"chars": 1499,
"preview": "---\ntype: cabal\nname: ansi-wl-pprint\nversion: 0.6.8.2\nsummary: The Wadler/Leijen Pretty Printer for colored ANSI termina"
},
{
"path": ".licenses/semantic/cabal/array.txt",
"chars": 4001,
"preview": "---\ntype: cabal\nname: array\nversion: 0.5.3.0\nsummary: Mutable and immutable arrays\nhomepage: \nlicense: bsd-3-clause\n---\n"
},
{
"path": ".licenses/semantic/cabal/asn1-encoding.txt",
"chars": 1684,
"preview": "---\ntype: cabal\nname: asn1-encoding\nversion: 0.9.5\nsummary: ASN1 data reader and writer in RAW, BER and DER forms\nhomepa"
},
{
"path": ".licenses/semantic/cabal/asn1-parse.txt",
"chars": 1672,
"preview": "---\ntype: cabal\nname: asn1-parse\nversion: 0.9.4\nsummary: Simple monadic parser for ASN1 stream types.\nhomepage: https://"
},
{
"path": ".licenses/semantic/cabal/asn1-types.txt",
"chars": 1645,
"preview": "---\ntype: cabal\nname: asn1-types\nversion: 0.3.2\nsummary: ASN.1 types\nhomepage: https://github.com/vincenthz/hs-asn1-type"
},
{
"path": ".licenses/semantic/cabal/async.txt",
"chars": 1704,
"preview": "---\ntype: cabal\nname: async\nversion: 2.2.1\nsummary: Run IO operations asynchronously and wait for their results\nhomepage"
},
{
"path": ".licenses/semantic/cabal/attoparsec-iso8601.txt",
"chars": 1645,
"preview": "---\ntype: cabal\nname: attoparsec-iso8601\nversion: 1.0.1.0\nsummary: Parsing of ISO 8601 dates, originally from aeson.\nhom"
},
{
"path": ".licenses/semantic/cabal/attoparsec.txt",
"chars": 1638,
"preview": "---\ntype: cabal\nname: attoparsec\nversion: 0.13.2.2\nsummary: Fast combinator parsing for bytestrings and text\nhomepage: h"
},
{
"path": ".licenses/semantic/cabal/base-compat-batteries.txt",
"chars": 1249,
"preview": "---\ntype: cabal\nname: base-compat-batteries\nversion: 0.10.5\nsummary: base-compat with extra batteries\nhomepage: \nlicense"
},
{
"path": ".licenses/semantic/cabal/base-compat.txt",
"chars": 1237,
"preview": "---\ntype: cabal\nname: base-compat\nversion: 0.10.5\nsummary: A compatibility layer for base\nhomepage: \nlicense: mit\n---\nCo"
},
{
"path": ".licenses/semantic/cabal/base-orphans.txt",
"chars": 1337,
"preview": "---\ntype: cabal\nname: base-orphans\nversion: '0.8'\nsummary: Backwards-compatible orphan instances for base\nhomepage: http"
},
{
"path": ".licenses/semantic/cabal/base-prelude.txt",
"chars": 1253,
"preview": "---\ntype: cabal\nname: base-prelude\nversion: '1.3'\nsummary: The most complete prelude formed solely from the \"base\" packa"
},
{
"path": ".licenses/semantic/cabal/base.txt",
"chars": 3987,
"preview": "---\ntype: cabal\nname: base\nversion: 4.12.0.0\nsummary: Basic libraries\nhomepage: \nlicense: bsd-3-clause\n---\nThis library "
},
{
"path": ".licenses/semantic/cabal/base64-bytestring.txt",
"chars": 1682,
"preview": "---\ntype: cabal\nname: base64-bytestring\nversion: 1.0.0.2\nsummary: Fast base64 encoding and decoding for ByteStrings\nhome"
},
{
"path": ".licenses/semantic/cabal/basement.txt",
"chars": 1722,
"preview": "---\ntype: cabal\nname: basement\nversion: 0.0.10\nsummary: Foundation scrap box of array & string\nhomepage: https://github."
},
{
"path": ".licenses/semantic/cabal/bifunctors.txt",
"chars": 1410,
"preview": "---\ntype: cabal\nname: bifunctors\nversion: 5.5.3\nsummary: Bifunctors\nhomepage: https://github.com/ekmett/bifunctors/\nlice"
},
{
"path": ".licenses/semantic/cabal/binary.txt",
"chars": 1647,
"preview": "---\ntype: cabal\nname: binary\nversion: 0.8.6.0\nsummary: Binary serialisation for Haskell values using lazy ByteStrings\nho"
},
{
"path": ".licenses/semantic/cabal/blaze-builder.txt",
"chars": 1724,
"preview": "---\ntype: cabal\nname: blaze-builder\nversion: 0.4.1.0\nsummary: Efficient buffered output.\nhomepage: https://github.com/lp"
},
{
"path": ".licenses/semantic/cabal/byteable.txt",
"chars": 1655,
"preview": "---\ntype: cabal\nname: byteable\nversion: 0.1.1\nsummary: Type class for sequence of bytes\nhomepage: https://github.com/vin"
},
{
"path": ".licenses/semantic/cabal/bytestring.txt",
"chars": 1784,
"preview": "---\ntype: cabal\nname: bytestring\nversion: 0.10.8.2\nsummary: Fast, compact, strict and lazy byte strings with a list inte"
},
{
"path": ".licenses/semantic/cabal/call-stack.txt",
"chars": 1240,
"preview": "---\ntype: cabal\nname: call-stack\nversion: 0.1.0\nsummary: Use GHC call-stacks in a backward compatible way\nhomepage: http"
},
{
"path": ".licenses/semantic/cabal/case-insensitive.txt",
"chars": 1700,
"preview": "---\ntype: cabal\nname: case-insensitive\nversion: 1.2.0.11\nsummary: Case insensitive string comparison\nhomepage: https://g"
},
{
"path": ".licenses/semantic/cabal/cereal.txt",
"chars": 1631,
"preview": "---\ntype: cabal\nname: cereal\nversion: 0.5.8.0\nsummary: A binary serialization library\nhomepage: https://github.com/Galoi"
},
{
"path": ".licenses/semantic/cabal/charset.txt",
"chars": 1713,
"preview": "---\ntype: cabal\nname: charset\nversion: 0.3.7.1\nsummary: Fast unicode character sets based on complemented PATRICIA tries"
},
{
"path": ".licenses/semantic/cabal/clock.txt",
"chars": 1709,
"preview": "---\ntype: cabal\nname: clock\nversion: 0.7.2\nsummary: 'High-resolution clock functions: monotonic, realtime, cputime.'\nhom"
},
{
"path": ".licenses/semantic/cabal/cmark-gfm.txt",
"chars": 6584,
"preview": "---\ntype: cabal\nname: cmark-gfm\nversion: 0.1.8\nsummary: Fast, accurate GitHub Flavored Markdown parser and renderer\nhome"
},
{
"path": ".licenses/semantic/cabal/colour.txt",
"chars": 1230,
"preview": "---\ntype: cabal\nname: colour\nversion: 2.3.4\nsummary: A model for human colour/color perception\nhomepage: https://www.has"
},
{
"path": ".licenses/semantic/cabal/comonad.txt",
"chars": 1436,
"preview": "---\ntype: cabal\nname: comonad\nversion: 5.0.4\nsummary: Comonads\nhomepage: https://github.com/ekmett/comonad/\nlicense: bsd"
},
{
"path": ".licenses/semantic/cabal/connection.txt",
"chars": 1668,
"preview": "---\ntype: cabal\nname: connection\nversion: 0.2.8\nsummary: Simple and easy network connections API\nhomepage: https://githu"
},
{
"path": ".licenses/semantic/cabal/constraints.txt",
"chars": 1414,
"preview": "---\nhomepage: http://github.com/ekmett/constraints/\nsummary: Constraint manipulation\nname: constraints\nversion: 0.10.1\nl"
},
{
"path": ".licenses/semantic/cabal/containers.txt",
"chars": 1736,
"preview": "---\ntype: cabal\nname: containers\nversion: 0.6.0.1\nsummary: Assorted concrete container types\nhomepage: \nlicense: bsd-3-c"
},
{
"path": ".licenses/semantic/cabal/contravariant.txt",
"chars": 1616,
"preview": "---\ntype: cabal\nname: contravariant\nversion: '1.5'\nsummary: Contravariant functors\nhomepage: https://github.com/ekmett/c"
},
{
"path": ".licenses/semantic/cabal/cookie.txt",
"chars": 1233,
"preview": "---\ntype: cabal\nname: cookie\nversion: 0.4.4\nsummary: HTTP cookie parsing and rendering\nhomepage: https://github.com/snoy"
},
{
"path": ".licenses/semantic/cabal/cryptonite.txt",
"chars": 1664,
"preview": "---\ntype: cabal\nname: cryptonite\nversion: '0.25'\nsummary: Cryptography Primitives sink\nhomepage: https://github.com/hask"
},
{
"path": ".licenses/semantic/cabal/data-default-class.txt",
"chars": 1656,
"preview": "---\ntype: cabal\nname: data-default-class\nversion: 0.1.2.0\nsummary: A class for types with a default value\nhomepage: http"
},
{
"path": ".licenses/semantic/cabal/deepseq-generics.txt",
"chars": 1737,
"preview": "---\ntype: cabal\nname: deepseq-generics\nversion: 0.2.0.0\nsummary: GHC.Generics-based Control.DeepSeq.rnf implementation\nh"
},
{
"path": ".licenses/semantic/cabal/deepseq.txt",
"chars": 2107,
"preview": "---\ntype: cabal\nname: deepseq\nversion: 1.4.4.0\nsummary: Deep evaluation of data structures\nhomepage: https://github.com/"
},
{
"path": ".licenses/semantic/cabal/directory-tree.txt",
"chars": 1488,
"preview": "---\ntype: cabal\nname: directory-tree\nversion: 0.12.1\nsummary: A simple directory-like tree datatype, with useful IO func"
},
{
"path": ".licenses/semantic/cabal/directory.txt",
"chars": 3080,
"preview": "---\ntype: cabal\nname: directory\nversion: 1.3.3.0\nsummary: Platform-agnostic library for filesystem operations\nhomepage: "
},
{
"path": ".licenses/semantic/cabal/distributive.txt",
"chars": 1448,
"preview": "---\ntype: cabal\nname: distributive\nversion: '0.6'\nsummary: Distributive functors -- Dual to Traversable\nhomepage: https:"
},
{
"path": ".licenses/semantic/cabal/dlist.txt",
"chars": 1684,
"preview": "---\ntype: cabal\nname: dlist\nversion: 0.8.0.5\nsummary: Difference lists\nhomepage: https://github.com/spl/dlist\nlicense: b"
},
{
"path": ".licenses/semantic/cabal/enclosed-exceptions.txt",
"chars": 1277,
"preview": "---\nhomepage: https://github.com/jcristovao/enclosed-exceptions\nsummary: Catching all exceptions from within an enclosed"
},
{
"path": ".licenses/semantic/cabal/erf.txt",
"chars": 1598,
"preview": "---\ntype: cabal\nname: erf\nversion: 2.0.0.0\nsummary: The error function, erf, and related functions.\nhomepage: \nlicense: "
},
{
"path": ".licenses/semantic/cabal/exceptions.txt",
"chars": 1653,
"preview": "---\ntype: cabal\nname: exceptions\nversion: 0.10.0\nsummary: Extensible optionally-pure exceptions\nhomepage: https://github"
},
{
"path": ".licenses/semantic/cabal/fastsum.txt",
"chars": 1788,
"preview": "---\ntype: cabal\nname: fastsum\nversion: 0.1.1.0\nsummary: A fast open-union type suitable for 100+ contained alternatives\n"
},
{
"path": ".licenses/semantic/cabal/filepath.txt",
"chars": 1712,
"preview": "---\ntype: cabal\nname: filepath\nversion: 1.4.2.1\nsummary: Library for manipulating FilePaths in a cross platform way.\nhom"
},
{
"path": ".licenses/semantic/cabal/fingertree.txt",
"chars": 1760,
"preview": "---\ntype: cabal\nname: fingertree\nversion: 0.1.4.2\nsummary: Generic finger-tree structure, with example instances\nhomepag"
},
{
"path": ".licenses/semantic/cabal/foldl.txt",
"chars": 1656,
"preview": "---\ntype: cabal\nname: foldl\nversion: 1.4.5\nsummary: Composable, streaming, and efficient left folds\nhomepage: \nlicense: "
},
{
"path": ".licenses/semantic/cabal/freer-cofreer.txt",
"chars": 1684,
"preview": "---\ntype: cabal\nname: freer-cofreer\nversion: 0.0.0.1\nsummary: Freer monads and Cofreer comonads.\nhomepage: https://githu"
},
{
"path": ".licenses/semantic/cabal/fused-effects.txt",
"chars": 1733,
"preview": "---\ntype: cabal\nname: fused-effects\nversion: 0.4.0.0\nsummary: A fast, flexible, fused effect system.\nhomepage: https://g"
},
{
"path": ".licenses/semantic/cabal/generic-monoid.txt",
"chars": 1713,
"preview": "---\ntype: cabal\nname: generic-monoid\nversion: '0.1.0.0'\nsummary: Derive monoid instances for product types.\nhomepage: ht"
},
{
"path": ".licenses/semantic/cabal/generics-sop.txt",
"chars": 1678,
"preview": "---\ntype: cabal\nname: generics-sop\nversion: 0.4.0.1\nsummary: Generic Programming using True Sums of Products\nhomepage: \n"
},
{
"path": ".licenses/semantic/cabal/ghc-boot-th.txt",
"chars": 1755,
"preview": "---\ntype: cabal\nname: ghc-boot-th\nversion: 8.6.4\nsummary: Shared functionality between GHC and the @template-haskell@\n\nl"
},
{
"path": ".licenses/semantic/cabal/ghc-boot.txt",
"chars": 1749,
"preview": "---\ntype: cabal\nname: ghc-boot\nversion: 8.6.4\nsummary: Shared functionality between GHC and its boot libraries\n\nlicense:"
},
{
"path": ".licenses/semantic/cabal/ghc-heap.txt",
"chars": 1650,
"preview": "---\ntype: cabal\nname: ghc-heap\nversion: 8.6.4\nsummary: Functions for walking GHC's heap\n\nlicense: bsd-3-clause\n---\nCopyr"
},
{
"path": ".licenses/semantic/cabal/ghc-prim.txt",
"chars": 2968,
"preview": "---\ntype: cabal\nname: ghc-prim\nversion: 0.5.3\nsummary: GHC primitives\nhomepage: \nlicense: bsd-3-clause\n---\nThis library "
},
{
"path": ".licenses/semantic/cabal/ghc-tcplugins-extra.txt",
"chars": 1550,
"preview": "---\ntype: cabal\nname: ghc-tcplugins-extra\nversion: '0.3'\nsummary: Utilities for writing GHC type-checker plugins\nhomepag"
},
{
"path": ".licenses/semantic/cabal/ghc-typelits-extra.txt",
"chars": 1538,
"preview": "---\ntype: cabal\nname: ghc-typelits-extra\nversion: '0.3'\nsummary: Additional type-level operations on GHC.TypeLits.Nat\nho"
},
{
"path": ".licenses/semantic/cabal/ghc-typelits-knownnat.txt",
"chars": 1582,
"preview": "---\ntype: cabal\nname: ghc-typelits-knownnat\nversion: '0.6'\nsummary: Derive KnownNat constraints from other KnownNat cons"
},
{
"path": ".licenses/semantic/cabal/ghc-typelits-natnormalise.txt",
"chars": 1550,
"preview": "---\ntype: cabal\nname: ghc-typelits-natnormalise\nversion: 0.6.2\nsummary: GHC typechecker plugin for types of kind GHC.Typ"
},
{
"path": ".licenses/semantic/cabal/ghc.txt",
"chars": 1738,
"preview": "---\ntype: cabal\nname: ghc\nversion: 8.6.4\nsummary: The GHC API\nhomepage: https://www.haskell.org/ghc/\nlicense: bsd-3-clau"
},
{
"path": ".licenses/semantic/cabal/ghci.txt",
"chars": 1738,
"preview": "---\ntype: cabal\nname: ghci\nversion: 8.6.4\nsummary: The library supporting GHC's interactive interpreter\n\nlicense: bsd-3-"
},
{
"path": ".licenses/semantic/cabal/gitrev.txt",
"chars": 1651,
"preview": "---\ntype: cabal\nname: gitrev\nversion: 1.3.1\nsummary: Compile git revision info into Haskell projects\nhomepage: https://g"
},
{
"path": ".licenses/semantic/cabal/hashable.txt",
"chars": 1700,
"preview": "---\ntype: cabal\nname: hashable\nversion: 1.2.7.0\nsummary: A class for types that can be converted to a hash value\nhomepag"
},
{
"path": ".licenses/semantic/cabal/haskeline.txt",
"chars": 1463,
"preview": "---\ntype: cabal\nname: haskeline\nversion: 0.7.5.0\nsummary: A command-line interface for user input, written in Haskell.\nh"
},
{
"path": ".licenses/semantic/cabal/haskell-lexer.txt",
"chars": 1255,
"preview": "---\ntype: cabal\nname: haskell-lexer\nversion: 1.0.2\nsummary: A fully compliant Haskell 98 lexer.\nhomepage: https://github"
},
{
"path": ".licenses/semantic/cabal/haskell-src.txt",
"chars": 1753,
"preview": "---\ntype: cabal\nname: haskell-src\nversion: 1.0.3.0\nsummary: Support for manipulating Haskell source code\nhomepage: \nlice"
},
{
"path": ".licenses/semantic/cabal/haskell-tree-sitter.txt",
"chars": 1701,
"preview": "---\ntype: cabal\nname: haskell-tree-sitter\nversion: 0.1.0\nsummary: haskell tree-sitter bindings\nhomepage: https://github."
},
{
"path": ".licenses/semantic/cabal/heap.txt",
"chars": 1427,
"preview": "---\ntype: cabal\nname: heap\nversion: 1.0.4\nsummary: Heaps in Haskell\nhomepage: \nlicense: bsd-2-clause\n---\nCopyright (c) 2"
},
{
"path": ".licenses/semantic/cabal/hostname.txt",
"chars": 1704,
"preview": "---\ntype: cabal\nname: hostname\nversion: '1.0'\nsummary: A very simple package providing a cross-platform means of determi"
},
{
"path": ".licenses/semantic/cabal/hourglass.txt",
"chars": 1664,
"preview": "---\ntype: cabal\nname: hourglass\nversion: 0.2.12\nsummary: simple performant time related library\nhomepage: https://github"
},
{
"path": ".licenses/semantic/cabal/hpc.txt",
"chars": 1560,
"preview": "---\ntype: cabal\nname: hpc\nversion: 0.6.0.3\nsummary: Code Coverage Library for Haskell\nhomepage: \nlicense: bsd-3-clause\n-"
},
{
"path": ".licenses/semantic/cabal/http-api-data.txt",
"chars": 1585,
"preview": "---\ntype: cabal\nname: http-api-data\nversion: '0.4'\nsummary: Converting to/from HTTP API data like URL pieces, headers an"
},
{
"path": ".licenses/semantic/cabal/insert-ordered-containers.txt",
"chars": 1749,
"preview": "---\ntype: cabal\nname: insert-ordered-containers\nversion: 0.2.1.0\nsummary: Associative containers retaining insertion ord"
},
{
"path": ".licenses/semantic/cabal/integer-gmp.txt",
"chars": 1667,
"preview": "---\ntype: cabal\nname: integer-gmp\nversion: 1.0.2.0\nsummary: Integer library based on GMP\nhomepage: \nlicense: bsd-3-claus"
},
{
"path": ".licenses/semantic/cabal/integer-logarithms.txt",
"chars": 1244,
"preview": "---\ntype: cabal\nname: integer-logarithms\nversion: 1.0.2.2\nsummary: Integer logarithms.\nhomepage: https://github.com/Bodi"
},
{
"path": ".licenses/semantic/cabal/invariant.txt",
"chars": 1484,
"preview": "---\ntype: cabal\nname: invariant\nversion: 0.5.1\nsummary: Haskell98 invariant functors\nhomepage: https://github.com/nfrisb"
},
{
"path": ".licenses/semantic/cabal/kan-extensions.txt",
"chars": 1667,
"preview": "---\ntype: cabal\nname: kan-extensions\nversion: '5.2'\nsummary: Kan extensions, Kan lifts, the Yoneda lemma, and (co)densit"
},
{
"path": ".licenses/semantic/cabal/kdt.txt",
"chars": 1229,
"preview": "---\ntype: cabal\nname: kdt\nversion: 0.2.4\nsummary: Fast and flexible k-d trees for various types of point queries.\nhomepa"
},
{
"path": ".licenses/semantic/cabal/keys.txt",
"chars": 1606,
"preview": "---\ntype: cabal\nname: keys\nversion: 3.12.1\nsummary: Keyed functors and containers\nhomepage: https://github.com/ekmett/ke"
},
{
"path": ".licenses/semantic/cabal/lens.txt",
"chars": 1417,
"preview": "---\ntype: cabal\nname: lens\nversion: '4.17'\nsummary: Lenses, Folds and Traversals\nhomepage: https://github.com/ekmett/len"
},
{
"path": ".licenses/semantic/cabal/lifted-async.txt",
"chars": 1722,
"preview": "---\nhomepage: https://github.com/maoe/lifted-async\nsummary: Run lifted IO operations asynchronously and wait for their r"
},
{
"path": ".licenses/semantic/cabal/lifted-base.txt",
"chars": 1673,
"preview": "---\nhomepage: https://github.com/basvandijk/lifted-base\nsummary: lifted IO operations from the base library\nname: lifted"
},
{
"path": ".licenses/semantic/cabal/machines.txt",
"chars": 1644,
"preview": "---\ntype: cabal\nname: machines\nversion: 0.6.4\nsummary: Networked stream transducers\nhomepage: https://github.com/ekmett/"
},
{
"path": ".licenses/semantic/cabal/managed.txt",
"chars": 1637,
"preview": "---\ntype: cabal\nname: managed\nversion: 1.0.6\nsummary: A monad for managed values\nhomepage: \nlicense: bsd-3-clause\n---\nCo"
},
{
"path": ".licenses/semantic/cabal/math-functions.txt",
"chars": 1514,
"preview": "---\ntype: cabal\nname: math-functions\nversion: '0.3.1.0'\nsummary: Collection of tools for numeric computations\nhomepage: "
},
{
"path": ".licenses/semantic/cabal/megaparsec.txt",
"chars": 1507,
"preview": "---\ntype: cabal\nname: megaparsec\nversion: 7.0.4\nsummary: Monadic parser combinators\nhomepage: https://github.com/mrkkrp/"
},
{
"path": ".licenses/semantic/cabal/memory.txt",
"chars": 1730,
"preview": "---\ntype: cabal\nname: memory\nversion: 0.14.18\nsummary: memory and related abstraction stuff\nhomepage: https://github.com"
},
{
"path": ".licenses/semantic/cabal/mersenne-random-pure64.txt",
"chars": 1714,
"preview": "---\ntype: cabal\nname: mersenne-random-pure64\nversion: 0.2.2.0\nsummary: Generate high quality pseudorandom numbers purely"
},
{
"path": ".licenses/semantic/cabal/mime-types.txt",
"chars": 1248,
"preview": "---\ntype: cabal\nname: mime-types\nversion: 0.1.0.9\nsummary: Basic mime-type handling types and functions\nhomepage: https:"
},
{
"path": ".licenses/semantic/cabal/mmorph.txt",
"chars": 1595,
"preview": "---\ntype: cabal\nname: mmorph\nversion: 1.1.2\nsummary: Monad morphisms\nhomepage: \nlicense: bsd-3-clause\n---\nCopyright (c) "
},
{
"path": ".licenses/semantic/cabal/monad-control.txt",
"chars": 1705,
"preview": "---\nhomepage: https://github.com/basvandijk/monad-control\nsummary: Lift control operations, like exception catching, thr"
},
{
"path": ".licenses/semantic/cabal/mtl.txt",
"chars": 1769,
"preview": "---\ntype: cabal\nname: mtl\nversion: 2.2.2\nsummary: Monad classes, using functional dependencies\nhomepage: https://github."
},
{
"path": ".licenses/semantic/cabal/mwc-random.txt",
"chars": 1505,
"preview": "---\ntype: cabal\nname: mwc-random\nversion: 0.14.0.0\nsummary: Fast, high quality pseudo random number generation\nhomepage:"
},
{
"path": ".licenses/semantic/cabal/neat-interpolation.txt",
"chars": 1266,
"preview": "---\ntype: cabal\nname: neat-interpolation\nversion: 0.3.2.4\nsummary: A quasiquoter for neat and simple multiline text inte"
},
{
"path": ".licenses/semantic/cabal/network-uri.txt",
"chars": 1747,
"preview": "---\ntype: cabal\nname: network-uri\nversion: 2.6.1.0\nsummary: URI manipulation\nhomepage: https://github.com/haskell/networ"
},
{
"path": ".licenses/semantic/cabal/network.txt",
"chars": 1753,
"preview": "---\ntype: cabal\nname: network\nversion: 2.8.0.0\nsummary: Low-level networking interface\nhomepage: https://github.com/hask"
},
{
"path": ".licenses/semantic/cabal/old-locale.txt",
"chars": 3045,
"preview": "---\ntype: cabal\nname: old-locale\nversion: 1.0.0.7\nsummary: locale library\nhomepage: \nlicense: bsd-3-clause\n---\nThis libr"
},
{
"path": ".licenses/semantic/cabal/old-time.txt",
"chars": 3041,
"preview": "---\ntype: cabal\nname: old-time\nversion: 1.1.0.3\nsummary: Time library\nhomepage: \nlicense: bsd-3-clause\n---\nThis library "
},
{
"path": ".licenses/semantic/cabal/optional-args.txt",
"chars": 1644,
"preview": "---\ntype: cabal\nname: optional-args\nversion: 1.0.2\nsummary: Optional function arguments\nhomepage: \nlicense: bsd-3-clause"
},
{
"path": ".licenses/semantic/cabal/optparse-applicative.txt",
"chars": 1744,
"preview": "---\ntype: cabal\nname: optparse-applicative\nversion: 0.14.3.0\nsummary: Utilities and combinators for parsing command line"
},
{
"path": ".licenses/semantic/cabal/parallel.txt",
"chars": 2074,
"preview": "---\ntype: cabal\nname: parallel\nversion: 3.2.2.0\nsummary: Parallel programming library\nhomepage: \nlicense: bsd-3-clause\n-"
},
{
"path": ".licenses/semantic/cabal/parsec.txt",
"chars": 1437,
"preview": "---\ntype: cabal\nname: parsec\nversion: 3.1.13.0\nsummary: Monadic parser combinators\nhomepage: https://github.com/haskell/"
},
{
"path": ".licenses/semantic/cabal/parser-combinators.txt",
"chars": 1655,
"preview": "---\ntype: cabal\nname: parser-combinators\nversion: 1.0.1\nsummary: Lightweight package providing commonly useful parser co"
},
{
"path": ".licenses/semantic/cabal/parsers.txt",
"chars": 1602,
"preview": "---\ntype: cabal\nname: parsers\nversion: 0.12.9\nsummary: Parsing combinators\nhomepage: https://github.com/ekmett/parsers/\n"
},
{
"path": ".licenses/semantic/cabal/pem.txt",
"chars": 1673,
"preview": "---\ntype: cabal\nname: pem\nversion: 0.2.4\nsummary: Privacy Enhanced Mail (PEM) format reader and writer.\nhomepage: https:"
},
{
"path": ".licenses/semantic/cabal/pointed.txt",
"chars": 1420,
"preview": "---\ntype: cabal\nname: pointed\nversion: 5.0.1\nsummary: Pointed and copointed data\nhomepage: https://github.com/ekmett/poi"
},
{
"path": ".licenses/semantic/cabal/pretty.txt",
"chars": 2097,
"preview": "---\ntype: cabal\nname: pretty\nversion: 1.1.3.6\nsummary: Pretty-printing library\nhomepage: https://github.com/haskell/pret"
},
{
"path": ".licenses/semantic/cabal/prettyprinter.txt",
"chars": 1517,
"preview": "---\ntype: cabal\nname: prettyprinter\nversion: 1.2.1\nsummary: A modern, easy to use, well-documented, extensible pretty-pr"
},
{
"path": ".licenses/semantic/cabal/primitive.txt",
"chars": 1716,
"preview": "---\ntype: cabal\nname: primitive\nversion: 0.6.4.0\nsummary: Primitive memory-related operations\nhomepage: https://github.c"
},
{
"path": ".licenses/semantic/cabal/process.txt",
"chars": 3037,
"preview": "---\ntype: cabal\nname: process\nversion: 1.6.5.0\nsummary: Process libraries\n\nlicense: bsd-3-clause\n---\nThis library (libra"
},
{
"path": ".licenses/semantic/cabal/profunctors.txt",
"chars": 1601,
"preview": "---\ntype: cabal\nname: profunctors\nversion: '5.3'\nsummary: Profunctors\nhomepage: https://github.com/ekmett/profunctors/\nl"
},
{
"path": ".licenses/semantic/cabal/proto3-suite.txt",
"chars": 726,
"preview": "---\ntype: cabal\nname: proto3-suite\nversion: 0.2.0\nsummary: A low level library for writing out data in the Protocol Buff"
},
{
"path": ".licenses/semantic/cabal/proto3-wire.txt",
"chars": 725,
"preview": "---\ntype: cabal\nname: proto3-wire\nversion: 1.0.0\nsummary: A low-level implementation of the Protocol Buffers (version 3)"
},
{
"path": ".licenses/semantic/cabal/quickcheck-instances.txt",
"chars": 1696,
"preview": "---\ntype: cabal\nname: quickcheck-instances\nversion: 0.3.19\nsummary: Common quickcheck instances\nhomepage: https://github"
},
{
"path": ".licenses/semantic/cabal/random.txt",
"chars": 3079,
"preview": "---\ntype: cabal\nname: random\nversion: '1.1'\nsummary: random number library\nhomepage: https://github.com/haskell/random\nl"
},
{
"path": ".licenses/semantic/cabal/recursion-schemes.txt",
"chars": 1457,
"preview": "---\ntype: cabal\nname: recursion-schemes\nversion: 5.1.2\nsummary: Generalized bananas, lenses and barbed wire\nhomepage: ht"
},
{
"path": ".licenses/semantic/cabal/reducers.txt",
"chars": 1654,
"preview": "---\ntype: cabal\nname: reducers\nversion: 3.12.3\nsummary: Semigroups, specialized containers and a general map/reduce fram"
},
{
"path": ".licenses/semantic/cabal/reflection.txt",
"chars": 1782,
"preview": "---\ntype: cabal\nname: reflection\nversion: 2.1.4\nsummary: Reifies arbitrary terms into types that can be reflected back i"
},
{
"path": ".licenses/semantic/cabal/rts.txt",
"chars": 1693,
"preview": "---\ntype: cabal\nname: rts\nversion: '1.0'\nsummary:\nhomepage:\nlicense: bsd-3-clause\n---\nThe Glasgow Haskell Compiler Licen"
},
{
"path": ".licenses/semantic/cabal/safe.txt",
"chars": 1690,
"preview": "---\ntype: cabal\nname: safe\nversion: 0.3.17\nsummary: Library of safe (exception free) functions\nhomepage: https://github."
},
{
"path": ".licenses/semantic/cabal/scientific.txt",
"chars": 1704,
"preview": "---\ntype: cabal\nname: scientific\nversion: 0.3.6.2\nsummary: Numbers represented using scientific notation\nhomepage: https"
},
{
"path": ".licenses/semantic/cabal/semigroupoids.txt",
"chars": 1438,
"preview": "---\ntype: cabal\nname: semigroupoids\nversion: 5.3.2\nsummary: 'Semigroupoids: Category sans id'\nhomepage: https://github.c"
},
{
"path": ".licenses/semantic/cabal/semigroups.txt",
"chars": 1425,
"preview": "---\ntype: cabal\nname: semigroups\nversion: 0.18.5\nsummary: Anything that associates\nhomepage: https://github.com/ekmett/s"
},
{
"path": ".licenses/semantic/cabal/semilattices.txt",
"chars": 1661,
"preview": "---\ntype: cabal\nname: semilattices\nversion: 0.0.0.3\nsummary: Semilattices\nhomepage: https://github.com/robrix/semilattic"
},
{
"path": ".licenses/semantic/cabal/servant.txt",
"chars": 1781,
"preview": "---\ntype: cabal\nname: servant\nversion: '0.15'\nsummary: A family of combinators for defining webservices APIs\nhomepage: h"
},
{
"path": ".licenses/semantic/cabal/shelly.txt",
"chars": 1698,
"preview": "---\nhomepage: https://github.com/yesodweb/Shelly.hs\nsummary: shell-like (systems) programming in Haskell\nname: shelly\nve"
},
{
"path": ".licenses/semantic/cabal/singleton-bool.txt",
"chars": 1680,
"preview": "---\ntype: cabal\nname: singleton-bool\nversion: 0.1.4\nsummary: Type level booleans\nhomepage: https://github.com/phadej/sin"
},
{
"path": ".licenses/semantic/cabal/socks.txt",
"chars": 1643,
"preview": "---\ntype: cabal\nname: socks\nversion: 0.5.6\nsummary: Socks proxy (ver 5)\nhomepage: https://github.com/vincenthz/hs-socks\n"
},
{
"path": ".licenses/semantic/cabal/sop-core.txt",
"chars": 1648,
"preview": "---\ntype: cabal\nname: sop-core\nversion: 0.4.0.0\nsummary: True Sums of Products\nhomepage: \nlicense: bsd-3-clause\n---\nCopy"
},
{
"path": ".licenses/semantic/cabal/split.txt",
"chars": 1634,
"preview": "---\ntype: cabal\nname: split\nversion: 0.2.3.3\nsummary: Combinator library for splitting lists.\nhomepage: https://github.c"
},
{
"path": ".licenses/semantic/cabal/stm-chans.txt",
"chars": 1739,
"preview": "---\ntype: cabal\nname: stm-chans\nversion: 3.0.0.4\nsummary: Additional types of channels for STM.\nhomepage: https://code.h"
},
{
"path": ".licenses/semantic/cabal/stm.txt",
"chars": 1783,
"preview": "---\ntype: cabal\nname: stm\nversion: 2.5.0.0\nsummary: Software Transactional Memory\nhomepage: https://wiki.haskell.org/Sof"
},
{
"path": ".licenses/semantic/cabal/streaming-commons.txt",
"chars": 1284,
"preview": "---\ntype: cabal\nname: streaming-commons\nversion: 0.2.1.0\nsummary: Common lower-level functions needed by various streami"
},
{
"path": ".licenses/semantic/cabal/string-conversions.txt",
"chars": 1722,
"preview": "---\ntype: cabal\nname: string-conversions\nversion: 0.4.0.1\nsummary: Simplifies dealing with different types for strings\nh"
},
{
"path": ".licenses/semantic/cabal/swagger2.txt",
"chars": 1633,
"preview": "---\ntype: cabal\nname: swagger2\nversion: 2.3.1.1\nsummary: Swagger 2.0 data model\nhomepage: https://github.com/GetShopTV/s"
},
{
"path": ".licenses/semantic/cabal/syb.txt",
"chars": 4038,
"preview": "---\ntype: cabal\nname: syb\nversion: '0.7'\nsummary: Scrap Your Boilerplate\nhomepage: https://www.cs.uu.nl/wiki/GenericProg"
},
{
"path": ".licenses/semantic/cabal/system-fileio.txt",
"chars": 1256,
"preview": "---\ntype: cabal\nname: system-fileio\nversion: 0.3.16.4\nsummary: Consistent filesystem interaction across GHC versions (de"
},
{
"path": ".licenses/semantic/cabal/system-filepath.txt",
"chars": 1263,
"preview": "---\ntype: cabal\nname: system-filepath\nversion: 0.4.14\nsummary: High-level, byte-based file and directory path manipulati"
},
{
"path": ".licenses/semantic/cabal/tagged.txt",
"chars": 1714,
"preview": "---\ntype: cabal\nname: tagged\nversion: 0.8.6\nsummary: Haskell 98 phantom types to avoid unsafely passing dummy arguments\n"
},
{
"path": ".licenses/semantic/cabal/template-haskell.txt",
"chars": 1752,
"preview": "---\ntype: cabal\nname: template-haskell\nversion: 2.14.0.0\nsummary: Support library for Template Haskell\nhomepage: \nlicens"
},
{
"path": ".licenses/semantic/cabal/temporary.txt",
"chars": 1796,
"preview": "---\ntype: cabal\nname: temporary\nversion: '1.3'\nsummary: Portable temporary file and directory support\nhomepage: https://"
},
{
"path": ".licenses/semantic/cabal/terminfo.txt",
"chars": 1435,
"preview": "---\ntype: cabal\nname: terminfo\nversion: 0.4.1.2\nsummary: Haskell bindings to the terminfo library.\nhomepage: https://git"
},
{
"path": ".licenses/semantic/cabal/text.txt",
"chars": 1482,
"preview": "---\ntype: cabal\nname: text\nversion: 1.2.3.1\nsummary: An efficient packed Unicode text type.\nhomepage: https://github.com"
},
{
"path": ".licenses/semantic/cabal/tf-random.txt",
"chars": 1678,
"preview": "---\ntype: cabal\nname: tf-random\nversion: '0.5'\nsummary: High-quality splittable pseudorandom number generator\nhomepage: "
},
{
"path": ".licenses/semantic/cabal/th-abstraction.txt",
"chars": 917,
"preview": "---\ntype: cabal\nname: th-abstraction\nversion: 0.2.11.0\nsummary: Nicer interface for reified information about data types"
},
{
"path": ".licenses/semantic/cabal/these.txt",
"chars": 1713,
"preview": "---\ntype: cabal\nname: these\nversion: 0.7.6\nsummary: An either-or-both data type & a generalized 'zip with padding' typec"
},
{
"path": ".licenses/semantic/cabal/time-locale-compat.txt",
"chars": 1717,
"preview": "---\ntype: cabal\nname: time-locale-compat\nversion: 0.1.1.5\nsummary: Compatibile module for time-format locale\nhomepage: h"
},
{
"path": ".licenses/semantic/cabal/time.txt",
"chars": 1534,
"preview": "---\ntype: cabal\nname: time\nversion: 1.8.0.2\nsummary: A time library\nhomepage: https://github.com/haskell/time\nlicense: b"
},
{
"path": ".licenses/semantic/cabal/tls.txt",
"chars": 1678,
"preview": "---\ntype: cabal\nname: tls\nversion: 1.4.1\nsummary: TLS/SSL protocol native implementation (Server and Client)\nhomepage: h"
},
{
"path": ".licenses/semantic/cabal/transformers-base.txt",
"chars": 1714,
"preview": "---\ntype: cabal\nname: transformers-base\nversion: 0.4.5.2\nsummary: Lift computations from the bottom of a transformer sta"
},
{
"path": ".licenses/semantic/cabal/transformers-compat.txt",
"chars": 1661,
"preview": "---\ntype: cabal\nname: transformers-compat\nversion: 0.6.2\nsummary: A small compatibility shim for the transformers librar"
},
{
"path": ".licenses/semantic/cabal/transformers.txt",
"chars": 1734,
"preview": "---\ntype: cabal\nname: transformers\nversion: 0.5.6.2\nsummary: Concrete functor and monad transformers\n\nlicense: bsd-3-cla"
},
{
"path": ".licenses/semantic/cabal/turtle.txt",
"chars": 1643,
"preview": "---\ntype: cabal\nname: turtle\nversion: 1.5.13\nsummary: Shell programming, Haskell-style\nhomepage: \nlicense: bsd-3-clause\n"
},
{
"path": ".licenses/semantic/cabal/unix-compat.txt",
"chars": 1789,
"preview": "---\ntype: cabal\nname: unix-compat\nversion: 0.5.1\nsummary: Portable POSIX-compatibility layer.\nhomepage: https://github.c"
},
{
"path": ".licenses/semantic/cabal/unix.txt",
"chars": 1748,
"preview": "---\ntype: cabal\nname: unix\nversion: 2.7.2.2\nsummary: POSIX functionality\nhomepage: https://github.com/haskell/unix\nlicen"
},
{
"path": ".licenses/semantic/cabal/unliftio-core.txt",
"chars": 1257,
"preview": "---\ntype: cabal\nname: unliftio-core\nversion: 0.1.2.0\nsummary: The MonadUnliftIO typeclass for unlifting monads to IO\nhom"
},
{
"path": ".licenses/semantic/cabal/unordered-containers.txt",
"chars": 1713,
"preview": "---\ntype: cabal\nname: unordered-containers\nversion: 0.2.9.0\nsummary: Efficient hashing-based container types\nhomepage: h"
},
{
"path": ".licenses/semantic/cabal/utf8-string.txt",
"chars": 1684,
"preview": "---\ntype: cabal\nname: utf8-string\nversion: 1.0.1.1\nsummary: Support for reading and writing UTF8 Strings\nhomepage: https"
},
{
"path": ".licenses/semantic/cabal/uuid-types.txt",
"chars": 1634,
"preview": "---\ntype: cabal\nname: uuid-types\nversion: 1.0.3\nsummary: Type definitions for Universally Unique Identifiers\nhomepage: h"
},
{
"path": ".licenses/semantic/cabal/vault.txt",
"chars": 1712,
"preview": "---\ntype: cabal\nname: vault\nversion: 0.3.1.2\nsummary: a persistent store for values of arbitrary types\nhomepage: https:/"
},
{
"path": ".licenses/semantic/cabal/vector-builder.txt",
"chars": 1210,
"preview": "---\ntype: cabal\nname: vector-builder\nversion: 0.3.7.2\nsummary: Vector builder\nhomepage: https://github.com/nikita-volkov"
},
{
"path": ".licenses/semantic/cabal/vector-instances.txt",
"chars": 1698,
"preview": "---\ntype: cabal\nname: vector-instances\nversion: '3.4'\nsummary: Orphan Instances for 'Data.Vector'\nhomepage: https://gith"
},
{
"path": ".licenses/semantic/cabal/vector-th-unbox.txt",
"chars": 1721,
"preview": "---\ntype: cabal\nname: vector-th-unbox\nversion: '0.2.1.6'\nsummary: Deriver for Data.Vector.Unboxed using Template Haskell"
},
{
"path": ".licenses/semantic/cabal/vector.txt",
"chars": 1692,
"preview": "---\ntype: cabal\nname: vector\nversion: 0.12.0.2\nsummary: Efficient Arrays\nhomepage: https://github.com/haskell/vector\nlic"
},
{
"path": ".licenses/semantic/cabal/void.txt",
"chars": 1614,
"preview": "---\ntype: cabal\nname: void\nversion: 0.7.2\nsummary: A Haskell 98 logically uninhabited data type\nhomepage: https://github"
},
{
"path": ".licenses/semantic/cabal/x509-store.txt",
"chars": 1681,
"preview": "---\ntype: cabal\nname: x509-store\nversion: 1.6.7\nsummary: X.509 collection accessing and storing methods\nhomepage: https:"
},
{
"path": ".licenses/semantic/cabal/x509-system.txt",
"chars": 1691,
"preview": "---\ntype: cabal\nname: x509-system\nversion: 1.6.6\nsummary: Handle per-operating-system X.509 accessors and storage\nhomepa"
},
{
"path": ".licenses/semantic/cabal/x509-validation.txt",
"chars": 1677,
"preview": "---\ntype: cabal\nname: x509-validation\nversion: 1.6.11\nsummary: X.509 Certificate and CRL validation\nhomepage: https://gi"
},
{
"path": ".licenses/semantic/cabal/x509.txt",
"chars": 1651,
"preview": "---\ntype: cabal\nname: x509\nversion: 1.7.5\nsummary: X509 reader and writer\nhomepage: https://github.com/vincenthz/hs-cert"
},
{
"path": ".licenses/semantic/cabal/zlib.txt",
"chars": 1495,
"preview": "---\ntype: cabal\nname: zlib\nversion: 0.6.2\nsummary: Compression and decompression in the gzip and zlib formats\nhomepage: "
},
{
"path": ".stylish-haskell.yaml",
"chars": 8024,
"preview": "# stylish-haskell configuration file\n# ==================================\n\n# The stylish-haskell tool is mainly configur"
},
{
"path": "BUILD.bazel",
"chars": 1778,
"preview": "# This build file specifies the packages from GHC bindists that\n# we want to use, as well as the top-level hie-bios REPL"
},
{
"path": "CODEOWNERS",
"chars": 24,
"preview": "* @github/semantic-code\n"
},
{
"path": "CODE_OF_CONDUCT.md",
"chars": 3356,
"preview": "# Contributor Covenant Code of Conduct\n\n## Our Pledge\n\nIn the interest of fostering an open and welcoming environment, w"
},
{
"path": "CONTRIBUTING.md",
"chars": 3138,
"preview": "## Contributing\n\n[fork]: https://github.com/github/semantic-open-source/fork\n[pr]: https://github.com/github/semantic-op"
},
{
"path": "Dockerfile",
"chars": 1856,
"preview": "# Put protoc and twirp tooling in its own image\nFROM haskell:8.8.1 as haskell\nRUN cabal v2-update && \\\n cabal v2-inst"
},
{
"path": "HACKING.md",
"chars": 3374,
"preview": "# Effective `semantic` Hacking for Fun and Profit\n\nThe Semantic repository is a large one, containing dozens of subproje"
},
{
"path": "README.md",
"chars": 5089,
"preview": "**NOTE**: _This repository is no longer supported or updated by GitHub. If you wish to continue to develop this code you"
},
{
"path": "WORKSPACE",
"chars": 6937,
"preview": "# This file defines the workspace for the Semantic monorepo.\n# It loads the Haskell compilation rules, describes the pac"
}
]
// ... and 2853 more files (download for full content)
About this extraction
This page contains the full source code of the github/semantic GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 3053 files (5.1 MB), approximately 1.5M tokens, and a symbol index with 790 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.