Carp/CarpHask.cabal

name:                CarpHask
version:             0.3.0.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
  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,
                       Qualify,
                       Repl,
                       StartingEnv,
                       RenderDocs,
                       StructUtils,
                       Path,
                       Interfaces,
                       Primitives,
                       Validate,
                       Reify

  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

  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
  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`
Bump to version 0.3.0. 2019-07-04 11:34:03 +03:00			`version: 0.3.0.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`
			`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,`
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,`
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,`
			`Reify`
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`
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`
			`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`