Carp/CarpHask.cabal

name:                CarpHask
version:             0.4.2.0
-- synopsis:
-- description:
homepage:            https://github.com/eriksvedang/Carp
license:             Apache-2.0
license-file:        LICENSE
author:              Erik Svedäng
maintainer:          erik.svedang@gmail.com
copyright:           Erik Svedäng
category:            General
build-type:          Simple
extra-source-files:  README.md
cabal-version:       >=1.10

library
  ghc-options:         -Wall -Werror
  hs-source-dirs:      src
  exposed-modules:     Info,
                       Obj,
                       Meta,
                       Project,
                       Parsing,
                       Infer,
                       Emit,
                       ColorText,
                       Constraints,
                       Deftype,
                       Sumtypes,
                       SumtypeCase,
                       Commands,
                       Template,
                       ToTemplate,
                       SymPath,
                       Types,
                       TypesToC,
                       Util,
                       Eval,
                       TypeError,
                       InitialTypes,
                       AssignTypes,
                       GenerateConstraints,
                       Polymorphism,
                       Concretize,
                       ArrayTemplates,
                       StaticArrayTemplates,
                       Expand,
                       Scoring,
                       Lookup,
                       Context,
                       Qualify,
                       Repl,
                       StartingEnv,
                       RenderDocs,
                       StructUtils,
                       Path,
                       Interfaces,
                       PrimitiveError
                       Primitives,
                       Validate,
                       Reify,
                       Env,
                       TypePredicates,
                       Managed

  build-depends:       base >= 4.7 && < 5
                     , parsec == 3.1.*
                     , mtl
                     , containers
                     , process
                     , directory
                     , filepath
                     , split
                     , haskeline
                     , blaze-html
                     , blaze-markup
                     , text
                     , ansi-terminal >= 0.10.3
                     , cmark
                     , edit-distance
                     , open-browser

  default-language:    Haskell2010

executable carp
  hs-source-dirs:      app
  main-is:             Main.hs
  ghc-options:         -threaded -rtsopts -with-rtsopts=-N
  build-depends:       base
                     , CarpHask
                     , containers
                     , directory
                     , filepath
                     , haskeline
                     , process
                     , optparse-applicative
  default-language:    Haskell2010

executable carp-header-parse
  hs-source-dirs:      headerparse
  main-is:             Main.hs
  ghc-options:         -threaded -rtsopts -with-rtsopts=-N
  build-depends:       base
                     , CarpHask
                     , containers
                     , directory
                     , parsec
                     , optparse-applicative
  default-language:    Haskell2010

test-suite CarpHask-test
  type:                exitcode-stdio-1.0
  hs-source-dirs:      test
  main-is:             Spec.hs
  build-depends:       base
                     , CarpHask
                     , HUnit
                     , containers
  other-modules:       TestConstraints
                     , TestLookup
  ghc-options:         -threaded -rtsopts -with-rtsopts=-N
  default-language:    Haskell2010

source-repository head
  type:     git
  location: https://github.com/carp-lang/Carp
REPLACE WITH HASKELL VERSION 2017-06-26 12:15:03 +03:00			`name: CarpHask`
Update CarpHask.cabal 2020-11-26 10:26:51 +03:00			`version: 0.4.2.0`
REPLACE WITH HASKELL VERSION 2017-06-26 12:15:03 +03:00			`-- synopsis:`
			`-- description:`
			`homepage: https://github.com/eriksvedang/Carp`
			`license: Apache-2.0`
			`license-file: LICENSE`
			`author: Erik Svedäng`
			`maintainer: erik.svedang@gmail.com`
			`copyright: Erik Svedäng`
			`category: General`
			`build-type: Simple`
			`extra-source-files: README.md`
			`cabal-version: >=1.10`

			`library`
