fcf-containers 0.4.0 → 0.5.0

raw patch · 11 files changed

+329/−569 lines, 11 filesdep ~first-class-familiesPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: first-class-families

API changes (from Hackage documentation)

Files

• CHANGELOG.md +7/−0
• default.nix +6/−6
• fcf-containers.cabal +4/−4
• src/Fcf/Alg/List.hs +7/−253
• src/Fcf/Alg/Sort.hs +3/−2
• src/Fcf/Alg/Symbol.hs +251/−0
• src/Fcf/Data/MapC.hs +11/−11
• src/Fcf/Data/NatMap.hs +14/−15
• src/Fcf/Data/Set.hs +1/−1
• src/Fcf/Data/Symbol.hs +0/−250
• src/Fcf/Data/Text.hs +25/−27

@@ -1,4 +1,11 @@ +# 0.5.0++20200323++ - start using version 0.8.0 of first-class-families+ - a documentation fix+ # 0.4.0  20200216

@@ -16,17 +16,17 @@           # });           first-class-families = self.callCabal2nix "first-class-families"            #   ~/gito/first-class-families {}; -            (pkgs.fetchFromGitHub { # 0.7+            (pkgs.fetchFromGitHub { # 0.8               owner  = "Lysxia";               repo   = "first-class-families";-              rev    = "120e41ea3831b9ffad62239e109c1b2a0aaf269f";-              sha256 = "0pyxpnkgr2rgn83whl37jh7k3rdr5hiprdmfkswwj7c1nhl1ky5i";+              rev    = "4a0bf3ea9c125bb4009b61ce70b1a5339b7b2072";+              sha256 = "14387mpfvds226iynkpay3aaqamvxznxjsmg2qcwdxafdvxmyq9z";             }) {};-            # (pkgs.fetchFromGitHub { # 0.6 TODO remove this+            # (pkgs.fetchFromGitHub { # 0.7             #   owner  = "Lysxia";             #   repo   = "first-class-families";-            #   rev    = "2fb77468d3b0ce64dc5371bed1b636d60219975c";-            #   sha256 = "1jvn11nbb7271hhy7q21cyn4r238pfzj00aabd39gwhi0g2gzqbf";+            #   rev    = "120e41ea3831b9ffad62239e109c1b2a0aaf269f";+            #   sha256 = "0pyxpnkgr2rgn83whl37jh7k3rdr5hiprdmfkswwj7c1nhl1ky5i";             # }) {};         };       };

@@ -6,7 +6,7 @@     contents of containers-package and show how these can be used. Everything is     based on the ideas given in the first-class-families -package. Homepage:            https://github.com/gspia/fcf-containers-Version:             0.4.0+Version:             0.5.0 Build-type:          Simple Author:              gspia Maintainer:          iahogsp@gmail.com@@ -24,14 +24,14 @@                    , Fcf.Data.NatMap                    , Fcf.Data.Tree                    , Fcf.Data.Set-                   , Fcf.Data.Symbol                    , Fcf.Data.Text                    , Fcf.Alg.List                    , Fcf.Alg.Sort+                   , Fcf.Alg.Symbol                    , Fcf.Alg.Tree                    , Fcf.Alg.Morphism   build-depends:     base >= 4.9 && < 4.14-                   , first-class-families >= 0.7 && < 0.8+                   , first-class-families >= 0.8 && < 0.9   ghc-options:      -Wall   default-language:  Haskell2010   -- ghc-options:@@ -58,10 +58,10 @@   default-language: Haskell2010   other-modules:    Fcf.Alg.Morphism                   , Fcf.Alg.List+                  , Fcf.Alg.Symbol                   , Fcf.Data.Tree                   , Fcf.Data.MapC                   , Fcf.Data.Set-                  , Fcf.Data.Symbol                   , Fcf.Data.Text   build-depends:    base                   , first-class-families

