categorifier-c-examples.cabal

cabal-version:  2.4

name:           categorifier-c-examples
version:        0.1
homepage:       https://github.com/con-kitty/categorifier-c#readme
bug-reports:    https://github.com/con-kitty/categorifier-c/issues
build-type:     Simple
tested-with:    GHC==8.10.1, GHC==8.10.2, GHC==8.10.4, GHC==8.10.7, GHC==9.0.1, GHC==9.0.2

source-repository head
  type: git
  location: https://github.com/con-kitty/categorifier-c

executable simple
  hs-source-dirs: simple
  main-is: Main.hs
  other-modules:
      F
  ghc-options:
      -O0
      -fexpose-all-unfoldings
      -fmax-simplifier-iterations=0
      -fno-ignore-interface-pragmas
      -fno-omit-interface-pragmas
      -Wall
      -fplugin Categorifier
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.UnconCat.hierarchy
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.ConCat.functionHierarchy
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.ConCatExtensions.hierarchy
  build-depends:
      base
    , ghc-prim
    , concat-classes
    , categorifier-c
    , categorifier-category
    , categorifier-client
    , categorifier-concat-extensions-category
    , categorifier-concat-extensions-integration
    , categorifier-concat-integration
    , categorifier-plugin
    , categorifier-unconcat-category
    , categorifier-unconcat-integration
  default-language: Haskell2010

executable multiple-c-functions
  hs-source-dirs: multiple-c-functions
  main-is: Main.hs
  other-modules:
      F
  ghc-options:
      -O0
      -fexpose-all-unfoldings
      -fmax-simplifier-iterations=0
      -fno-ignore-interface-pragmas
      -fno-omit-interface-pragmas
      -Wall
      -fplugin Categorifier
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.UnconCat.hierarchy
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.ConCat.functionHierarchy
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.ConCatExtensions.hierarchy
      -- This example requires `cMakerMapFun`, which tells the plugin how to interpret
      -- `kFunctionCall`. `baseMakerMapFun` is the default maker map, but it needs to be
      -- specified if we want to use additional maker maps.
      -fplugin-opt Categorifier:maker-map:Categorifier.Core.MakerMap.baseMakerMapFun
      -fplugin-opt Categorifier:maker-map:Categorifier.C.MakerMap.cMakerMapFun
  build-depends:
      base
    , ghc-prim
    , concat-classes
    , categorifier-c
    , categorifier-category
    , categorifier-client
    , categorifier-concat-extensions-category
    , categorifier-concat-extensions-integration
    , categorifier-concat-integration
    , categorifier-c-maker-map
    , categorifier-plugin
    , categorifier-unconcat-category
    , categorifier-unconcat-integration
  default-language: Haskell2010

executable separate-categorification
  hs-source-dirs: separate-categorification
  main-is: Main.hs
  other-modules:
      F
      G
  ghc-options:
      -O0
      -fexpose-all-unfoldings
      -fmax-simplifier-iterations=0
      -fno-ignore-interface-pragmas
      -fno-omit-interface-pragmas
      -Wall
      -fplugin Categorifier
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.UnconCat.hierarchy
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.ConCat.functionHierarchy
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.ConCatExtensions.hierarchy
  build-depends:
      base
    , ghc-prim
    , concat-classes
    , categorifier-c
    , categorifier-category
    , categorifier-client
    , categorifier-concat-extensions-category
    , categorifier-concat-extensions-integration
    , categorifier-concat-integration
    , categorifier-plugin
    , categorifier-unconcat-category
    , categorifier-unconcat-integration
  default-language: Haskell2010

executable auto-interpret
  hs-source-dirs: auto-interpret
  main-is: Main.hs
  other-modules:
      F
  ghc-options:
      -O0
      -fexpose-all-unfoldings
      -fmax-simplifier-iterations=0
      -fno-ignore-interface-pragmas
      -fno-omit-interface-pragmas
      -Wall
      -fplugin Categorifier
      -fplugin-opt Categorifier:autointerpreter:Categorifier.C.UnconCat.tryAutoInterpret
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.UnconCat.hierarchy
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.ConCat.functionHierarchy
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.ConCatExtensions.hierarchy
  build-depends:
      base
    , ghc-prim
    , concat-classes
    , categorifier-c
    , categorifier-c-hk-classes
    , categorifier-c-unconcat
    , categorifier-category
    , categorifier-client
    , categorifier-concat-extensions-category
    , categorifier-concat-extensions-integration
    , categorifier-concat-integration
    , categorifier-plugin
    , categorifier-unconcat-category
    , categorifier-unconcat-integration
  default-language: Haskell2010

executable sum-types
  hs-source-dirs: sum-types
  main-is: Main.hs
  other-modules:
      F
  ghc-options:
      -O0
      -fexpose-all-unfoldings
      -fmax-simplifier-iterations=0
      -fno-ignore-interface-pragmas
      -fno-omit-interface-pragmas
      -Wall
      -fplugin Categorifier
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.UnconCat.hierarchy
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.ConCat.functionHierarchy
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.ConCatExtensions.hierarchy
  build-depends:
      base
    , ghc-prim
    , concat-classes
    , categorifier-c
    , categorifier-category
    , categorifier-client
    , categorifier-concat-extensions-category
    , categorifier-concat-extensions-integration
    , categorifier-concat-integration
    , categorifier-plugin
    , categorifier-unconcat-category
    , categorifier-unconcat-integration
  default-language: Haskell2010

