packages feed

jacinda 1.1.0.0 → 1.2.0.0

raw patch · 15 files changed

+76/−71 lines, 15 filesdep ~arraydep ~bytestringdep ~containers

Dependency ranges changed: array, bytestring, containers, criterion, deepseq, directory, filepath, microlens, microlens-mtl, mtl, optparse-applicative, prettyprinter, recursion, regex-rure, silently, split, tasty, tasty-hunit, text, transformers, vector

Files

CHANGELOG.md view
@@ -1,3 +1,7 @@+# 1.2.0.0++  * `~`, `!~` builtins require that the regex be the second argument.+ # 1.1.0.0    * Add builtin for last field
doc/guide.pdf view

binary file changed (197934 → 198278 bytes)

examples/mtlCtx.jac view
@@ -1,6 +1,8 @@ {. finds any line matching /MonadState/ or /MonadError/ without {. an INLINABLE pragma on the preceding line +{. TODO val fpCtx ≔ line ~* 1 /\{-#.*INLINABLE\s+([a-z][A-Za-z0-9]*)#-\}/+ @include'lib/maybe.jac'  fn step(ctx, line) :=
+ examples/silly.jac view
@@ -0,0 +1,7 @@+fn count(x):=+  (+)|0 [:1"x;++let+  val ext := count {%/\{-#\s*LANGUAGE\s*(.*)#-\}/}{`0}+  val tot := count $0+in (ext.tot) end
jacinda.cabal view
@@ -1,6 +1,6 @@ cabal-version:      2.0 name:               jacinda-version:            1.1.0.0+version:            1.2.0.0 license:            AGPL-3 license-file:       COPYING maintainer:         vamchale@gmail.com@@ -73,7 +73,7 @@         microlens,         directory,         filepath,-        microlens-mtl,+        microlens-mtl >=0.1.8.0,         vector,         recursion >=1.0.0.0,         split@@ -105,7 +105,7 @@     build-depends:         base,         jacinda-lib,-        optparse-applicative,+        optparse-applicative >=0.13.0.0,         bytestring      if impl(ghc >=8.0)
man/ja.1 view
@@ -1,4 +1,4 @@-.\" Automatically generated by Pandoc 2.18+.\" Automatically generated by Pandoc 2.19.2 .\" .\" Define V font for inline verbatim, using C font in formats .\" that render this, and otherwise B font.@@ -63,6 +63,9 @@ .PP \f[B]#\f[R] Prefix operator: tally (count bytes in string) .TP+\f[B]#*\f[R] Prefix operator: list length+List a -> a+.TP \f[B],\f[R] Ternary operator: zip with (a -> b -> c) -> Stream a -> Stream b -> Stream c .TP@@ -99,10 +102,12 @@ \f[B]||\f[R] Boolean or .PP \f[B]!\f[R] Prefix boolean not-.PP+.TP \f[B]\[ti]\f[R] Matches regex-.PP+Str -> Regex -> Bool+.TP \f[B]!\[ti]\f[R] Does not match+Str -> Regex -> Bool .PP \f[B]ix\f[R] Line number .TP@@ -202,7 +207,7 @@ (+)|0 [:1\[dq]$0 Count lines .TP-[y]|0 {|ix}+[y]|> {|ix} Count lines .TP (+)|0 [#x+1]\[dq]$0@@ -216,6 +221,9 @@ .TP (&)|#t (>)\[rs]. {|\[ga]1:f} Is the first column strictly increasing?+.TP+[y]|> {|\[ga]0\[ti]/\[ha]$/}+Is the last line blank? .SH BUGS .PP Please report any bugs you may come across to
prelude/fn.jac view
@@ -30,3 +30,12 @@  fn head :=   ([[:x]|>);+<<<<<<< Updated upstream+=======++{. fold two on the same stream+fn foldTwo(op0, op1, seed0, seed1, stream) :=+  let+    val go := \acc. \line. (op0 (acc->1) line . op1 (acc->2) line)+  in go|(seed0.seed1) stream end;+>>>>>>> Stashed changes
src/Jacinda/AST.hs view
@@ -55,13 +55,12 @@ data TB = TyInteger         | TyFloat         | TyDate-        | TyStr+        | TyStr | TyR         | TyStream         | TyVec         | TyBool         | TyOption         | TyUnit-        -- TODO: tyRegex         -- TODO: convert float to int         deriving (Eq, Ord) @@ -95,6 +94,7 @@     pretty TyVec     = "List"     pretty TyOption  = "Optional"     pretty TyUnit    = "𝟙"+    pretty TyR       = "Regex"  instance Pretty (T a) where     pretty (TyB _ b)        = pretty b@@ -251,23 +251,20 @@          | RegexLit { eLoc :: a, eRr :: BS.ByteString }          | FloatLit { eLoc :: a, eFloat :: !Double }          | Lam { eLoc :: a, eBound :: Name a, lamE :: E a }-         | Dfn { eLoc :: a, eDfn :: E a } -- to be rewritten as a lambda...-         -- TODO: builtin sum type ? (makes pattern matching easier down the road)+         | Dfn { eLoc :: a, eDfn :: E a }          | BBuiltin { eLoc :: a, eBin :: BBin }          | TBuiltin { eLoc :: a, eTer :: BTer }          | UBuiltin { eLoc :: a, eUn :: BUn }          | NBuiltin { eLoc :: a, eNil :: N }          | Tup { eLoc :: a, esTup :: [E a] }          | ResVar { eLoc :: a, dfnVar :: DfnVar }-         | RegexCompiled RurePtr -- holds compiled regex (after normalization)+         | RegexCompiled RurePtr -- holds compiled regex after normalization          | Arr { eLoc :: a, elems :: V.Vector (E a) }          | Anchor { eLoc :: a, eAnchored :: [E a] }          | Paren { eLoc :: a, eExpr :: E a }          | OptionVal { eLoc :: a, eMaybe :: Maybe (E a) }          | Cond { eLoc :: a, eIf :: E a, eThen :: E a, eElse :: E a }-         -- TODO: regex literal          deriving (Functor, Generic)-         -- TODO: side effects: allow since it's strict?  instance Recursive (E a) where @@ -419,7 +416,6 @@        | IsPrintf        | HasField Int (T K)        | Witherable-       -- TODO: witherable        deriving (Eq, Ord)  instance Pretty C where
src/Jacinda/Backend/Normalize.hs view
@@ -18,8 +18,7 @@                                  ) where  import           Control.Exception          (Exception, throw)-import           Control.Monad.State.Strict (State, evalState, gets, modify, runState)-import           Data.Bifunctor             (second)+import           Control.Monad.State.Strict (State, evalState, gets, modify) import qualified Data.ByteString            as BS import qualified Data.ByteString.Char8      as ASCII import           Data.Foldable              (traverse_)@@ -98,9 +97,6 @@ mkLetCtx :: Int -> LetCtx mkLetCtx i = LetCtx IM.empty (Renames i IM.empty) -hoistEvalM :: Int -> EvalM a -> (a, Int)-hoistEvalM i = second (max_ . renames_) . flip runState (mkLetCtx i)- runEvalM :: Int          -> EvalM a          -> a@@ -182,14 +178,12 @@     eI <- eNorm e     eI' <- eNorm e'     pure $ case (eI, eI') of-        (RegexCompiled re, StrLit _ str) -> BoolLit tyBool (isMatch' re str)         (StrLit _ str, RegexCompiled re) -> BoolLit tyBool (isMatch' re str)         _                                -> EApp ty (EApp ty' op eI) eI' eNorm (EApp ty (EApp ty' op@(BBuiltin _ NotMatches) e) e') = do     eI <- eNorm e     eI' <- eNorm e'     pure $ case (eI, eI') of-        (RegexCompiled re, StrLit _ str) -> BoolLit tyBool (not $ isMatch' re str)         (StrLit _ str, RegexCompiled re) -> BoolLit tyBool (not $ isMatch' re str)         _                                -> EApp ty (EApp ty' op eI) eI' eNorm (EApp ty (EApp ty' op@(BBuiltin (TyArr _ (TyB _ TyInteger) _) Max) e) e') = do@@ -393,7 +387,7 @@ eNorm e@(Var _ (Name _ (Unique i) _)) = do     st <- gets binds     case IM.lookup i st of-        Just e'@Var{} -> eNorm e' -- no cyclic binds!!+        Just e'@Var{} -> eNorm e' -- no cyclic binds         Just e'       -> renameE e' -- FIXME: set outermost type to be type of var...         Nothing       -> pure e -- default to e in case var was bound in a lambda eNorm (EApp ty e@Var{} e') = eNorm =<< (EApp ty <$> eNorm e <*> pure e')@@ -471,24 +465,11 @@     case y' of         Arr _ es -> foldE f' x' es         _        -> pure $ EApp ty0 (EApp ty1 (EApp ty2 op f') x') y'--- eNorm (EApp ty0 (EApp ty1 op@(BBuiltin (TyArr _ _ (TyArr _ _ (TyApp _ (TyB _ TyVec) _))) Prior) x) y) = do-    -- x' <- eNorm x-    -- y' <- eNorm y-    -- case y' of-        -- Arr _ es -> Arr undefined <$> V.priorM (applyOp x') es-        -- _        -> pure $ EApp ty0 (EApp ty1 op x') y'--- eNorm (EApp ty0 (EApp ty1 (EApp ty2 op@(TBuiltin (TyArr _ _ (TyApp _ _ (TyApp _ (TyB _ TyVec) _))) ZipW) f) x) y) = do-    -- f' <- eNorm f-    -- x' <- eNorm x-    -- y' <- eNorm y-    -- case (x', y') of-        -- (Arr _ es, Arr _ es') -> Arr undefined <$> V.zipWithM (applyOp f') es es'-        -- _                     -> pure $ EApp ty0 (EApp ty1 (EApp ty2 op f') x') y' eNorm (EApp ty0 (EApp ty1 (EApp ty2 op@TBuiltin{} f) x) y) = EApp ty0 <$> (EApp ty1 <$> (EApp ty2 op <$> eNorm f) <*> eNorm x) <*> eNorm y -- we include this in case (+) has type (a->a->a) (for instance) if it is -- normalizing a decl (which can be ambiguous/general) eNorm (EApp ty0 (EApp ty1 op@BBuiltin{} e) e') = EApp ty0 <$> (EApp ty1 op <$> eNorm e) <*> eNorm e'--- FIXME: specialize types after inlining hm+-- FIXME: monomorphize types after inlining eNorm (EApp ty e@EApp{} e') =     eNorm =<< (EApp ty <$> eNorm e <*> pure e') eNorm (Arr ty es) = Arr ty <$> traverse eNorm es
src/Jacinda/Backend/TreeWalk.hs view
@@ -8,7 +8,6 @@  import           Control.Exception          (Exception, throw) import           Control.Monad.State.Strict (State, get, modify, runState)-import           Control.Recursion          (cata, embed) import           Data.Bifunctor             (bimap) import qualified Data.ByteString            as BS import           Data.Containers.ListUtils  (nubIntOn, nubOrdOn)@@ -24,7 +23,7 @@ import           Jacinda.AST import           Jacinda.Backend.Normalize import           Jacinda.Backend.Printf-import           Jacinda.Regex+import           Jacinda.Regex              (captures', find', findCapture, isMatch', splitBy, substr) import           Jacinda.Ty.Const import           Regex.Rure                 (RurePtr) @@ -37,7 +36,7 @@  instance Exception StreamError where -(!) :: Show a => V.Vector a -> Int -> a+(!) :: V.Vector a -> Int -> a v ! ix = case v V.!? ix of     Just x  -> x     Nothing -> throw $ IndexOutOfBounds ix@@ -76,8 +75,6 @@ asOpt (OptionVal _ e) = e asOpt e               = noRes e "Option" --- TODO: do I want to interleave state w/ eNorm or w/e- -- eval eEval :: (Int, BS.ByteString, V.Vector BS.ByteString) -- ^ Field context (for that line)       -> E (T K)@@ -124,16 +121,16 @@         let eI = go e             eI' = go e'         in case (eI, eI') of-            (RegexCompiled reϵ, StrLit _ strϵ) -> BoolLit tyBool (isMatch' reϵ strϵ)             (StrLit _ strϵ, RegexCompiled reϵ) -> BoolLit tyBool (isMatch' reϵ strϵ)-            _                                  -> noRes eI "Regex or Str"+            (StrLit{}, _)                      -> noRes eI' "Regex"+            _                                  -> noRes eI "Str"     go (EApp _ (EApp _ (BBuiltin _ NotMatches) e) e') =         let eI = go e             eI' = go e'         in case (eI, eI') of-            (RegexCompiled reϵ, StrLit _ strϵ) -> BoolLit tyBool (not $ isMatch' reϵ strϵ)             (StrLit _ strϵ, RegexCompiled reϵ) -> BoolLit tyBool (not $ isMatch' reϵ strϵ)-            _                                  -> noRes eI "Regex or Str"+            (StrLit{}, _)                      -> noRes eI' "Regex"+            _                                  -> noRes eI "Str"     go (EApp _ (EApp _ (BBuiltin _ Match) e) e') =         let eI = asRegex (go e)             eI' = asStr (go e')@@ -400,7 +397,7 @@     imap (\ix line -> eEval (mkCtx re ix line) e) ir re (Guarded _ pe e) =     -- TODO: normalize before stream-    fmap (uncurry (\ix line -> eEval (mkCtx re ix line) e)) . ifilter' (\ix line -> asBool (eEval (mkCtx re ix line) pe))+    fmap (\(ix, line) -> eEval (mkCtx re ix line) e) . ifilter' (\ix line -> asBool (eEval (mkCtx re ix line) pe)) ir re (EApp _ (EApp _ (BBuiltin _ Map) op) stream) = fmap (applyUn op) . ir re stream ir re (EApp _ (EApp _ (BBuiltin _ Filter) op) stream) =     filter (asBool . applyUn op) . ir re stream
src/Jacinda/File.hs view
@@ -69,7 +69,6 @@     a (RegexLitF _ rrϵ) = RegexCompiled (compileDefault rrϵ)     a (NBuiltinF _ Fp)  = mkStr fp     a x                 = embed x-    -- TODO: is cata performant enough?  compileIn :: FileBS -> Program (T K) -> Program (T K) compileIn fp (Program ds e) = Program (compileD fp <$> ds) (compileR fp e)@@ -102,7 +101,7 @@     (typed, i) <- yeetIO $ runTypeM m (tyProgram ast)     cont <- yeetIO $ runJac (compileFS (cliFS <|> getFS ast)) i (compileIn (ASCII.pack fp) typed)     cont $ fmap BSL.toStrict (ASCIIL.lines contents)-    -- see: BSL.split, BSL.splitWith+    -- TODO: BSL.split, BSL.splitWith for arbitrary record separators  runOnHandle :: [FilePath]             -> BSL.ByteString -- ^ Program
src/Jacinda/Parser.y view
@@ -309,12 +309,10 @@  data ParseError a = Unexpected (Token a)                   | LexErr String-                  | NoImpl (Name a)  instance Pretty a => Pretty (ParseError a) where     pretty (Unexpected tok)  = pretty (loc tok) <+> "Unexpected" <+> pretty tok     pretty (LexErr str)      = pretty (T.pack str)-    pretty (NoImpl n)        = pretty (Name.loc n) <+> "Signature for" <+> pretty n <+> "is not accompanied by an implementation"  instance Pretty a => Show (ParseError a) where     show = show . pretty@@ -327,7 +325,7 @@ parse = fmap snd . runParse parseF  parseWithMax :: BSL.ByteString -> Either (ParseError AlexPosn) (Int, File)-parseWithMax = fmap (first fst3) . parseWithInitCtx+parseWithMax = fmap (first fst3) . runParse parseF     where fst3 (x, _, _) = x  parseWithInitCtx :: BSL.ByteString -> Either (ParseError AlexPosn) (AlexUserState, File)
src/Jacinda/Rename.hs view
@@ -91,8 +91,6 @@ mkLam :: [Name a] -> E a -> E a mkLam ns e = foldr (\n -> Lam (loc n) n) e ns --- TODO: investigate performance w/out cata- -- | A dfn could be unary or binary - here we guess if it is binary hasY :: E a -> Bool hasY = cata a where
src/Jacinda/Ty.hs view
@@ -79,6 +79,9 @@ addVarEnv :: Int -> T K -> TyState a -> TyState a addVarEnv i ty (TyState u k cvs v cs) = TyState u k cvs (IM.insert i ty v) cs +addKindEnv :: Int -> K -> TyState a -> TyState a+addKindEnv i k (TyState u ks cvs v cs) = TyState u (IM.insert i k ks) cvs v cs+ addConstraint :: Ord a => (a, T K, T K) -> TyState a -> TyState a addConstraint c (TyState u k cvs v cs) = TyState u k cvs v (S.insert c cs) @@ -130,7 +133,7 @@     | length tys == length tys' = unifyPrep um (zip3 (repeat l) tys tys' ++ tyss)     | otherwise = throwError (UnificationFailed l (void ty) (void ty')) unifyMatch um ((_, TyVar _ n@(Name _ (Unique k) _), ty@(TyVar _ n')):tys)-    | n == n' = unifyPrep um tys -- a type variable is always equal to itself, don't bother inserting this!+    | n == n' = unifyPrep um tys     | otherwise = IM.insert k ty <$> unifyPrep (IM.insert k ty um) tys unifyMatch _ ((l, ty, ty'):_) = throwError (UnificationFailed l (void ty) (void ty')) @@ -166,14 +169,16 @@     Name n (Unique $ st+1) k         <$ modify (mapMaxU (+1)) +namek :: Name K -> TypeM a (Name K)+namek n =+    modify (addKindEnv (unUnique$unique n) (loc n)) $> n+ higherOrder :: T.Text -> TypeM a (Name K)-higherOrder t = freshName t (KArr Star Star)--- TODO: this should modify kind environment+higherOrder t = freshName t (KArr Star Star) >>= namek  -- of kind 'Star' dummyName :: T.Text -> TypeM a (Name K)-dummyName n = freshName n Star--- TODO: this should modify kind environment+dummyName n = freshName n Star >>= namek  addC :: Ord a => Name b -> (C, a) -> IM.IntMap (S.Set (C, a)) -> IM.IntMap (S.Set (C, a)) addC (Name _ (Unique i) _) c = IM.alter (Just . go) i where@@ -255,9 +260,9 @@                       | otherwise        -> throwError $ Expected (tLoc ty1) k0         k0                               -> throwError $ Expected (KArr Star Star) k0 --- TODO: this will need some class context if we permit custom types (Optional) checkType :: Ord a => T K -> (C, a) -> TypeM a () checkType TyVar{} _                            = pure () -- TODO: I think this is right+checkType (TyB _ TyR) (IsSemigroup, _)         = pure () checkType (TyB _ TyStr) (IsSemigroup, _)       = pure () checkType (TyB _ TyInteger) (IsSemigroup, _)   = pure () checkType (TyB _ TyInteger) (IsNum, _)         = pure ()@@ -348,7 +353,7 @@ checkAmb e@(UBuiltin ty _) | isAmbiguous ty = throwError $ Ambiguous ty (void e) checkAmb (Implicit _ e') = checkAmb e' checkAmb (Guarded _ p e') = checkAmb p *> checkAmb e'-checkAmb (EApp _ e' e'') = checkAmb e' *> checkAmb e'' -- more precise errors, don't fail yet! (if they aren't ambiguous, it shouldn't be+checkAmb (EApp _ e' e'') = checkAmb e' *> checkAmb e'' -- more precise errors, don't fail yet! checkAmb (Tup _ es) = traverse_ checkAmb es checkAmb e@(Arr ty _) | isAmbiguous ty = throwError $ Ambiguous ty (void e) checkAmb e@(Var ty _) | isAmbiguous ty = throwError $ Ambiguous ty (void e)@@ -420,7 +425,7 @@ tyE0 (IntLit _ i)            = pure $ IntLit tyI i tyE0 (FloatLit _ f)          = pure $ FloatLit tyF f tyE0 (StrLit _ str)          = pure $ StrLit tyStr str-tyE0 (RegexLit _ rr)         = pure $ RegexLit tyStr rr+tyE0 (RegexLit _ rr)         = pure $ RegexLit tyR rr tyE0 (Column _ i)            = pure $ Column (tyStream tyStr) i tyE0 (IParseCol _ i)         = pure $ IParseCol (tyStream tyI) i tyE0 (FParseCol _ i)         = pure $ FParseCol (tyStream tyF) i@@ -442,16 +447,16 @@ tyE0 (BBuiltin l Neq)        = BBuiltin <$> tyEq l <*> pure Neq tyE0 (BBuiltin l Min)        = BBuiltin <$> tyM l <*> pure Min tyE0 (BBuiltin l Max)        = BBuiltin <$> tyM l <*> pure Max-tyE0 (BBuiltin _ Split)      = pure $ BBuiltin (tyArr tyStr (tyArr tyStr (mkVec tyStr))) Split+tyE0 (BBuiltin _ Split)      = pure $ BBuiltin (tyArr tyStr (tyArr tyR (mkVec tyStr))) Split tyE0 (BBuiltin _ Splitc)     = pure $ BBuiltin (tyArr tyStr (tyArr tyStr (mkVec tyStr))) Splitc-tyE0 (BBuiltin _ Matches)    = pure $ BBuiltin (tyArr tyStr (tyArr tyStr tyBool)) Matches-tyE0 (BBuiltin _ NotMatches) = pure $ BBuiltin (tyArr tyStr (tyArr tyStr tyBool)) NotMatches+tyE0 (BBuiltin _ Matches)    = pure $ BBuiltin (tyArr tyStr (tyArr tyR tyBool)) Matches+tyE0 (BBuiltin _ NotMatches) = pure $ BBuiltin (tyArr tyStr (tyArr tyR tyBool)) NotMatches tyE0 (UBuiltin _ Tally)      = pure $ UBuiltin (tyArr tyStr tyI) Tally tyE0 (BBuiltin _ Div)        = pure $ BBuiltin (tyArr tyF (tyArr tyF tyF)) Div tyE0 (UBuiltin _ Not)        = pure $ UBuiltin (tyArr tyBool tyBool) Not tyE0 (BBuiltin _ And)        = pure $ BBuiltin (tyArr tyBool (tyArr tyBool tyBool)) And tyE0 (BBuiltin _ Or)         = pure $ BBuiltin (tyArr tyBool (tyArr tyBool tyBool)) Or-tyE0 (BBuiltin _ Match)      = pure $ BBuiltin (tyArr tyStr (tyArr tyStr (tyOpt $ TyTup Star [tyI, tyI]))) Match+tyE0 (BBuiltin _ Match)      = pure $ BBuiltin (tyArr tyStr (tyArr tyR (tyOpt $ TyTup Star [tyI, tyI]))) Match tyE0 (TBuiltin _ Substr)     = pure $ TBuiltin (tyArr tyStr (tyArr tyI (tyArr tyI tyStr))) Substr tyE0 (UBuiltin _ IParse)     = pure $ UBuiltin (tyArr tyStr tyI) IParse tyE0 (UBuiltin _ FParse)     = pure $ UBuiltin (tyArr tyStr tyF) FParse@@ -549,7 +554,6 @@         fTy = tyArr (tyArr a' b') (tyArr (hkt f' a') (hkt f' b'))     modify (mapClassVars (addC f (Functor, l)))     pure $ BBuiltin fTy Map--- (b -> a -> b) -> b -> Stream a -> b tyE0 (TBuiltin l Fold) = do     b <- dummyName "b"     a <- dummyName "a"@@ -569,7 +573,7 @@     modify (mapClassVars (addC f (Foldable, l)))     pure $ BBuiltin fTy Fold1 tyE0 (TBuiltin _ Captures) =-    pure $ TBuiltin (tyArr tyStr (tyArr tyI (tyArr tyStr (tyOpt tyStr)))) Captures+    pure $ TBuiltin (tyArr tyStr (tyArr tyI (tyArr tyR (tyOpt tyStr)))) Captures -- (a -> a -> a) -> Stream a -> Stream a tyE0 (BBuiltin _ Prior) = do     a <- dummyName "a"@@ -604,11 +608,10 @@         fTy = tyArr b' (tyArr (tyArr a' b') (tyArr (tyOpt a') b'))     pure $ TBuiltin fTy Option tyE0 (TBuiltin _ AllCaptures) =-    pure $ TBuiltin (tyArr tyStr (tyArr tyI (tyArr tyStr (mkVec tyStr)))) AllCaptures+    pure $ TBuiltin (tyArr tyStr (tyArr tyI (tyArr tyR (mkVec tyStr)))) AllCaptures tyE0 (Implicit _ e) = do     e' <- tyE0 e     pure $ Implicit (tyStream (eLoc e')) e'--- (a -> b -> c) -> Stream a -> Stream b -> Stream c tyE0 (Guarded l e streamE) = do     streamE' <- tyE0 streamE     e' <- tyE0 e
src/Jacinda/Ty/Const.hs view
@@ -1,5 +1,5 @@ module Jacinda.Ty.Const ( tyStream-                        , tyStr+                        , tyStr, tyR                         , tyI                         , tyF                         , tyBool@@ -25,6 +25,9 @@  tyStr :: T K tyStr = TyB Star TyStr++tyR :: T K+tyR = TyB Star TyR  hkt :: T K -> T K -> T K hkt = TyApp Star