Address incomplete patterns (#1062) * chore: Address incomplete patterns * chore: Address incomplete patterns * chore: Address incomplete patterns * chore: Address incomplete patterns * chore: Address incomplete patterns * chore: Address incomplete patterns * chore: Address incomplete patterns * chore: Address incomplete patterns * chore: Address incomplete patterns * chore: Address incomplete patterns * chore: Address incomplete patterns * chore: Address incomplete patterns * chore: Unused error * chore: Address incomplete patterns * chore: Address incomplete patterns * chore: Address incomplete patterns * chore: Address incomplete patterns * chore: Address incomplete patterns * chore: Remove flag present only in newer ghc 2020-12-09 08:19:28 +03:00			`ghc-options: -Wall -Werror`
REPLACE WITH HASKELL VERSION 2017-06-26 12:15:03 +03:00			`hs-source-dirs: src`
Move Info into its own module Unlike many of the other datatypes in Obj.hs, Info does not introduce mutually recursive dependencies. Obj.hs is quite large and contains a lot of different functionality, so I think it helps to move anything that we can separate out into its own module in order to start simplifying the Obj.hs and its responsibilities. 2020-05-23 20:09:53 +03:00			`exposed-modules: Info,`
			`Obj,`
Add Meta module The Meta module does two things: - Collects functions related to working with Carp MetaData in one place - Hides the underlying implementation of MetaData MetaData is backed by `Data.Map` previously, we'd alter MetaData by getting the underlying map directly and calling Map functions to modify the contents. The functions in the Meta module encapsulate this--now callers may manipulate MetaData without having to know anything about the underlying Map implementation. This should make it easier to swap out the underlying representation in the future as well. 2020-06-09 21:28:07 +03:00			`Meta,`
Add pkgconfigflags. 2020-05-30 12:52:37 +03:00			`Project,`
REPLACE WITH HASKELL VERSION 2017-06-26 12:15:03 +03:00			`Parsing,`
repl: use haskeline 2017-10-20 00:36:17 +03:00			`Infer,`
REPLACE WITH HASKELL VERSION 2017-06-26 12:15:03 +03:00			`Emit,`
			`ColorText,`
			`Constraints,`
			`Deftype,`
Sumtype module. 2018-10-30 14:55:17 +03:00			`Sumtypes,`
Work in progress... 2019-03-26 12:23:27 +03:00			`SumtypeCase,`
REPLACE WITH HASKELL VERSION 2017-06-26 12:15:03 +03:00			`Commands,`
			`Template,`
Created a 'ToTemplate' module to avoid putting too much stuff into Concretize. 2018-08-30 14:07:14 +03:00			`ToTemplate,`
Separated Types utilities into SymPath.hs and TypesToC.hs 2020-05-24 12:04:31 +03:00			`SymPath,`
REPLACE WITH HASKELL VERSION 2017-06-26 12:15:03 +03:00			`Types,`
Separated Types utilities into SymPath.hs and TypesToC.hs 2020-05-24 12:04:31 +03:00			`TypesToC,`
REPLACE WITH HASKELL VERSION 2017-06-26 12:15:03 +03:00			`Util,`
Split the Infer module into smaller pieces. 2017-08-31 16:25:28 +03:00			`Eval,`
			`TypeError,`
			`InitialTypes,`
Split out AssignTypes also. 2017-08-31 17:40:56 +03:00			`AssignTypes,`
More splitting into modules, plus some comments. 2017-08-31 16:46:13 +03:00			`GenerateConstraints,`
Extracted Concretize-module. 2017-09-01 07:31:26 +03:00			`Polymorphism,`
Moved array templates out into its own module. 2017-09-06 09:57:48 +03:00			`Concretize,`
Extracted out Expand.hs module. 2017-12-15 18:37:03 +03:00			`ArrayTemplates,`
Some cleanup and start of tests for Static Array. 2020-04-29 11:39:15 +03:00			`StaticArrayTemplates,`
Extracted scoring of binders to its own module. 2018-02-01 19:41:29 +03:00			`Expand,`
Moved a lot of code out of Obj.hs and into two new modules: Qualify.hs and Lookup.hs 2018-02-01 19:52:50 +03:00			`Scoring,`
			`Lookup,`
refactor: improve readability of interface functions (#1053) * refactor: improve readability of interface functions Also refactors the `define` function for readability. The old definitions of these functions were quite unwieldy and difficult to read. This refactor attempts to make the monadic contexts we're juggling (often 3, Maybe, IO, Either) easier to spot. * refactor: Add context env updaters; refactor prims This commit contains a few more cleanups of the interface and define functions in Primitives. It also defines a new context module for holding functions that update context environments. 2020-12-05 23:00:28 +03:00			`Context,`
Split out two new modules: "Repl" and "StartingEnv". 2018-02-06 10:39:28 +03:00			`Qualify,`
			`Repl,`
RenderDocs.hs 2018-03-27 07:27:52 +03:00			`StartingEnv,`
A beginning of 'str' and 'prn' for sumtypes. 2019-01-23 22:26:42 +03:00			`RenderDocs,`
Validation for sumtype cases. 2019-02-20 17:25:00 +03:00			`StructUtils,`
Path module. 2019-09-24 00:47:26 +03:00			`Path,`
Move interface registration functions into Interfaces.hs This PR moves interface handling code out of Primitives.hs and into its own module. The actual primitives user's rely on to define and implement interfaces still live in Primitives.hs, but now all the registration/internal context mgmt code related to interfaces lives in its own module. Hopefully this will make it easier to modify and extend! 2020-06-10 08:02:13 +03:00			`Interfaces,`
Primitive refactors (#1070) * refactor: move primitive errors; refactor primtiveInfo This commit is the first in what will hopefully be a series of helpful primitive refactors. To start, we: - Move some inline `evalError` strings into a `PrimitiveError` module, (similar to the `TypeError`/`Types` module relationship - Add `Reifiable` instances for String and Int types to take these types to their XObj representation. - Add info utility functions for converting Info data to an XObj - Refactor the `info` primitive: - Use monadic combinators + `maybe` instead of nested cases. - Use helper lookup functions that take a context--nearly all lookup calls currently extract some env, typically without doing anything to it, to pass it to lookup. This is a sign the boundary is incorrect and lookups should take the context instead--this will allow us to eliminate a ton of local `globalEnv`, `typeEnv`, etc. bindings. - Don't print hidden bindings - Indent printed meta information. - Color bindings blue * chore: format code * refactor: improve names for lookups that take a context * feat: print hidden binders when calling info Someone calling info might be interested in hidden binders as well, for debugging purposes, etc. To enable this, we provide a version of show for binders that prints hidden binders. I've also made the printing of meta values in info more generic. 2020-12-15 23:38:55 +03:00			`PrimitiveError`
eval: add primitives 2020-02-21 22:20:13 +03:00			`Primitives,`
Enhance type reflection; get types of values, get kinds Extends Carp's support for type reflection by returning types for values as well as bindings. `type` now also returns a valid Carp expression/s-expression and so its output can be used as input to dynamic functions and macros (prior to this commit, `type` printed the type to the REPL but did not return a meaningful expression in Carp). Here are a few illustrations of the behavior: ``` (def x 1) ;; type now returns an s-expression/symbol (type x) => Int ;; It also works on values (type 1) => Int (type 2b) => Byte (type "foo") => (Ref String <StaticLifetime>) ;; It works on more complex values as well (type Maybe) => Module (type Maybe.Just) (Fn [a] (Maybe a) <StaticLifetime>) ;; reports honestly about polymorphism (type (Maybe.Nothing)) => (Maybe a) (type (Pair.init 1 2)) => (Pair Int Int) ;; What about the type of types? (type (type 2)) => Type ;; Or the type of types of types? (type (type (type 2))) => () ;; One more time! (type (type (type (type 2)))) => () ;; so, () is the fixpoint of type, and is reached after two applications (type zero) ;; the type of an interface is all of its implementations => (((Fn [] (Array a) <StaticLifetime>) (Fn [] Bool <StaticLifetime>) (Fn [] Byte <StaticLifetime>) (Fn [] Char <StaticLifetime>) (Fn [] Double <StaticLifetime>) (Fn [] Float <StaticLifetime>) (Fn [] Int <StaticLifetime>) (Fn [] Int16 <StaticLifetime>) (Fn [] Int32 <StaticLifetime>) (Fn [] Int64 <StaticLifetime>) (Fn [] Int8 <StaticLifetime>) (Fn [] Long <StaticLifetime>) (Fn [] (Maybe a) <StaticLifetime>) (Fn [] (Pair a b) <StaticLifetime>) (Fn [] (Quadruple a b c d) <StaticLifetime>) (Fn [] String <StaticLifetime>) (Fn [] (Triple a b c) <StaticLifetime>) (Fn [] Uint16 <StaticLifetime>) (Fn [] Uint32 <StaticLifetime>) (Fn [] Uint64 <StaticLifetime>) (Fn [] Uint8 <StaticLifetime>))) ``` As shown in the example above, this change also includes a cosmetic update to the representation of lifetime variables, which are surrounded in <> to distinguish them from type variables. This commit also adds a new `kind` primitive that reports on the kind of a binding or value: ``` (def x 3) (kind x) => Base (kind 2) => Base (kind Maybe.Just) => Higher (kind (Maybe.Just 2)) => Higher ``` `kind` and `type` both support interactive development in the repl, for example, a user can rely on `kind` to check the kind of a type they plan on using in an interface that demands a higher-kinded argument. Likewise, they both also support developing macros based on type information. 2020-10-03 00:48:58 +03:00			`Validate,`
refactor: Make Lookup module more focused and DRY (#1054) * refactor: Move constraints test to own module, create TestLookup module * refactor: Extracted 'Env' module * refactor: Extracted 'TypePredicates' module * test: First, very simple test * refactor: Extracted 'Managed' module * refactor: Add 'lookupBinder' function that doesn't return an Env (often what we want) * refactor: Move out more stuff from Lookup * refactor: Use new 'lookupBinder' in tons of places (avoids tuple) * refactor: Got rid of monolithic 'recursiveLookupInternal' * refactor: Avoid boolean blindness * refactor: Better names for some lookup functions * refactor: More logical order in Lookup.hs * style: Use correct version of ormolu (0.1.4.1) * refactor: Slightly more consistent naming * refactor: Address @scolsen:s feedback 2020-12-07 09:06:32 +03:00			`Reify,`
			`Env,`
			`TypePredicates,`
			`Managed`
repl: use haskeline 2017-10-20 00:36:17 +03:00
REPLACE WITH HASKELL VERSION 2017-06-26 12:15:03 +03:00			`build-depends: base >= 4.7 && < 5`
			`, parsec == 3.1.*`
			`, mtl`
			`, containers`
			`, process`
			`, directory`
Started working on 'relative-include' macro - not working yet though. 2018-03-12 18:30:36 +03:00			`, filepath`
REPLACE WITH HASKELL VERSION 2017-06-26 12:15:03 +03:00			`, split`
Split out two new modules: "Repl" and "StartingEnv". 2018-02-06 10:39:28 +03:00			`, haskeline`
docs: change to pretty rendering 2018-07-18 13:23:02 +03:00			`, blaze-html`
			`, blaze-markup`
RenderDocs.hs 2018-03-27 07:27:52 +03:00			`, text`
Switch resolver. 2020-05-21 21:44:43 +03:00			`, ansi-terminal >= 0.10.3`
compiler: add suport for markdown in docstrings 2018-10-22 17:10:13 +03:00			`, cmark`
compiler: better error messages 2019-03-12 21:11:12 +03:00			`, edit-distance`
docs: Remove a lot of duplicated information and refer to webpages instead (#988) * docs: Remove a lot of duplicated information and refer to webpages instead * fix: Remove line about (help), it does not make sense anymore * fix: Add open-browser to nix config Co-authored-by: Erik Svedang <erik@Eriks-iMac.local> 2020-11-23 11:58:06 +03:00			`, open-browser`
repl: use haskeline 2017-10-20 00:36:17 +03:00
REPLACE WITH HASKELL VERSION 2017-06-26 12:15:03 +03:00			`default-language: Haskell2010`

Enable manual. 2017-06-26 13:04:39 +03:00			`executable carp`
REPLACE WITH HASKELL VERSION 2017-06-26 12:15:03 +03:00			`hs-source-dirs: app`
			`main-is: Main.hs`
			`ghc-options: -threaded -rtsopts -with-rtsopts=-N`
			`build-depends: base`
			`, CarpHask`
			`, containers`
repl: added simple completion and history file 2017-10-23 00:34:06 +03:00			`, directory`
Path module. 2019-09-24 00:47:26 +03:00			`, filepath`
repl: use haskeline 2017-10-20 00:36:17 +03:00			`, haskeline`
REPLACE WITH HASKELL VERSION 2017-06-26 12:15:03 +03:00			`, process`
Switch option parsing to optparse-applicative, remove tcc dependency. 2020-05-21 20:57:40 +03:00			`, optparse-applicative`
REPLACE WITH HASKELL VERSION 2017-06-26 12:15:03 +03:00			`default-language: Haskell2010`

Started working on utility for parsing C headers. 2018-02-27 11:50:20 +03:00			`executable carp-header-parse`
			`hs-source-dirs: headerparse`
			`main-is: Main.hs`
			`ghc-options: -threaded -rtsopts -with-rtsopts=-N`
			`build-depends: base`
			`, CarpHask`
			`, containers`
			`, directory`
			`, parsec`
Switch option parsing to optparse-applicative, remove tcc dependency. 2020-05-21 20:57:40 +03:00			`, optparse-applicative`
Started working on utility for parsing C headers. 2018-02-27 11:50:20 +03:00			`default-language: Haskell2010`

REPLACE WITH HASKELL VERSION 2017-06-26 12:15:03 +03:00			`test-suite CarpHask-test`
			`type: exitcode-stdio-1.0`
			`hs-source-dirs: test`
			`main-is: Spec.hs`
			`build-depends: base`
			`, CarpHask`
			`, HUnit`
			`, containers`
refactor: Make Lookup module more focused and DRY (#1054) * refactor: Move constraints test to own module, create TestLookup module * refactor: Extracted 'Env' module * refactor: Extracted 'TypePredicates' module * test: First, very simple test * refactor: Extracted 'Managed' module * refactor: Add 'lookupBinder' function that doesn't return an Env (often what we want) * refactor: Move out more stuff from Lookup * refactor: Use new 'lookupBinder' in tons of places (avoids tuple) * refactor: Got rid of monolithic 'recursiveLookupInternal' * refactor: Avoid boolean blindness * refactor: Better names for some lookup functions * refactor: More logical order in Lookup.hs * style: Use correct version of ormolu (0.1.4.1) * refactor: Slightly more consistent naming * refactor: Address @scolsen:s feedback 2020-12-07 09:06:32 +03:00			`other-modules: TestConstraints`
			`, TestLookup`
REPLACE WITH HASKELL VERSION 2017-06-26 12:15:03 +03:00			`ghc-options: -threaded -rtsopts -with-rtsopts=-N`
			`default-language: Haskell2010`

			`source-repository head`
			`type: git`
Started working on utility for parsing C headers. 2018-02-27 11:50:20 +03:00			`location: https://github.com/carp-lang/Carp`