executable recursive-types
  hs-source-dirs: recursive-types
  main-is: Main.hs
  other-modules:
      F
  ghc-options:
      -O0
      -fexpose-all-unfoldings
      -fmax-simplifier-iterations=0
      -fno-ignore-interface-pragmas
      -fno-omit-interface-pragmas
      -Wall
      -fplugin Categorifier
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.UnconCat.hierarchy
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.ConCat.functionHierarchy
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.ConCatExtensions.hierarchy
  build-depends:
      base
    , ghc-prim
    , concat-classes
    , categorifier-c
    , categorifier-category
    , categorifier-client
    , categorifier-concat-extensions-category
    , categorifier-concat-extensions-integration
    , categorifier-concat-integration
    , categorifier-plugin
    , categorifier-unconcat-category
    , categorifier-unconcat-integration
  default-language: Haskell2010

executable recursive-types-2
  hs-source-dirs: recursive-types-2
  main-is: Main.hs
  other-modules:
      F
  ghc-options:
      -O0
      -fexpose-all-unfoldings
      -fmax-simplifier-iterations=0
      -fno-ignore-interface-pragmas
      -fno-omit-interface-pragmas
      -Wall
      -fplugin Categorifier
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.UnconCat.hierarchy
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.ConCat.functionHierarchy
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.ConCatExtensions.hierarchy
  build-depends:
      base
    , ghc-prim
    , concat-classes
    , categorifier-c
    , categorifier-category
    , categorifier-client
    , categorifier-concat-extensions-category
    , categorifier-concat-extensions-integration
    , categorifier-concat-integration
    , categorifier-plugin
    , categorifier-unconcat-category
    , categorifier-unconcat-integration
  default-language: Haskell2010

executable c-types
  hs-source-dirs: c-types
  main-is: Main.hs
  ghc-options:
      -Wall
  build-depends:
      base
    , filepath
    , text
    , categorifier-c
  default-language: Haskell2010

executable c-wrappers
  hs-source-dirs: c-wrappers
  main-is: Main.hs
  other-modules:
      F
  ghc-options:
      -O0
      -fexpose-all-unfoldings
      -fmax-simplifier-iterations=0
      -fno-ignore-interface-pragmas
      -fno-omit-interface-pragmas
      -Wall
      -fplugin Categorifier
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.UnconCat.hierarchy
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.ConCat.functionHierarchy
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.ConCatExtensions.hierarchy
  build-depends:
      base
    , ghc-prim
    , concat-classes
    , categorifier-c
    , categorifier-category
    , categorifier-client
    , categorifier-concat-extensions-category
    , categorifier-concat-extensions-integration
    , categorifier-concat-integration
    , categorifier-plugin
    , categorifier-unconcat-category
    , categorifier-unconcat-integration
  default-language: Haskell2010

executable th-compile
  hs-source-dirs: th-compile
  main-is: Main.hs
  other-modules:
      F
  ghc-options:
      -O0
      -fexpose-all-unfoldings
      -fmax-simplifier-iterations=0
      -fno-ignore-interface-pragmas
      -fno-omit-interface-pragmas
      -Wall
      -fplugin Categorifier
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.UnconCat.hierarchy
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.ConCat.functionHierarchy
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.ConCatExtensions.hierarchy
  build-depends:
      base
    , ghc-prim
    , concat-classes
    , categorifier-c
    , categorifier-c-test-lib
    , categorifier-category
    , categorifier-client
    , categorifier-concat-extensions-category
    , categorifier-concat-extensions-integration
    , categorifier-concat-integration
    , categorifier-plugin
    , categorifier-unconcat-category
    , categorifier-unconcat-integration
  default-language: Haskell2010

executable external-c-functions
  hs-source-dirs: external-c-functions
  main-is: Main.hs
  other-modules:
      CTypes
      F
  ghc-options:
      -O0
      -fexpose-all-unfoldings
      -fmax-simplifier-iterations=0
      -fno-ignore-interface-pragmas
      -fno-omit-interface-pragmas
      -Wall
      -fplugin Categorifier
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.UnconCat.hierarchy
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.ConCat.functionHierarchy
      -fplugin-opt Categorifier:hierarchy:Categorifier.Hierarchy.ConCatExtensions.hierarchy
      -- This example requires `cMakerMapFun`, which tells the plugin how to interpret
      -- `kForeignFunctionCall`. `baseMakerMapFun` is the default maker map, but it needs to be
      -- specified if we want to use additional maker maps.
      -fplugin-opt Categorifier:maker-map:Categorifier.Core.MakerMap.baseMakerMapFun
      -fplugin-opt Categorifier:maker-map:Categorifier.C.MakerMap.cMakerMapFun
  build-depends:
      base
    , filepath
    , ghc-prim
    , concat-classes
    , categorifier-c
    , categorifier-c-maker-map
    , categorifier-category
    , categorifier-client
    , categorifier-concat-extensions-category
    , categorifier-concat-extensions-integration
    , categorifier-concat-integration
    , categorifier-plugin
    , categorifier-unconcat-category
    , categorifier-unconcat-integration
    , text
  default-language: Haskell2010