ddc-core-tetra (empty) → 0.3.2.1
raw patch · 12 files changed
+785/−0 lines, 12 filesdep +arraydep +basedep +containerssetup-changed
Dependencies added: array, base, containers, ddc-base, ddc-core, ddc-core-salt, ddc-core-simpl, deepseq, mtl, transformers
Files
- DDC/Core/Tetra.hs +21/−0
- DDC/Core/Tetra/Compounds.hs +10/−0
- DDC/Core/Tetra/Env.hs +101/−0
- DDC/Core/Tetra/Prim.hs +107/−0
- DDC/Core/Tetra/Prim/Base.hs +110/−0
- DDC/Core/Tetra/Prim/OpPrimArith.hs +88/−0
- DDC/Core/Tetra/Prim/OpPrimRef.hs +57/−0
- DDC/Core/Tetra/Prim/TyConPrim.hs +102/−0
- DDC/Core/Tetra/Profile.hs +98/−0
- LICENSE +30/−0
- Setup.hs +2/−0
- ddc-core-tetra.cabal +59/−0
+ DDC/Core/Tetra.hs view
@@ -0,0 +1,21 @@++module DDC.Core.Tetra+ ( -- * Language profile+ profile++ -- * Names+ , Name (..)+ , TyConPrim (..)+ , OpPrimArith (..)+ , OpPrimRef (..)++ -- * Name Parsing+ , readName++ -- * Program Lexing+ , lexModuleString+ , lexExpString)++where+import DDC.Core.Tetra.Prim+import DDC.Core.Tetra.Profile
+ DDC/Core/Tetra/Compounds.hs view
@@ -0,0 +1,10 @@++module DDC.Core.Tetra.Compounds+ ( module DDC.Core.Compounds.Annot+ , tBool+ , tNat+ , tInt+ , tWord)+where+import DDC.Core.Tetra.Prim.TyConPrim+import DDC.Core.Compounds.Annot
+ DDC/Core/Tetra/Env.hs view
@@ -0,0 +1,101 @@++module DDC.Core.Tetra.Env+ ( primDataDefs+ , primSortEnv+ , primKindEnv+ , primTypeEnv)+where+import DDC.Core.Tetra.Prim+import DDC.Core.Tetra.Compounds+import DDC.Type.DataDef+import DDC.Type.Exp+import DDC.Type.Env (Env)+import qualified DDC.Type.Env as Env+++-- DataDefs -------------------------------------------------------------------+-- | Data type definitions +--+-- > Type Constructors+-- > ---- ------------------------------+-- > Bool True False+-- > Nat 0 1 2 ...+-- > Int ... -2i -1i 0i 1i 2i ...+-- > Word{8,16,32,64}# 42w8 123w64 ...+-- +primDataDefs :: DataDefs Name+primDataDefs+ = fromListDataDefs+ -- Primitive -----------------------------------------------+ -- Bool+ [ DataDef (NameTyConPrim TyConPrimBool) + [] + (Just [ (NameLitBool True, []) + , (NameLitBool False, []) ])++ -- Nat+ , DataDef (NameTyConPrim TyConPrimNat) [] Nothing++ -- Int+ , DataDef (NameTyConPrim TyConPrimInt) [] Nothing++ -- WordN+ , DataDef (NameTyConPrim (TyConPrimWord 64)) [] Nothing+ , DataDef (NameTyConPrim (TyConPrimWord 32)) [] Nothing+ , DataDef (NameTyConPrim (TyConPrimWord 16)) [] Nothing+ , DataDef (NameTyConPrim (TyConPrimWord 8)) [] Nothing++ -- Ref+ , DataDef (NameTyConPrim TyConPrimRef) [] Nothing+ ]+++-- Sorts ---------------------------------------------------------------------+-- | Sort environment containing sorts of primitive kinds.+primSortEnv :: Env Name+primSortEnv = Env.setPrimFun sortOfPrimName Env.empty+++-- | Take the sort of a primitive kind name.+sortOfPrimName :: Name -> Maybe (Sort Name)+sortOfPrimName _ = Nothing+++-- Kinds ----------------------------------------------------------------------+-- | Kind environment containing kinds of primitive data types.+primKindEnv :: Env Name+primKindEnv = Env.setPrimFun kindOfPrimName Env.empty+++-- | Take the kind of a primitive name.+--+-- Returns `Nothing` if the name isn't primitive. +--+kindOfPrimName :: Name -> Maybe (Kind Name)+kindOfPrimName nn+ = case nn of+ NameTyConPrim tc -> Just $ kindTyConPrim tc+ _ -> Nothing+++-- Types ----------------------------------------------------------------------+-- | Type environment containing types of primitive operators.+primTypeEnv :: Env Name+primTypeEnv = Env.setPrimFun typeOfPrimName Env.empty+++-- | Take the type of a name,+-- or `Nothing` if this is not a value name.+typeOfPrimName :: Name -> Maybe (Type Name)+typeOfPrimName dc+ = case dc of+ NameOpPrimArith p -> Just $ typeOpPrimArith p+ NameOpPrimRef p -> Just $ typeOpPrimRef p++ NameLitBool _ -> Just $ tBool+ NameLitNat _ -> Just $ tNat+ NameLitInt _ -> Just $ tInt+ NameLitWord _ bits -> Just $ tWord bits++ _ -> Nothing+
+ DDC/Core/Tetra/Prim.hs view
@@ -0,0 +1,107 @@++module DDC.Core.Tetra.Prim+ ( -- * Names and lexing.+ Name (..)+ , readName++ -- * Primitive type constructors.+ , TyConPrim (..)+ , kindTyConPrim++ -- * Primitive arithmetic operators.+ , OpPrimArith (..)+ , typeOpPrimArith++ -- * Mutable references.+ , OpPrimRef (..)+ , typeOpPrimRef)+where+import DDC.Core.Tetra.Prim.Base+import DDC.Core.Tetra.Prim.TyConPrim+import DDC.Core.Tetra.Prim.OpPrimArith+import DDC.Core.Tetra.Prim.OpPrimRef+import DDC.Core.Salt.Name + ( readLitPrimNat+ , readLitPrimInt+ , readLitPrimWordOfBits)++import DDC.Base.Pretty+import Control.DeepSeq+import Data.Char +++instance NFData Name where+ rnf nn+ = case nn of+ NameVar s -> rnf s+ NameCon s -> rnf s++ NameTyConPrim con -> rnf con+ NameOpPrimArith con -> rnf con+ NameOpPrimRef con -> rnf con++ NameLitBool b -> rnf b+ NameLitNat n -> rnf n+ NameLitInt i -> rnf i+ NameLitWord i bits -> rnf i `seq` rnf bits+++instance Pretty Name where+ ppr nn+ = case nn of+ NameVar v -> text v+ NameCon c -> text c++ NameTyConPrim tc -> ppr tc+ NameOpPrimArith op -> ppr op+ NameOpPrimRef op -> ppr op++ NameLitBool True -> text "True"+ NameLitBool False -> text "False"+ NameLitNat i -> integer i+ NameLitInt i -> integer i <> text "i"+ NameLitWord i bits -> integer i <> text "w" <> int bits+++-- | Read the name of a variable, constructor or literal.+readName :: String -> Maybe Name+readName str+ -- Primitive names.+ | Just p <- readTyConPrim str + = Just $ NameTyConPrim p++ | Just p <- readOpPrimArith str + = Just $ NameOpPrimArith p++ | Just p <- readOpPrimRef str + = Just $ NameOpPrimRef p++ -- Literal Bools+ | str == "True" = Just $ NameLitBool True+ | str == "False" = Just $ NameLitBool False++ -- Literal Nat+ | Just val <- readLitPrimNat str+ = Just $ NameLitNat val++ -- Literal Ints+ | Just val <- readLitPrimInt str+ = Just $ NameLitInt val++ -- Literal Words+ | Just (val, bits) <- readLitPrimWordOfBits str+ , elem bits [8, 16, 32, 64]+ = Just $ NameLitWord val bits++ -- Constructors.+ | c : _ <- str+ , isUpper c+ = Just $ NameCon str++ -- Variables.+ | c : _ <- str+ , isLower c + = Just $ NameVar str++ | otherwise+ = Nothing
+ DDC/Core/Tetra/Prim/Base.hs view
@@ -0,0 +1,110 @@++module DDC.Core.Tetra.Prim.Base+ ( Name (..)+ , TyConPrim (..)+ , OpPrimArith (..)+ , OpPrimRef (..))+where+import Data.Typeable+++-- | Names of things used in Disciple Core Tetra.+data Name+ -- | User defined variables.+ = NameVar String++ -- | A user defined constructor.+ | NameCon String++ -- Machine primitives ------------------+ -- | A primitive type constructor.+ | NameTyConPrim TyConPrim++ -- | Primitive arithmetic, logic, comparison and bit-wise operators.+ | NameOpPrimArith OpPrimArith++ -- | Mutable references.+ | NameOpPrimRef OpPrimRef++ -- Literals -----------------------------+ -- | A boolean literal.+ | NameLitBool Bool++ -- | A natural literal.+ | NameLitNat Integer++ -- | An integer literal.+ | NameLitInt Integer++ -- | A word literal.+ | NameLitWord Integer Int+ deriving (Eq, Ord, Show, Typeable)+++-- TyConPrim ------------------------------------------------------------------+-- | Primitive type constructors.+data TyConPrim+ -- | @Bool@ unboxed booleans.+ = TyConPrimBool++ -- | @Nat@ natural numbers.+ -- Big enough to count every addressable byte in the store.+ | TyConPrimNat++ -- | @Int@ signed integers.+ | TyConPrimInt++ -- | @WordN@ machine words of the given width.+ | TyConPrimWord Int++ -- | A mutable reference.+ | TyConPrimRef+ deriving (Eq, Ord, Show)+++-- OpPrimArith ----------------------------------------------------------------+-- | Primitive arithmetic, logic, and comparison opretors.+-- We expect the backend/machine to be able to implement these directly.+--+-- For the Shift Right operator, the type that it is used at determines+-- whether it is an arithmetic (with sign-extension) or logical+-- (no sign-extension) shift.+data OpPrimArith+ -- numeric+ = OpPrimArithNeg -- ^ Negation+ | OpPrimArithAdd -- ^ Addition+ | OpPrimArithSub -- ^ Subtraction+ | OpPrimArithMul -- ^ Multiplication+ | OpPrimArithDiv -- ^ Division+ | OpPrimArithMod -- ^ Modulus+ | OpPrimArithRem -- ^ Remainder++ -- comparison+ | OpPrimArithEq -- ^ Equality+ | OpPrimArithNeq -- ^ Negated Equality+ | OpPrimArithGt -- ^ Greater Than+ | OpPrimArithGe -- ^ Greater Than or Equal+ | OpPrimArithLt -- ^ Less Than+ | OpPrimArithLe -- ^ Less Than or Equal++ -- boolean+ | OpPrimArithAnd -- ^ Boolean And+ | OpPrimArithOr -- ^ Boolean Or++ -- bitwise+ | OpPrimArithShl -- ^ Shift Left+ | OpPrimArithShr -- ^ Shift Right+ | OpPrimArithBAnd -- ^ Bit-wise And+ | OpPrimArithBOr -- ^ Bit-wise Or+ | OpPrimArithBXOr -- ^ Bit-wise eXclusive Or+ deriving (Eq, Ord, Show)+++-- OpPrimRef ------------------------------------------------------------------+-- | Mutable References.+data OpPrimRef+ = OpPrimRefAllocRef -- ^ Allocate a reference.+ | OpPrimRefReadRef -- ^ Read a reference.+ | OpPrimRefWriteRef -- ^ Write to a reference.+ deriving (Eq, Ord, Show)+
+ DDC/Core/Tetra/Prim/OpPrimArith.hs view
@@ -0,0 +1,88 @@++module DDC.Core.Tetra.Prim.OpPrimArith+ ( readOpPrimArith+ , typeOpPrimArith)+where+import DDC.Core.Tetra.Prim.TyConPrim+import DDC.Core.Tetra.Prim.Base+import DDC.Type.Compounds+import DDC.Type.Exp+import DDC.Base.Pretty+import Control.DeepSeq+import Data.List+++-- OpPrimArith ----------------------------------------------------------------+instance NFData OpPrimArith++instance Pretty OpPrimArith where+ ppr op+ = let Just (_, n) = find (\(p, _) -> op == p) opPrimArithNames+ in (text n)+++-- | Read a primitive operator.+readOpPrimArith :: String -> Maybe OpPrimArith+readOpPrimArith str+ = case find (\(_, n) -> str == n) opPrimArithNames of+ Just (p, _) -> Just p+ _ -> Nothing+++-- | Names of primitve operators.+opPrimArithNames :: [(OpPrimArith, String)]+opPrimArithNames+ = [ (OpPrimArithNeg, "neg#")+ , (OpPrimArithAdd, "add#")+ , (OpPrimArithSub, "sub#")+ , (OpPrimArithMul, "mul#")+ , (OpPrimArithDiv, "div#")+ , (OpPrimArithRem, "rem#")+ , (OpPrimArithMod, "mod#")+ , (OpPrimArithEq , "eq#" )+ , (OpPrimArithNeq, "neq#")+ , (OpPrimArithGt , "gt#" )+ , (OpPrimArithGe , "ge#" )+ , (OpPrimArithLt , "lt#" )+ , (OpPrimArithLe , "le#" )+ , (OpPrimArithAnd, "and#")+ , (OpPrimArithOr , "or#" ) + , (OpPrimArithShl, "shl#")+ , (OpPrimArithShr, "shr#")+ , (OpPrimArithBAnd, "band#")+ , (OpPrimArithBOr, "bor#")+ , (OpPrimArithBXOr, "bxor#") ]+++-- | Take the type of a primitive arithmetic operator.+typeOpPrimArith :: OpPrimArith -> Type Name+typeOpPrimArith op+ = case op of+ -- Numeric+ OpPrimArithNeg -> tForall kData $ \t -> t `tFunPE` t+ OpPrimArithAdd -> tForall kData $ \t -> t `tFunPE` t `tFunPE` t+ OpPrimArithSub -> tForall kData $ \t -> t `tFunPE` t `tFunPE` t+ OpPrimArithMul -> tForall kData $ \t -> t `tFunPE` t `tFunPE` t+ OpPrimArithDiv -> tForall kData $ \t -> t `tFunPE` t `tFunPE` t+ OpPrimArithMod -> tForall kData $ \t -> t `tFunPE` t `tFunPE` t+ OpPrimArithRem -> tForall kData $ \t -> t `tFunPE` t `tFunPE` t++ -- Comparison+ OpPrimArithEq -> tForall kData $ \t -> t `tFunPE` t `tFunPE` tBool+ OpPrimArithNeq -> tForall kData $ \t -> t `tFunPE` t `tFunPE` tBool+ OpPrimArithGt -> tForall kData $ \t -> t `tFunPE` t `tFunPE` tBool+ OpPrimArithLt -> tForall kData $ \t -> t `tFunPE` t `tFunPE` tBool+ OpPrimArithLe -> tForall kData $ \t -> t `tFunPE` t `tFunPE` tBool+ OpPrimArithGe -> tForall kData $ \t -> t `tFunPE` t `tFunPE` tBool++ -- Boolean+ OpPrimArithAnd -> tBool `tFunPE` tBool `tFunPE` tBool+ OpPrimArithOr -> tBool `tFunPE` tBool `tFunPE` tBool++ -- Bitwise+ OpPrimArithShl -> tForall kData $ \t -> t `tFunPE` t `tFunPE` t+ OpPrimArithShr -> tForall kData $ \t -> t `tFunPE` t `tFunPE` t+ OpPrimArithBAnd -> tForall kData $ \t -> t `tFunPE` t `tFunPE` t+ OpPrimArithBOr -> tForall kData $ \t -> t `tFunPE` t `tFunPE` t+ OpPrimArithBXOr -> tForall kData $ \t -> t `tFunPE` t `tFunPE` t+
+ DDC/Core/Tetra/Prim/OpPrimRef.hs view
@@ -0,0 +1,57 @@++module DDC.Core.Tetra.Prim.OpPrimRef+ ( readOpPrimRef+ , typeOpPrimRef)+where+import DDC.Core.Tetra.Prim.TyConPrim+import DDC.Core.Tetra.Prim.Base+import DDC.Type.Compounds+import DDC.Type.Exp+import DDC.Base.Pretty+import Control.DeepSeq+import Data.List+++-- OpPrimArith ----------------------------------------------------------------+instance NFData OpPrimRef++instance Pretty OpPrimRef where+ ppr op+ = let Just (_, n) = find (\(p, _) -> op == p) opPrimRefNames+ in (text n)+++-- | Read a primitive operator.+readOpPrimRef :: String -> Maybe OpPrimRef+readOpPrimRef str+ = case find (\(_, n) -> str == n) opPrimRefNames of+ Just (p, _) -> Just p+ _ -> Nothing+++-- | Names of primitve operators.+opPrimRefNames :: [(OpPrimRef, String)]+opPrimRefNames+ = [ (OpPrimRefAllocRef, "allocRef#")+ , (OpPrimRefReadRef, "readRef#")+ , (OpPrimRefWriteRef, "writeRef#") ]+++-- | Take the type of a primitive arithmetic operator.+typeOpPrimRef :: OpPrimRef -> Type Name+typeOpPrimRef op+ = case op of+ OpPrimRefAllocRef + -> tForalls [kRegion, kData] + $ \[tR, tA] -> tA + `tFun` tSusp (tAlloc tR) (tRef tR tA)++ OpPrimRefReadRef + -> tForalls [kRegion, kData]+ $ \[tR, tA] -> tRef tR tA+ `tFun` tSusp (tRead tR) tA++ OpPrimRefWriteRef + -> tForalls [kRegion, kData]+ $ \[tR, tA] -> tRef tR tA `tFun` tA+ `tFun` tSusp (tWrite tR) tUnit
+ DDC/Core/Tetra/Prim/TyConPrim.hs view
@@ -0,0 +1,102 @@++module DDC.Core.Tetra.Prim.TyConPrim + ( TyConPrim (..)+ , readTyConPrim+ , kindTyConPrim+ , tBool+ , tNat+ , tInt+ , tWord+ , tRef)+where+import DDC.Core.Tetra.Prim.Base+import DDC.Core.Compounds.Annot+import DDC.Core.Exp.Simple+import DDC.Base.Pretty+import Control.DeepSeq+import Data.List+import Data.Char+++instance NFData TyConPrim where+ rnf tc+ = case tc of+ TyConPrimWord i -> rnf i+ _ -> ()+++instance Pretty TyConPrim where+ ppr tc+ = case tc of+ TyConPrimBool -> text "Bool"+ TyConPrimNat -> text "Nat"+ TyConPrimInt -> text "Int"+ TyConPrimWord bits -> text "Word" <> int bits+ TyConPrimRef -> text "Ref"+++-- | Read a primitive type constructor.+-- +-- Words are limited to 8, 16, 32, or 64 bits.+-- +-- Floats are limited to 32 or 64 bits.+readTyConPrim :: String -> Maybe TyConPrim+readTyConPrim str+ | str == "Bool" = Just $ TyConPrimBool+ | str == "Nat" = Just $ TyConPrimNat+ | str == "Int" = Just $ TyConPrimInt++ -- WordN+ | Just rest <- stripPrefix "Word" str+ , (ds, "") <- span isDigit rest+ , not $ null ds+ , n <- read ds+ , elem n [8, 16, 32, 64]+ = Just $ TyConPrimWord n++ | str == "Ref" = Just $ TyConPrimRef++ | otherwise+ = Nothing+++-- | Yield the kind of a type constructor.+kindTyConPrim :: TyConPrim -> Kind Name+kindTyConPrim tc+ = case tc of+ TyConPrimBool -> kData+ TyConPrimNat -> kData+ TyConPrimInt -> kData+ TyConPrimWord _ -> kData+ TyConPrimRef -> kRegion `kFun` kData `kFun` kData+++-- Compounds ------------------------------------------------------------------+-- | Primitive `Bool` type.+tBool :: Type Name+tBool = TCon (TyConBound (UPrim (NameTyConPrim TyConPrimBool) kData) kData)+++-- | Primitive `Nat` type.+tNat :: Type Name+tNat = TCon (TyConBound (UPrim (NameTyConPrim TyConPrimNat) kData) kData)+++-- | Primitive `Int` type.+tInt :: Type Name+tInt = TCon (TyConBound (UPrim (NameTyConPrim TyConPrimInt) kData) kData)+++-- | Primitive `WordN` type of the given width.+tWord :: Int -> Type Name+tWord bits + = TCon (TyConBound (UPrim (NameTyConPrim (TyConPrimWord bits)) kData) kData)+++-- | Primitive `Ref` type.+tRef :: Region Name -> Type Name -> Type Name+tRef tR tA + = tApps (TCon (TyConBound (UPrim (NameTyConPrim TyConPrimRef) k) k))+ [tR, tA]+ where k = kRegion `kFun` kData `kFun` kData+
+ DDC/Core/Tetra/Profile.hs view
@@ -0,0 +1,98 @@++-- | Language profile for Disciple Core Tetra+module DDC.Core.Tetra.Profile+ ( profile+ , lexModuleString+ , lexExpString+ , freshT+ , freshX)+where+import DDC.Core.Tetra.Prim+import DDC.Core.Tetra.Env+import DDC.Core.Fragment+import DDC.Core.Lexer+import DDC.Type.Exp+import DDC.Data.Token+import Control.Monad.State.Strict+import DDC.Type.Env (Env)+import qualified DDC.Type.Env as Env++-- | Language profile for Disciple Core Flow.+profile :: Profile Name +profile+ = Profile+ { profileName = "Tetra"+ , profileFeatures = features+ , profilePrimDataDefs = primDataDefs+ , profilePrimSupers = primSortEnv+ , profilePrimKinds = primKindEnv+ , profilePrimTypes = primTypeEnv++ -- We don't need to distinguish been boxed and unboxed+ -- because we allow unboxed instantiation.+ , profileTypeIsUnboxed = const False }+++features :: Features+features + = Features+ { featuresTrackedEffects = True+ , featuresTrackedClosures = False+ , featuresFunctionalEffects = False+ , featuresFunctionalClosures = False+ , featuresPartialPrims = True+ , featuresPartialApplication = True+ , featuresGeneralApplication = True+ , featuresNestedFunctions = True+ , featuresDebruijnBinders = True+ , featuresUnboundLevel0Vars = False+ , featuresUnboxedInstantiation = True+ , featuresNameShadowing = True+ , featuresUnusedBindings = True+ , featuresUnusedMatches = True }+++-- | Lex a string to tokens, using primitive names.+--+-- The first argument gives the starting source line number.+lexModuleString :: String -> Int -> String -> [Token (Tok Name)]+lexModuleString sourceName lineStart str+ = map rn $ lexModuleWithOffside sourceName lineStart str+ where rn (Token strTok sp) + = case renameTok readName strTok of+ Just t' -> Token t' sp+ Nothing -> Token (KJunk "lexical error") sp+++-- | Lex a string to tokens, using primitive names.+--+-- The first argument gives the starting source line number.+lexExpString :: String -> Int -> String -> [Token (Tok Name)]+lexExpString sourceName lineStart str+ = map rn $ lexExp sourceName lineStart str+ where rn (Token strTok sp) + = case renameTok readName strTok of+ Just t' -> Token t' sp+ Nothing -> Token (KJunk "lexical error") sp+++-- | Create a new type variable name that is not in the given environment.+freshT :: Env Name -> Bind Name -> State Int Name+freshT env bb+ = do i <- get+ put (i + 1)+ let n = NameVar ("t" ++ show i)+ case Env.lookupName n env of+ Nothing -> return n+ _ -> freshT env bb+++-- | Create a new value variable name that is not in the given environment.+freshX :: Env Name -> Bind Name -> State Int Name+freshX env bb+ = do i <- get+ put (i + 1)+ let n = NameVar ("x" ++ show i)+ case Env.lookupName n env of+ Nothing -> return n+ _ -> freshX env bb
+ LICENSE view
@@ -0,0 +1,30 @@+--------------------------------------------------------------------------------+The Disciplined Disciple Compiler License (MIT style)++Copyrite (K) 2007-2013 The Disciplined Disciple Compiler Strike Force+All rights reversed.++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.++-------------------------------------------------------------------------------+Under Australian law copyright is free and automatic.+By contributing to DDC authors grant all rights they have regarding their+contributions to the other members of the Disciplined Disciple Compiler Strike+Force, past, present and future, as well as placing their contributions under+the above license.++Use "darcs show authors" to get a list of Strike Force members.++--------------------------------------------------------------------------------+Redistributions of libraries in ./external are governed by their own licenses:++ - TinyPTC GNU Lesser General Public License+
+ Setup.hs view
@@ -0,0 +1,2 @@+import Distribution.Simple+main = defaultMain
+ ddc-core-tetra.cabal view
@@ -0,0 +1,59 @@+Name: ddc-core-tetra+Version: 0.3.2.1+License: MIT+License-file: LICENSE+Author: The Disciplined Disciple Compiler Strike Force+Maintainer: Ben Lippmeier <benl@ouroborus.net>+Build-Type: Simple+Cabal-Version: >=1.6+Stability: experimental+Category: Compilers/Interpreters+Homepage: http://disciple.ouroborus.net+Synopsis: Disciplined Disciple Compiler intermediate language.+Description: Disciplined Disciple Compiler intermediate language+ with internalized effect judgement.++Library+ Build-Depends: + base == 4.6.*,+ deepseq == 1.3.*,+ containers == 0.5.*,+ array == 0.4.*,+ transformers == 0.3.*,+ mtl == 2.1.*,+ ddc-base == 0.3.2.*,+ ddc-core == 0.3.2.*,+ ddc-core-salt == 0.3.2.*,+ ddc-core-simpl == 0.3.2.*++ Exposed-modules:+ DDC.Core.Tetra++ DDC.Core.Tetra.Compounds+ DDC.Core.Tetra.Env+ DDC.Core.Tetra.Prim+ DDC.Core.Tetra.Profile++ Other-modules:+ DDC.Core.Tetra.Prim.Base+ DDC.Core.Tetra.Prim.OpPrimArith+ DDC.Core.Tetra.Prim.OpPrimRef+ DDC.Core.Tetra.Prim.TyConPrim+++ GHC-options:+ -Wall+ -fno-warn-orphans+ -fno-warn-missing-signatures+ -fno-warn-unused-do-bind++ Extensions:+ KindSignatures+ NoMonomorphismRestriction+ ScopedTypeVariables+ StandaloneDeriving+ PatternGuards+ ParallelListComp+ DeriveDataTypeable+ ViewPatterns+