@@ -29,13 +29,12 @@  import qualified GHC.TypeLits as TL -import           Fcf.Core (Eval, Exp, type (@@))-import           Fcf.Classes (Map)-import           Fcf.Combinators (type (=<<), type (<=<), Pure)-import           Fcf.Data.List (Foldr, Concat, TakeWhile, DropWhile, Reverse-                               , type (++), ZipWith, Elem, Take, Unfoldr)+import           Fcf.Core (Eval, Exp)+import           Fcf.Class.Foldable (And)+import           Fcf.Class.Functor (FMap)+import           Fcf.Combinators (type (=<<), Pure)+import           Fcf.Data.List (Foldr, Reverse, ZipWith, Elem, Take, Unfoldr) import           Fcf.Utils (If, TyEq)-import           Fcf.Data.Bool (type (&&), type  (||), Not) import           Fcf.Data.Nat  import           Fcf.Alg.Morphism@@ -53,8 +52,8 @@ data ListF a b = ConsF a b | NilF  -- We need a functor instance for Cata and Ana to work.-type instance Eval (Map f 'NilF) = 'NilF-type instance Eval (Map f ('ConsF a b)) = 'ConsF a (Eval (f b))+type instance Eval (FMap f 'NilF) = 'NilF+type instance Eval (FMap f ('ConsF a b)) = 'ConsF a (Eval (f b))  -------------------------------------------------------------------------------- @@ -222,251 +221,6 @@  -------------------------------------------------------------------------------- --- | Partition--- --- === __Example__--- --- >>> :kind! Eval (Fcf.Alg.List.Partition ((>=) 35) '[ 20, 30, 40, 50])--- Eval (Fcf.Alg.List.Partition ((>=) 35) '[ 20, 30, 40, 50]) :: ([Nat],---                                                                [Nat])--- = '( '[20, 30], '[40, 50])-data Partition :: (a -> Exp Bool) -> [a] -> Exp ([a],[a])-type instance Eval (Partition p lst) = Eval (Foldr (PartHelp p) '( '[], '[]) lst)---- helper-data PartHelp :: (a -> Exp Bool) -> a -> ([a],[a]) -> Exp ([a],[a])-type instance Eval (PartHelp p a '(xs,ys)) =-    If (Eval (p a))-        '(a ': xs, ys)-        '(xs, a ': ys)---- | Intersperse for type-level lists.------ === __Example__--- --- >>> :kind! Eval (Intersperse 0 '[1,2,3,4])--- Eval (Intersperse 0 '[1,2,3,4]) :: [Nat]--- = '[1, 0, 2, 0, 3, 0, 4]-data Intersperse :: a -> [a] -> Exp [a]-type instance Eval (Intersperse _   '[]      ) = '[]-type instance Eval (Intersperse sep (x ': xs)) = x ': Eval (PrependToAll sep xs)---- helper for Intersperse-data PrependToAll :: a -> [a] -> Exp [a]-type instance Eval (PrependToAll _   '[]      ) = '[]-type instance Eval (PrependToAll sep (x ': xs)) = sep ': x ': Eval (PrependToAll sep xs)---- | Intercalate for type-level lists.--- --- === __Example__--- --- >>> :kind! Eval (Intercalate '[", "] '[ '["Lorem"], '["ipsum"], '["dolor"] ])--- Eval (Intercalate '[", "] '[ '["Lorem"], '["ipsum"], '["dolor"] ]) :: [TL.Symbol]--- = '["Lorem", ", ", "ipsum", ", ", "dolor"]-data Intercalate :: [a] -> [[a]] -> Exp [a]-type instance Eval (Intercalate xs xss) = Eval (Concat =<< Intersperse xs xss)----- | 'Span', applied to a predicate @p@ and a type-level list @xs@, returns a --- type-level tuple where--- first element is longest prefix (possibly empty) of @xs@ of elements that--- satisfy @p@ and second element is the remainder of the list:------ === __Example__--- --- >>> :kind! Eval (Span (Flip (<) 3) '[1,2,3,4,1,2,3,4])--- Eval (Span (Flip (<) 3) '[1,2,3,4,1,2,3,4]) :: ([Nat], [Nat])--- = '( '[1, 2], '[3, 4, 1, 2, 3, 4])------ >>> :kind! Eval (Span (Flip (<) 9) '[1,2,3])--- Eval (Span (Flip (<) 9) '[1,2,3]) :: ([Nat], [Nat])--- = '( '[1, 2, 3], '[])------ >>> :kind! Eval (Span (Flip (<) 0) '[1,2,3])--- Eval (Span (Flip (<) 0) '[1,2,3]) :: ([Nat], [Nat])--- = '( '[], '[1, 2, 3])-data Span :: (a -> Exp Bool) -> [a] -> Exp ([a],[a])-type instance Eval (Span p lst) = '( Eval (TakeWhile p lst), Eval (DropWhile p lst))----- | 'Break', applied to a predicate @p@ and a type-level list @xs@, returns a --- type-level tuple where--- first element is longest prefix (possibly empty) of @xs@ of elements that--- /do not satisfy/ @p@ and second element is the remainder of the list:------ === __Example__--- --- >>> :kind! Eval (Break (Flip (>) 3) '[1,2,3,4,1,2,3,4])--- Eval (Break (Flip (>) 3) '[1,2,3,4,1,2,3,4]) :: ([Nat], [Nat])--- = '( '[1, 2, 3], '[4, 1, 2, 3, 4])------ >>> :kind! Eval (Break (Flip (<) 9) '[1,2,3])--- Eval (Break (Flip (<) 9) '[1,2,3]) :: ([Nat], [Nat])--- = '( '[], '[1, 2, 3])------ >>> :kind! Eval (Break (Flip (>) 9) '[1,2,3])--- Eval (Break (Flip (>) 9) '[1,2,3]) :: ([Nat], [Nat])--- = '( '[1, 2, 3], '[])-data Break :: (a -> Exp Bool) -> [a] -> Exp ([a],[a])-type instance Eval (Break p lst) = Eval (Span (Not <=< p) lst)----- | IsPrefixOf takes two type-level lists and returns true--- iff the first list is a prefix of the second.------ === __Example__--- --- >>> :kind! Eval (IsPrefixOf '[0,1,2] '[0,1,2,3,4,5])--- Eval (IsPrefixOf '[0,1,2] '[0,1,2,3,4,5]) :: Bool--- = 'True------ >>> :kind! Eval (IsPrefixOf '[0,1,2] '[0,1,3,2,4,5])--- Eval (IsPrefixOf '[0,1,2] '[0,1,3,2,4,5]) :: Bool--- = 'False------ >>> :kind! Eval (IsPrefixOf '[] '[0,1,3,2,4,5])--- Eval (IsPrefixOf '[] '[0,1,3,2,4,5]) :: Bool--- = 'True------ >>> :kind! Eval (IsPrefixOf '[0,1,3,2,4,5] '[])--- Eval (IsPrefixOf '[0,1,3,2,4,5] '[]) :: Bool--- = 'False-data IsPrefixOf :: [a] -> [a] -> Exp Bool-type instance Eval (IsPrefixOf xs ys) = IsPrefixOf_ xs ys---- helper for IsPrefixOf-type family IsPrefixOf_ (xs :: [a]) (ys :: [a]) :: Bool where-    IsPrefixOf_ '[] _ = 'True-    IsPrefixOf_ _ '[] = 'False-    IsPrefixOf_ (x ': xs) (y ': ys) =-         Eval ((Eval (TyEq x y)) && IsPrefixOf_ xs ys)----- | IsSuffixOf take two type-level lists and returns true--- iff the first list is a suffix of the second.------ === __Example__--- --- >>> :kind! Eval (IsSuffixOf '[3,4,5] '[0,1,2,3,4,5])--- Eval (IsSuffixOf '[3,4,5] '[0,1,2,3,4,5]) :: Bool--- = 'True------ >>> :kind! Eval (IsSuffixOf '[3,4,5] '[0,1,3,2,4,5])--- Eval (IsSuffixOf '[3,4,5] '[0,1,3,2,4,5]) :: Bool--- = 'False------ >>> :kind! Eval (IsSuffixOf '[] '[0,1,3,2,4,5])--- Eval (IsSuffixOf '[] '[0,1,3,2,4,5]) :: Bool--- = 'True------ >>> :kind! Eval (IsSuffixOf '[0,1,3,2,4,5] '[])--- Eval (IsSuffixOf '[0,1,3,2,4,5] '[]) :: Bool--- = 'False-data IsSuffixOf :: [a] -> [a] -> Exp Bool-type instance Eval (IsSuffixOf xs ys) =-    Eval (IsPrefixOf (Reverse @@ xs) (Reverse @@ ys))----- | IsInfixOf take two type-level lists and returns true--- iff the first list is a infix of the second.------ === __Example__--- --- >>> :kind! Eval (IsInfixOf '[2,3,4]  '[0,1,2,3,4,5,6])--- Eval (IsInfixOf '[2,3,4]  '[0,1,2,3,4,5,6]) :: Bool--- = 'True------ >>> :kind! Eval (IsInfixOf '[2,4,4]  '[0,1,2,3,4,5,6])--- Eval (IsInfixOf '[2,4,4]  '[0,1,2,3,4,5,6]) :: Bool--- = 'False-data IsInfixOf :: [a] -> [a] -> Exp Bool-type instance Eval (IsInfixOf xs ys) = Eval (Any (IsPrefixOf xs) =<< Tails ys)----- | Tails--- --- === __Example__--- --- >>> :kind! Eval (Tails '[0,1,2,3])--- Eval (Tails '[0,1,2,3]) :: [[Nat]]--- = '[ '[0, 1, 2, 3], '[1, 2, 3], '[2, 3], '[3]]-data Tails :: [a] -> Exp [[a]]-type instance Eval (Tails '[]) = '[]-type instance Eval (Tails (a ': as)) = (a ': as) ': Eval (Tails as)--------------------------------------------------------------------------------------- | Give true if all of the booleans in the list are true.------ === __Example__--- --- >>> :kind! Eval (And '[ 'True, 'True])--- Eval (And '[ 'True, 'True]) :: Bool--- = 'True------ >>> :kind! Eval (And '[ 'True, 'True, 'False])--- Eval (And '[ 'True, 'True, 'False]) :: Bool--- = 'False-data And :: [Bool] -> Exp Bool-type instance Eval (And lst) = Eval (Foldr (&&) 'True lst)----- | Type-level All.------ === __Example__------ >>> :kind! Eval (All (Flip (<) 6) '[0,1,2,3,4,5])--- Eval (All (Flip (<) 6) '[0,1,2,3,4,5]) :: Bool--- = 'True------ >>> :kind! Eval (All (Flip (<) 5) '[0,1,2,3,4,5])--- Eval (All (Flip (<) 5) '[0,1,2,3,4,5]) :: Bool--- = 'False-data All :: (a -> Exp Bool) -> [a] -> Exp Bool-type instance Eval (All p lst) = Eval (And =<< Map p lst)----- | Give true if any of the booleans in the list is true.------ === __Example__--- --- >>> :kind! Eval (Or '[ 'True, 'True])--- Eval (Or '[ 'True, 'True]) :: Bool--- = 'True--- --- >>> :kind! Eval (Or '[ 'False, 'False])--- Eval (Or '[ 'False, 'False]) :: Bool--- = 'False-data Or :: [Bool] -> Exp Bool-type instance Eval (Or lst) = Eval (Foldr (||) 'False lst)----- | Type-level Any.------ === __Example__--- --- >>> :kind! Eval (Any (Flip (<) 5) '[0,1,2,3,4,5])--- Eval (Any (Flip (<) 5) '[0,1,2,3,4,5]) :: Bool--- = 'True------ >>> :kind! Eval (Any (Flip (<) 0) '[0,1,2,3,4,5])--- Eval (Any (Flip (<) 0) '[0,1,2,3,4,5]) :: Bool--- = 'False-data Any :: (a -> Exp Bool) -> [a] -> Exp Bool-type instance Eval (Any p lst) = Eval (Or =<< Map p lst)-------------------------------------------------------------------------------------- | Snoc for type-level lists.------ === __Example__--- --- >>> :kind! Eval (Snoc '[1,2,3] 4)--- Eval (Snoc '[1,2,3] 4) :: [Nat]--- = '[1, 2, 3, 4]-data Snoc :: [a] -> a -> Exp [a]-type instance Eval (Snoc lst a) = Eval (lst ++ '[a])  -- | ToList for type-level lists. --

@@ -28,12 +28,13 @@                      , Flip, Not, TyEq, Pure ) import           Fcf.Data.List ( ZipWith, Filter, type (++) ) import           Fcf.Data.Nat (Nat)+import           Fcf.Data.Symbol (Symbol)  --------------------------------------------------------------------------------  import           Fcf.Alg.Tree (BTreeF(..)) import           Fcf.Alg.Morphism-import           Fcf.Data.Symbol (Symbol, SymbolOrd)+import           Fcf.Alg.Symbol (SymbolOrd)  -------------------------------------------------------------------------------- @@ -41,7 +42,7 @@  -- $setup -- >>> import qualified Fcf.Data.Nat as N ( type (<) )--- >>> import qualified Fcf.Data.Symbol as S ( type (<) )+-- >>> import qualified Fcf.Alg.Symbol as S ( type (<) )  -------------------------------------------------------------------------------- 

@@ -0,0 +1,251 @@+{-# LANGUAGE DataKinds              #-}+{-# LANGUAGE PolyKinds              #-}+{-# LANGUAGE TypeFamilies           #-}+{-# LANGUAGE TypeInType             #-}+{-# LANGUAGE TypeOperators          #-}+{-# LANGUAGE UndecidableInstances   #-}+{-# OPTIONS_GHC -Wall                       #-}+{-# OPTIONS_GHC -Werror=incomplete-patterns #-}++{-|+Module      : Fcf.Alg.Symbol+Description : Type level symbols+Copyright   : (c) gspia 2020-+License     : BSD+Maintainer  : gspia++= Fcf.Alg.Symbol++Type-level symbols and functions for them.++Note that the operators from this module conflict with "GHC.TypeLits".+++TODO: Would this whole module have a place first-class-families?++-}++--------------------------------------------------------------------------------++module Fcf.Alg.Symbol+    ( -- * Reexported type+      -- | From "Fcf.Data.Symbol" (which is from GHC).++      module X++      -- * Functions++    , Append+    , Intercalate+    , IsSpace+    , IsNewLine+    , IsTab+    , IsSpaceDelim+    , IsDigit++     -- * Comparison functions++    , SymbolOrd+    , type (<=)+    , type (>=)+    , type (<)+    , type (>)+    , type (==)+    )+  where++--------------------------------------------------------------------------------+        +import           GHC.TypeLits (Symbol)+import qualified GHC.TypeLits as TL++import           Fcf.Core (Eval, Exp)+import           Fcf.Data.List (Foldr, Elem)+import           Fcf.Data.Bool (type (||))+import           Fcf.Data.Symbol as X+import           Fcf.Utils (TyEq)++import           Fcf.Combinators (type (=<<))++--------------------------------------------------------------------------------++-- | Append two type-level symbols.+--+-- === __Example__+-- +-- >>> :kind! Eval (Append "hmm" " ok")+-- Eval (Append "hmm" " ok") :: Symbol+-- = "hmm ok"+data Append :: Symbol -> Symbol -> Exp Symbol+type instance Eval (Append s1 s2) = TL.AppendSymbol s1 s2+++-- | Intercalate type-level symbols.+-- +-- === __Example__+-- +-- >>> :kind! Eval (Intercalate "+" '["aa", "bb", "cc"])+-- Eval (Intercalate "+" '["aa", "bb", "cc"]) :: Symbol+-- = "aa+bb+cc"+--+-- >>> :kind! Eval (Intercalate "+" '["aa"])+-- Eval (Intercalate "+" '["aa"]) :: Symbol+-- = "aa"+--+-- >>> :kind! Eval (Intercalate "+" '[])+-- Eval (Intercalate "+" '[]) :: Symbol+-- = ""+data Intercalate :: Symbol -> [Symbol] -> Exp Symbol+type instance Eval (Intercalate s1 '[]) = ""+type instance Eval (Intercalate s1 (s ': sLst)) =+    Eval (Append s =<< Foldr (InterCalHelp s1) "" sLst)++-- helper+data InterCalHelp :: Symbol -> Symbol -> Symbol -> Exp Symbol+type instance Eval (InterCalHelp s s1 s2) = Eval (Append (Eval (Append s s1)) s2)+++-- | IsSpace+--+-- === __Example__+-- +-- >>> :kind! Eval (IsSpace "a")+-- Eval (IsSpace "a") :: Bool+-- = 'False+--+-- >>> :kind! Eval (IsSpace " ")+-- Eval (IsSpace " ") :: Bool+-- = 'True+data IsSpace :: Symbol -> Exp Bool+type instance Eval (IsSpace s) = Eval (s == " ")+++-- | IsNewline+--+-- === __Example__+-- +-- >>> :kind! Eval (IsNewLine "a")+-- Eval (IsNewLine "a") :: Bool+-- = 'False+--+-- >>> :kind! Eval (IsNewLine "\n")+-- Eval (IsNewLine "\n") :: Bool+-- = 'True+data IsNewLine :: Symbol -> Exp Bool+type instance Eval (IsNewLine s) = Eval (s == "\n")+++-- | IsTab+--+-- === __Example__+-- +-- >>> :kind! Eval (IsTab "a")+-- Eval (IsTab "a") :: Bool+-- = 'False+--+-- >>> :kind! Eval (IsTab "\t")+-- Eval (IsTab "\t") :: Bool+-- = 'True+data IsTab :: Symbol -> Exp Bool+type instance Eval (IsTab s) = Eval (s == "\t")+++-- | IsSpaceDelim+--+-- === __Example__+-- +-- >>> :kind! Eval (IsSpaceDelim "a")+-- Eval (IsSpaceDelim "a") :: Bool+-- = 'False+--+-- >>> :kind! Eval (IsSpaceDelim "\n")+-- Eval (IsSpaceDelim "\n") :: Bool+-- = 'True+data IsSpaceDelim :: Symbol -> Exp Bool+type instance Eval (IsSpaceDelim s) =+    Eval (Eval (IsSpace s) || (Eval (Eval (IsNewLine s) || Eval (IsTab s))))+++-- | IsDigit+--+-- === __Example__+-- +-- >>> :kind! Eval (IsDigit "3")+-- Eval (IsDigit "3") :: Bool+-- = 'True+--+-- >>> :kind! Eval (IsDigit "a")+-- Eval (IsDigit "a") :: Bool+-- = 'False+data IsDigit :: Symbol -> Exp Bool+type instance Eval (IsDigit s)+    = Eval (Elem s '["0","1","2","3","4","5","6","7","8","9"])++++--------------------------------------------------------------------------------+++-- | SymbolOrd - compare two symbols and give type-level Ordering +-- ( $ 'LT $, $ 'EQ $ or $ 'GT $ ).+--+-- === __Example__+-- +-- >>> :kind! Eval (SymbolOrd "a" "b")+-- Eval (SymbolOrd "a" "b") :: Ordering+-- = 'LT+data SymbolOrd :: Symbol -> Symbol -> Exp Ordering+type instance Eval (SymbolOrd a b) = TL.CmpSymbol a b++-- | Less-than-or-equal comparison for symbols.+-- +-- === __Example__+-- +-- >>> :kind! Eval ("b" <= "a")+-- Eval ("b" <= "a") :: Bool+-- = 'False+--+data (<=) :: Symbol -> Symbol -> Exp Bool+type instance Eval ((<=) a b) =+    Eval (Eval (TyEq (TL.CmpSymbol a b) 'LT) || Eval (TyEq (TL.CmpSymbol a b) 'EQ))++-- | Larger-than-or-equal comparison for symbols.+-- +-- === __Example__+-- +-- >>> :kind! Eval ("b" >= "a")+-- Eval ("b" >= "a") :: Bool+-- = 'True+data (>=) :: Symbol -> Symbol -> Exp Bool+type instance Eval ((>=) a b) =+    Eval (Eval (TyEq (TL.CmpSymbol a b) 'GT) || Eval (TyEq (TL.CmpSymbol a b) 'EQ))++-- | Less-than comparison for symbols.+-- +-- === __Example__+-- +-- >>> :kind! Eval ("a" < "b")+-- Eval ("a" < "b") :: Bool+-- = 'True+data (<) :: Symbol -> Symbol -> Exp Bool+type instance Eval ((<) a b) = Eval (TyEq (TL.CmpSymbol a b) 'LT)++-- | Larger-than comparison for symbols.+-- +-- === __Example__+-- +-- >>> :kind! Eval ("b" > "a")+-- Eval ("b" > "a") :: Bool+-- = 'True+data (>) :: Symbol -> Symbol -> Exp Bool+type instance Eval ((>) a b) = Eval (TyEq (TL.CmpSymbol a b) 'GT)++-- | Equality of symbols+-- +-- === __Example__+-- +-- >>> :kind! Eval ("b" == "a")+-- Eval ("b" == "a") :: Bool+-- = 'False+data (==) :: Symbol -> Symbol -> Exp Bool+type instance Eval ((==) a b) = Eval (TyEq (TL.CmpSymbol a b) 'EQ)

@@ -82,10 +82,10 @@                      , type (++), Not, If                      , Pure, TyEq, Length, Uncurry) import qualified Fcf as Fcf (Map, Foldr, Filter)-import           Fcf.Data.List (Elem)+import qualified Fcf.Data.List as L (Elem, Partition)  import           Fcf.Alg.Morphism-import qualified Fcf.Alg.List as Fcf (Partition)+-- import qualified Fcf.Alg.List as Fcf (Partition)  -------------------------------------------------------------------------------- @@ -94,7 +94,7 @@ -- $setup -- >>> import           Fcf (type (>=)) -- >>> import           Fcf.Data.Nat--- >>> import           Fcf.Data.Symbol (Symbol,Append)+-- >>> import           Fcf.Alg.Symbol (Symbol,Append)  -------------------------------------------------------------------------------- @@ -154,7 +154,7 @@ -- = 'MapC '[ '(3, "hih"), '(1, "haa"), '(2, "hoo")] data Insert :: k -> v -> MapC k v -> Exp (MapC k v) type instance Eval (Insert k v ('MapC lst)) =-    If (Eval (Elem k =<< Fcf.Map Fst lst))+    If (Eval (L.Elem k =<< Fcf.Map Fst lst))         ('MapC lst)         ('MapC ( '(k,v) ': lst)) @@ -179,7 +179,7 @@ -- = 'MapC '[ '(7, "xxx")] data InsertWith :: (v -> v -> Exp v) -> k -> v -> MapC k v -> Exp (MapC k v) type instance Eval (InsertWith f k v ('MapC lst)) =-    If (Eval (Elem k =<< Fcf.Map Fst lst))+    If (Eval (L.Elem k =<< Fcf.Map Fst lst))         ('MapC (Eval (Fcf.Map (InsWithHelp f k v) lst)))         ('MapC (Eval (lst ++ '[ '(k,v)]))) @@ -272,7 +272,7 @@ -- = 'False data Member :: k -> MapC k v -> Exp Bool type instance Eval (Member k mp) =-    Eval (Elem k =<< Keys mp)+    Eval (L.Elem k =<< Keys mp)  -- | NotMember --@@ -286,7 +286,7 @@ -- = 'True data NotMember :: k -> MapC k v -> Exp Bool type instance Eval (NotMember k mp) =-    Eval (Not =<< Elem k =<< Keys mp)+    Eval (Not =<< L.Elem k =<< Keys mp)  -- | Null --@@ -327,7 +327,7 @@  data UComb :: (k,v) -> [(k,v)] -> Exp [(k,v)] type instance Eval (UComb '(k,v) lst) =-    If (Eval (Elem k =<< Fcf.Map Fst lst))+    If (Eval (L.Elem k =<< Fcf.Map Fst lst))         lst         ('(k,v) ': lst) @@ -348,7 +348,7 @@ -- helper data DiffNotMem :: MapC k v -> k -> v -> Exp Bool type instance Eval (DiffNotMem mp k _) =-    Eval (Not =<< Elem k =<< Keys mp)+    Eval (Not =<< L.Elem k =<< Keys mp)   -- | Intersection@@ -366,7 +366,7 @@  -- helper data InterMem :: MapC k v -> k -> v -> Exp Bool-type instance Eval (InterMem mp k _) = Eval (Elem k =<< Keys mp)+type instance Eval (InterMem mp k _) = Eval (L.Elem k =<< Keys mp)   -- | Disjoint@@ -519,7 +519,7 @@ -- = '( 'MapC '[ '(3, 30)], 'MapC '[ '(5, 50)]) data Partition :: (v -> Exp Bool) -> MapC k v -> Exp (MapC k v, MapC k v) type instance Eval (Partition f ('MapC lst)) =-    Eval (PartitionHlp (Eval (Fcf.Partition (f <=< Snd) lst)))+    Eval (PartitionHlp (Eval (L.Partition (f <=< Snd) lst)))  data PartitionHlp :: ([(k,v)],[(k,v)]) -> Exp (MapC k v, MapC k v) type instance Eval (PartitionHlp '(xs,ys)) = '( 'MapC xs, 'MapC ys)

@@ -14,11 +14,11 @@ License     : BSD Maintainer  : gspia -= Fcf.Data.NatNatMap+= Fcf.Data.NatMap  NatMap provides an interface to mapping keys (Nat's) to values, which is similar to-NatIntMap given by the containers-package. Note that the this module still misses+IntMap given by the containers-package. Note that the this module still misses some of the methods that can be found in containers. If you need some, please do open up an issue or better, make a PR. @@ -71,17 +71,14 @@     )   where --- import qualified GHC.TypeLits as TL- import           Fcf ( Eval, Exp, Fst, Snd, type (=<<), type (<=<), type (@@)                      , type (++), Not, If                      , Pure, TyEq, Length, Uncurry) import qualified Fcf as Fcf (Map, Foldr, Filter)-import           Fcf.Data.List (Elem)+import qualified Fcf.Data.List as L (Elem, Partition)  import           Fcf.Data.Nat import           Fcf.Alg.Morphism-import qualified Fcf.Alg.List as Fcf (Partition)  -------------------------------------------------------------------------------- @@ -90,7 +87,7 @@ -- $setup -- >>> import           Fcf (type (>=)) -- >>> import           Fcf.Data.Nat--- >>> import           Fcf.Data.Symbol (Symbol,Append)+-- >>> import           Fcf.Alg.Symbol (Symbol,Append)  -------------------------------------------------------------------------------- @@ -149,13 +146,15 @@ -- = 'NatMap '[ '(3, "hih"), '(1, "haa"), '(2, "hoo")] data Insert :: Nat -> v -> NatMap v -> Exp (NatMap v) type instance Eval (Insert k v ('NatMap lst)) =-    If (Eval (Elem k =<< Fcf.Map Fst lst))+    If (Eval (L.Elem k =<< Fcf.Map Fst lst))         ('NatMap lst)         ('NatMap ( '(k,v) ': lst))   -- | InsertWith+-- -- if old there, map+-- -- if no old, add -- -- === __Example__@@ -175,7 +174,7 @@ -- = 'NatMap '[ '(7, "xxx")] data InsertWith :: (v -> v -> Exp v) -> Nat -> v -> NatMap v -> Exp (NatMap v) type instance Eval (InsertWith f k v ('NatMap lst)) =-    If (Eval (Elem k =<< Fcf.Map Fst lst))+    If (Eval (L.Elem k =<< Fcf.Map Fst lst))         ('NatMap (Eval (Fcf.Map (InsWithHelp f k v) lst)))         ('NatMap (Eval (lst ++ '[ '(k,v)]))) @@ -268,7 +267,7 @@ -- = 'False data Member :: Nat -> NatMap v -> Exp Bool type instance Eval (Member k mp) =-    Eval (Elem k =<< Keys mp)+    Eval (L.Elem k =<< Keys mp)  -- | NotMember --@@ -282,7 +281,7 @@ -- = 'True data NotMember :: Nat -> NatMap v -> Exp Bool type instance Eval (NotMember k mp) =-    Eval (Not =<< Elem k =<< Keys mp)+    Eval (Not =<< L.Elem k =<< Keys mp)  -- | Null --@@ -322,7 +321,7 @@  data UComb :: (k,v) -> [(k,v)] -> Exp [(k,v)] type instance Eval (UComb '(k,v) lst) =-    If (Eval (Elem k =<< Fcf.Map Fst lst))+    If (Eval (L.Elem k =<< Fcf.Map Fst lst))         lst         ('(k,v) ': lst) @@ -342,7 +341,7 @@ -- helper data DiffNotMem :: NatMap v -> k -> v -> Exp Bool type instance Eval (DiffNotMem mp k _) =-    Eval (Not =<< Elem k =<< Keys mp)+    Eval (Not =<< L.Elem k =<< Keys mp)   -- | Intersection@@ -359,7 +358,7 @@  -- helper data InterMem :: NatMap v -> Nat -> v -> Exp Bool-type instance Eval (InterMem mp k _) = Eval (Elem k =<< Keys mp)+type instance Eval (InterMem mp k _) = Eval (L.Elem k =<< Keys mp)   -- | Disjoint@@ -513,7 +512,7 @@ -- = '( 'NatMap '[ '(3, 30)], 'NatMap '[ '(5, 50)]) data Partition :: (v -> Exp Bool) -> NatMap v -> Exp (NatMap v, NatMap v) type instance Eval (Partition f ('NatMap lst)) =-    Eval (PartitionHlp (Eval (Fcf.Partition (f <=< Snd) lst)))+    Eval (PartitionHlp (Eval (L.Partition (f <=< Snd) lst)))  data PartitionHlp :: ([(Nat,v)],[(Nat,v)]) -> Exp (NatMap v, NatMap v) type instance Eval (PartitionHlp '(xs,ys)) = '( 'NatMap xs, 'NatMap ys)

@@ -64,9 +64,9 @@ import           Fcf ( Eval, Exp, type (=<<), type (<=<), type (&&)                      , Not, If, Map, Flip, TyEq ) import qualified Fcf as Fcf (Foldr, Filter)+import           Fcf.Class.Foldable (All, Any) import           Fcf.Data.List ( Elem, Cons, Concat, Reverse, Length, type (++)                                , ZipWith, Replicate)-import           Fcf.Alg.List ( All, Any )  -------------------------------------------------------------------------------- 

@@ -1,250 +0,0 @@-{-# LANGUAGE DataKinds              #-}-{-# LANGUAGE PolyKinds              #-}-{-# LANGUAGE TypeFamilies           #-}-{-# LANGUAGE TypeInType             #-}-{-# LANGUAGE TypeOperators          #-}-{-# LANGUAGE UndecidableInstances   #-}-{-# OPTIONS_GHC -Wall                       #-}-{-# OPTIONS_GHC -Werror=incomplete-patterns #-}--{-|-Module      : Fcf.Data.Symbol-Description : Type level symbols-Copyright   : (c) gspia 2020--License     : BSD-Maintainer  : gspia--= Fcf.Data.Symbol--Type-level symbols and functions for them.--Note that the operators from this module conflict with "GHC.TypeLits".---TODO: Would this whole module have a place first-class-families?---}------------------------------------------------------------------------------------module Fcf.Data.Symbol-    ( -- * Reexported type-      -- | From "GHC.TypeList".--      Symbol--      -- * Functions--    , Append-    , Intercalate-    , IsSpace-    , IsNewLine-    , IsTab-    , IsSpaceDelim-    , IsDigit--     -- * Comparison functions--    , SymbolOrd-    , type (<=)-    , type (>=)-    , type (<)-    , type (>)-    , type (==)-    )-  where-----------------------------------------------------------------------------------        -import           GHC.TypeLits (Symbol)-import qualified GHC.TypeLits as TL--import           Fcf.Core (Eval, Exp)-import           Fcf.Data.List (Foldr, Elem)-import           Fcf.Data.Bool (type (||))-import           Fcf.Utils (TyEq)--import           Fcf.Combinators (type (=<<))-------------------------------------------------------------------------------------- | Append two type-level symbols.------ === __Example__--- --- >>> :kind! Eval (Append "hmm" " ok")--- Eval (Append "hmm" " ok") :: Symbol--- = "hmm ok"-data Append :: Symbol -> Symbol -> Exp Symbol-type instance Eval (Append s1 s2) = TL.AppendSymbol s1 s2----- | Intercalate type-level symbols.--- --- === __Example__--- --- >>> :kind! Eval (Intercalate "+" '["aa", "bb", "cc"])--- Eval (Intercalate "+" '["aa", "bb", "cc"]) :: Symbol--- = "aa+bb+cc"------ >>> :kind! Eval (Intercalate "+" '["aa"])--- Eval (Intercalate "+" '["aa"]) :: Symbol--- = "aa"------ >>> :kind! Eval (Intercalate "+" '[])--- Eval (Intercalate "+" '[]) :: Symbol--- = ""-data Intercalate :: Symbol -> [Symbol] -> Exp Symbol-type instance Eval (Intercalate s1 '[]) = ""-type instance Eval (Intercalate s1 (s ': sLst)) =-    Eval (Append s =<< Foldr (InterCalHelp s1) "" sLst)---- helper-data InterCalHelp :: Symbol -> Symbol -> Symbol -> Exp Symbol-type instance Eval (InterCalHelp s s1 s2) = Eval (Append (Eval (Append s s1)) s2)----- | IsSpace------ === __Example__--- --- >>> :kind! Eval (IsSpace "a")--- Eval (IsSpace "a") :: Bool--- = 'False------ >>> :kind! Eval (IsSpace " ")--- Eval (IsSpace " ") :: Bool--- = 'True-data IsSpace :: Symbol -> Exp Bool-type instance Eval (IsSpace s) = Eval (s == " ")----- | IsNewline------ === __Example__--- --- >>> :kind! Eval (IsNewLine "a")--- Eval (IsNewLine "a") :: Bool--- = 'False------ >>> :kind! Eval (IsNewLine "\n")--- Eval (IsNewLine "\n") :: Bool--- = 'True-data IsNewLine :: Symbol -> Exp Bool-type instance Eval (IsNewLine s) = Eval (s == "\n")----- | IsTab------ === __Example__--- --- >>> :kind! Eval (IsTab "a")--- Eval (IsTab "a") :: Bool--- = 'False------ >>> :kind! Eval (IsTab "\t")--- Eval (IsTab "\t") :: Bool--- = 'True-data IsTab :: Symbol -> Exp Bool-type instance Eval (IsTab s) = Eval (s == "\t")----- | IsSpaceDelim------ === __Example__--- --- >>> :kind! Eval (IsSpaceDelim "a")--- Eval (IsSpaceDelim "a") :: Bool--- = 'False------ >>> :kind! Eval (IsSpaceDelim "\n")--- Eval (IsSpaceDelim "\n") :: Bool--- = 'True-data IsSpaceDelim :: Symbol -> Exp Bool-type instance Eval (IsSpaceDelim s) =-    Eval (Eval (IsSpace s) || (Eval (Eval (IsNewLine s) || Eval (IsTab s))))----- | IsDigit------ === __Example__--- --- >>> :kind! Eval (IsDigit "3")--- Eval (IsDigit "3") :: Bool--- = 'True------ >>> :kind! Eval (IsDigit "a")--- Eval (IsDigit "a") :: Bool--- = 'False-data IsDigit :: Symbol -> Exp Bool-type instance Eval (IsDigit s)-    = Eval (Elem s '["0","1","2","3","4","5","6","7","8","9"])----------------------------------------------------------------------------------------- | SymbolOrd - compare two symbols and give type-level Ordering --- ( $ 'LT $, $ 'EQ $ or $ 'GT $ ).------ === __Example__--- --- >>> :kind! Eval (SymbolOrd "a" "b")--- Eval (SymbolOrd "a" "b") :: Ordering--- = 'LT-data SymbolOrd :: Symbol -> Symbol -> Exp Ordering-type instance Eval (SymbolOrd a b) = TL.CmpSymbol a b---- | Less-than-or-equal comparison for symbols.--- --- === __Example__--- --- >>> :kind! Eval ("b" <= "a")--- Eval ("b" <= "a") :: Bool--- = 'False----data (<=) :: Symbol -> Symbol -> Exp Bool-type instance Eval ((<=) a b) =-    Eval (Eval (TyEq (TL.CmpSymbol a b) 'LT) || Eval (TyEq (TL.CmpSymbol a b) 'EQ))---- | Larger-than-or-equal comparison for symbols.--- --- === __Example__--- --- >>> :kind! Eval ("b" >= "a")--- Eval ("b" >= "a") :: Bool--- = 'True-data (>=) :: Symbol -> Symbol -> Exp Bool-type instance Eval ((>=) a b) =-    Eval (Eval (TyEq (TL.CmpSymbol a b) 'GT) || Eval (TyEq (TL.CmpSymbol a b) 'EQ))---- | Less-than comparison for symbols.--- --- === __Example__--- --- >>> :kind! Eval ("a" < "b")--- Eval ("a" < "b") :: Bool--- = 'True-data (<) :: Symbol -> Symbol -> Exp Bool-type instance Eval ((<) a b) = Eval (TyEq (TL.CmpSymbol a b) 'LT)---- | Larger-than comparison for symbols.--- --- === __Example__--- --- >>> :kind! Eval ("b" > "a")--- Eval ("b" > "a") :: Bool--- = 'True-data (>) :: Symbol -> Symbol -> Exp Bool-type instance Eval ((>) a b) = Eval (TyEq (TL.CmpSymbol a b) 'GT)---- | Equality of symbols--- --- === __Example__--- --- >>> :kind! Eval ("b" == "a")--- Eval ("b" == "a") :: Bool--- = 'False-data (==) :: Symbol -> Symbol -> Exp Bool-type instance Eval ((==) a b) = Eval (TyEq (TL.CmpSymbol a b) 'EQ)

@@ -47,7 +47,7 @@     , CompareLength      -- * Transformation-    , Map+    , FMap     , Intercalate     , Intersperse     , Reverse@@ -55,7 +55,7 @@      -- * Special Folds     , Concat-    , ConcatMap+    , FConcatMap     , Any     , All @@ -90,22 +90,20 @@  import           Fcf ( If, Eval, Exp, type (=<<), type (@@)                      , Flip, Pure )+import qualified Fcf.Class.Foldable as F (All, Any) import           Fcf.Data.List ( type (++) ) import qualified Fcf.Data.List as F     ( Length, Head, Tail, Init, Reverse, Take, Drop, TakeWhile, DropWhile-    , Foldr)--import qualified Fcf.Classes as F ( Map )+    , Foldr, Intercalate, Intersperse, IsPrefixOf, IsSuffixOf, IsInfixOf, Snoc)+import           Fcf.Data.Symbol (Symbol)+-- import qualified Fcf.Data.Symbol as FS -import qualified Fcf.Alg.List as F-    ( Any, All, IsPrefixOf, IsSuffixOf, IsInfixOf, Snoc, Intercalate-    , Intersperse)+import qualified Fcf.Class.Functor as F ( FMap )   import           Fcf.Data.Nat (Nat) import           Fcf.Alg.Morphism (First,Second)-import           Fcf.Data.Symbol (Symbol)-import qualified Fcf.Data.Symbol as S+import qualified Fcf.Alg.Symbol as S  -------------------------------------------------------------------------------- @@ -268,7 +266,7 @@ -- = 'Nothing data Unsnoc :: Text -> Exp (Maybe (Symbol, Text)) type instance Eval (Unsnoc txt) =-    Eval (F.Map (Second Reverse) =<< Uncons =<< Reverse txt)+    Eval (F.FMap (Second Reverse) =<< Uncons =<< Reverse txt)   -- | Get the first symbol of type-level text.@@ -297,7 +295,7 @@ -- Eval (Tail ('Text '[])) :: Maybe Text -- = 'Nothing data Tail :: Text -> Exp (Maybe Text)-type instance Eval (Tail ('Text lst)) = Eval (F.Map FromList =<< F.Tail lst)+type instance Eval (Tail ('Text lst)) = Eval (F.FMap FromList =<< F.Tail lst)  -- | Take all except the last symbol from type-level text. --@@ -311,7 +309,7 @@ -- Eval (Init ('Text '[])) :: Maybe Text -- = 'Nothing data Init :: Text -> Exp (Maybe Text)-type instance Eval (Init ('Text lst)) = Eval (F.Map FromList =<< F.Init lst)+type instance Eval (Init ('Text lst)) = Eval (F.FMap FromList =<< F.Init lst)   -- | Compare the length of type-level text to given Nat and give@@ -327,7 +325,7 @@   --- | Map for type-level text.+-- | FMap for type-level text. -- -- === __Example__ -- @@ -342,11 +340,11 @@ --     ) -- :} -- --- >>> :kind! Eval (Map Isymb2e ('Text '["i","m","u"]))--- Eval (Map Isymb2e ('Text '["i","m","u"])) :: Text+-- >>> :kind! Eval (FMap Isymb2e ('Text '["i","m","u"]))+-- Eval (FMap Isymb2e ('Text '["i","m","u"])) :: Text -- = 'Text '["e", "m", "u"]-data Map :: (Symbol -> Exp Symbol) -> Text -> Exp Text-type instance Eval (Map f ('Text lst)) = 'Text (Eval (F.Map f lst))+data FMap :: (Symbol -> Exp Symbol) -> Text -> Exp Text+type instance Eval (FMap f ('Text lst)) = 'Text (Eval (F.FMap f lst))   -- | Intercalate for type-level text.@@ -358,7 +356,7 @@ -- = 'Text '["a", "a", "m", "u", " ", "&", " ", "v", "a", "l", "o"] data Intercalate :: Text -> [Text] -> Exp Text type instance Eval (Intercalate ('Text txt) txts) =-    Eval (FromList =<< F.Intercalate txt =<< F.Map ToList txts)+    Eval (FromList =<< F.Intercalate txt =<< F.FMap ToList txts)   -- | Intersperse for type-level text.@@ -409,7 +407,7 @@   --- | ConcatMap for type-level text.+-- | FConcatMap for type-level text. -- -- === __Example__ --@@ -424,11 +422,11 @@ --     ) -- :} ----- >>> :kind! Eval (ConcatMap Isymb2aa ('Text '["i","m","u"," ","i","h"]))--- Eval (ConcatMap Isymb2aa ('Text '["i","m","u"," ","i","h"])) :: Text+-- >>> :kind! Eval (FConcatMap Isymb2aa ('Text '["i","m","u"," ","i","h"]))+-- Eval (FConcatMap Isymb2aa ('Text '["i","m","u"," ","i","h"])) :: Text -- = 'Text '["a", "a", "m", "u", " ", "a", "a", "h"]-data ConcatMap :: (Symbol -> Exp Text) -> Text -> Exp Text-type instance Eval (ConcatMap f ('Text lst)) = Eval (Concat =<< F.Map f lst)+data FConcatMap :: (Symbol -> Exp Text) -> Text -> Exp Text+type instance Eval (FConcatMap f ('Text lst)) = Eval (Concat =<< F.FMap f lst)  -- | Any for type-level text. --@@ -586,7 +584,7 @@ -- = '[ 'Text '["c", "d"], 'Text '["f", "g"], 'Text '["h"]] data SplitOn :: Text -> Text -> Exp [Text] type instance Eval (SplitOn ('Text sep) ('Text txt)) =-    Eval (F.Map FromList =<< SOLoop sep '( '[], txt))+    Eval (F.FMap FromList =<< SOLoop sep '( '[], txt))   -- | Helper for SplitOn@@ -619,7 +617,7 @@ -- = '[ 'Text '["c", "d"], 'Text '["b", "f"], 'Text '["a", "b", "h"]] data Split :: (Symbol -> Exp Bool) -> Text -> Exp [Text] type instance Eval (Split p ('Text txt)) =-    Eval (F.Map FromList =<< SplitLoop p '( '[], txt))+    Eval (F.FMap FromList =<< SplitLoop p '( '[], txt))  -- | Helper for Split data SplitTake :: (Symbol -> Exp Bool) -> [Symbol] -> [Symbol] -> Exp ([Symbol], [Symbol])@@ -668,7 +666,7 @@ -- = 'Text '["o", "k", "\n", "h", "m", "m ", "\n", "a", "b", "\n"] data Unlines :: [Text] -> Exp Text type instance Eval (Unlines txts) =-    Eval (Concat =<< F.Map (Flip Append (Singleton @@ "\n")) txts)+    Eval (Concat =<< F.FMap (Flip Append (Singleton @@ "\n")) txts)  -- | Unwords for type-level text. This uses 'Intercalate' to add space-symbol -- between the given texts.