From 6ca6f7c08685fa3c6742a23a6795e15d01899636 Mon Sep 17 00:00:00 2001 From: "restyled-io[bot]" <32688539+restyled-io[bot]@users.noreply.github.com> Date: Tue, 3 Sep 2024 18:31:29 -0500 Subject: [PATCH] Restyle Exploration of the Lower Your Guards paper (#402) * Restyled by fourmolu * Restyled by hlint --------- Co-authored-by: Restyled.io --- explore/lower-your-guards/Setup.hs | 1 + explore/lower-your-guards/src/Annotated.hs | 5 +- explore/lower-your-guards/src/GuardTree.hs | 6 +- explore/lower-your-guards/src/Inhabitants.hs | 18 +++--- explore/lower-your-guards/src/Main.hs | 4 +- explore/lower-your-guards/src/MatchTree.hs | 58 +++++++++---------- explore/lower-your-guards/src/Parse.hs | 18 +++--- explore/lower-your-guards/src/Play.hs | 53 ++++++++--------- .../lower-your-guards/src/Possibilities.hs | 8 +-- explore/lower-your-guards/src/Types.hs | 51 ++++++++-------- explore/lower-your-guards/src/UA.hs | 4 +- explore/lower-your-guards/src/Uncovered.hs | 10 ++-- 12 files changed, 122 insertions(+), 114 deletions(-) diff --git a/explore/lower-your-guards/Setup.hs b/explore/lower-your-guards/Setup.hs index 9a994af6..e8ef27db 100644 --- a/explore/lower-your-guards/Setup.hs +++ b/explore/lower-your-guards/Setup.hs @@ -1,2 +1,3 @@ import Distribution.Simple + main = defaultMain diff --git a/explore/lower-your-guards/src/Annotated.hs b/explore/lower-your-guards/src/Annotated.hs index 50ecf4d9..70def529 100644 --- a/explore/lower-your-guards/src/Annotated.hs +++ b/explore/lower-your-guards/src/Annotated.hs @@ -3,8 +3,8 @@ module Annotated where import qualified GuardTree as G -import qualified Uncovered as U import MatchInfo +import qualified Uncovered as U data Ant where Grhs :: U.RefinementType -> Int -> Ant @@ -17,4 +17,5 @@ annotated ref gdt = case gdt of G.Guarded (var, g) t -> case g of G.GMatch k args -> annotated (ref `U.liftAndLit` varInfo (Match k args)) t G.GWas new -> annotated (ref `U.liftAndLit` varInfo (WasOriginally new)) t - where varInfo = U.Info var + where + varInfo = U.Info var diff --git a/explore/lower-your-guards/src/GuardTree.hs b/explore/lower-your-guards/src/GuardTree.hs index 865c6650..bfbee784 100644 --- a/explore/lower-your-guards/src/GuardTree.hs +++ b/explore/lower-your-guards/src/GuardTree.hs @@ -6,9 +6,9 @@ import Control.Monad (replicateM, zipWithM) import Data.List.NonEmpty (NonEmpty (..)) import qualified Data.List.NonEmpty as NE import qualified Fresh as F +import MatchInfo import qualified Parse as P import qualified Types as Ty -import MatchInfo data Gdt where Grhs :: Int -> Gdt @@ -32,11 +32,11 @@ desugarClauses args clauses = do desugarClause :: [F.VarID] -> (Int, P.Clause) -> F.Fresh Gdt desugarClause args (i, P.Clause pat typeIn _) = do let x1 = head args -- we only suport 1 arg for this toy lyg - guards <- desugarMatch (x1,typeIn) pat + guards <- desugarMatch (x1, typeIn) pat return $ foldr Guarded (Grhs i) guards desugarMatch :: TypedVar -> P.Pattern -> F.Fresh [(TypedVar, Guard)] -desugarMatch var@(_,ty) pat = do +desugarMatch var@(_, ty) pat = do case pat of P.PWild -> return [] P.PVar name -> do diff --git a/explore/lower-your-guards/src/Inhabitants.hs b/explore/lower-your-guards/src/Inhabitants.hs index 254fbc4c..f18231d1 100644 --- a/explore/lower-your-guards/src/Inhabitants.hs +++ b/explore/lower-your-guards/src/Inhabitants.hs @@ -45,9 +45,9 @@ accessableRedundant ant args = case ant of -- do a linear scan from right to left lookupVar :: TypedVar -> [ConstraintFor] -> TypedVar lookupVar x = foldr getNextId x - where - getNextId (x', MatchInfo (WasOriginally y)) | x' == x = const y - getNextId _ = id + where + getNextId (x', MatchInfo (WasOriginally y)) | x' == x = const y + getNextId _ = id alistLookup :: (Eq a) => a -> [(a, b)] -> [b] alistLookup a = map snd . filter ((== a) . fst) @@ -101,10 +101,10 @@ findVarInhabitants var nref@(_, cns) = if null posNrefs then Poss.retSingle $ IPNot [] else Poss.anyOf <$> forM posNrefs (findVarInhabitants var) - where - constraintsOnX = onVar var cns - posMatch = listToMaybe $ mapMaybe (\case MatchInfo (Match k ys) -> Just (k, ys); _ -> Nothing) constraintsOnX - negMatch = mapMaybe (\case MatchInfo (Not k) -> Just k; _ -> Nothing) constraintsOnX + where + constraintsOnX = onVar var cns + posMatch = listToMaybe $ mapMaybe (\case MatchInfo (Match k ys) -> Just (k, ys); _ -> Nothing) constraintsOnX + negMatch = mapMaybe (\case MatchInfo (Not k) -> Just k; _ -> Nothing) constraintsOnX normalize :: NormRefType -> U.Formula -> F.Fresh (S.Set NormRefType) normalize nref (f1 `U.And` f2) = do @@ -155,8 +155,8 @@ addConstraintHelper nref@(ctx, cns) cf@(origX, c) = case c of else do let (noX', withX') = partition ((/= origX) . fst) cns addConstraints (ctx, noX' ++ [cf]) (substituteVarIDs origY origX withX') - where - added = (ctx, cns ++ [cf]) + where + added = (ctx, cns ++ [cf]) ----- ----- Helper functions for adding constraints: diff --git a/explore/lower-your-guards/src/Main.hs b/explore/lower-your-guards/src/Main.hs index a2ea3852..c75727da 100644 --- a/explore/lower-your-guards/src/Main.hs +++ b/explore/lower-your-guards/src/Main.hs @@ -147,5 +147,5 @@ niceInhabPattern (I.IPNot nots) = "(Not " ++ niceList (map Ty.dcName nots) ++ ") niceList :: [Text] -> String niceList as = concat $ tail $ concatMap comma as - where - comma x = [", ", T.unpack x] + where + comma x = [", ", T.unpack x] diff --git a/explore/lower-your-guards/src/MatchTree.hs b/explore/lower-your-guards/src/MatchTree.hs index 6fb02e39..cb5a30e2 100644 --- a/explore/lower-your-guards/src/MatchTree.hs +++ b/explore/lower-your-guards/src/MatchTree.hs @@ -1,4 +1,4 @@ -{-# LANGUAGE EmptyCase #-} + {-# OPTIONS_GHC -Wno-unrecognised-pragmas #-} {-# HLINT ignore "Eta reduce" #-} @@ -39,9 +39,9 @@ final2 = ([full] \\\ c2) \\\ c1 -- true = Status $ Is $ Just $ head $ Ty.dataCons Ty.bool -e1 = Pair (Either [(isInt 10)] []) (isInt 2) +e1 = Pair (Either [isInt 10] []) (isInt 2) -e2 = Pair (Either [(isInt 4)] []) (isInt 5) +e2 = Pair (Either [isInt 4] []) (isInt 5) -- e3 = Pair (Either [] [true]) (isInt 5) @@ -73,21 +73,21 @@ treeMinus t1 t2 = case (t1, t2) of (Pair _ _, Either _ _) -> error "type error6" (Pair a b, Pair c d) -> map mkPairL aMinusC ++ map mkPairR bMinusD ++ both - where - mkPairL aSubC = Pair aSubC d - mkPairR bSubD = Pair c bSubD - both = [Pair aSubC bSubD | aSubC <- aMinusC, bSubD <- bMinusD] - c' = treeIntersect a c - d' = treeIntersect b d - aMinusC = concatMap (a \\) c' - bMinusD = concatMap (b \\) d' - -- [Pair d' aSubC, Pair c' bSubD, Pair aSubC bSubD] + where + mkPairL aSubC = Pair aSubC d + mkPairR bSubD = Pair c bSubD + both = [Pair aSubC bSubD | aSubC <- aMinusC, bSubD <- bMinusD] + c' = treeIntersect a c + d' = treeIntersect b d + aMinusC = concatMap (a \\) c' + bMinusD = concatMap (b \\) d' + -- [Pair d' aSubC, Pair c' bSubD, Pair aSubC bSubD] (Either a b, Either c d) -> [Either left right] - where - -- l = foldr a (flip map (\\)) c - left = concat [x \\ y | x <- a, y <- c] - right = concat [x \\ y | x <- b, y <- d] + where + -- l = foldr a (flip map (\\)) c + left = concat [x \\ y | x <- a, y <- c] + right = concat [x \\ y | x <- b, y <- d] treeIntersect :: MatchTree -> MatchTree -> [MatchTree] treeIntersect m1 m2 = case (m1, m2) of @@ -105,20 +105,20 @@ treeIntersect m1 m2 = case (m1, m2) of (Either _ _, Pair _ _) -> error "type error5" (Pair _ _, Either _ _) -> error "type error6" (Pair a b, Pair c d) -> error "pairs" - -- map mkPairL (a \\ c) ++ map mkPairR (b \\ d) ++ both - -- where - -- mkPairL aSubC = Pair aSubC d - -- mkPairR bSubD = Pair c bSubD - -- both = [Pair aSubC bSubD | aSubC <- a \\ c, bSubD <- b \\ d] - -- c' = statIntersect a c - -- d' = statIntersect b d + -- map mkPairL (a \\ c) ++ map mkPairR (b \\ d) ++ both + -- where + -- mkPairL aSubC = Pair aSubC d + -- mkPairR bSubD = Pair c bSubD + -- both = [Pair aSubC bSubD | aSubC <- a \\ c, bSubD <- b \\ d] + -- c' = statIntersect a c + -- d' = statIntersect b d (Either a b, Either c d) -> error "eithers" - -- [Either left right] - -- where - -- -- l = foldr a (flip map (\\)) c - -- left = concat [x \\ y | x <- a, y <- c] - -- right = concat [x \\ y | x <- b, y <- d] - + +-- [Either left right] +-- where +-- -- l = foldr a (flip map (\\)) c +-- left = concat [x \\ y | x <- a, y <- c] +-- right = concat [x \\ y | x <- b, y <- d] -- (a-c)*(b-d) + c*(b-d) + (a-c)*d diff --git a/explore/lower-your-guards/src/Parse.hs b/explore/lower-your-guards/src/Parse.hs index 7f62341e..6c2b0e50 100644 --- a/explore/lower-your-guards/src/Parse.hs +++ b/explore/lower-your-guards/src/Parse.hs @@ -105,9 +105,9 @@ pDataConsMatch typeIn = pPattern :: Ty.Type -> Parser Pattern pPattern typeIn = choice - [ symbol "_" $> PWild, - pDataConsMatch typeIn, - pName <&> PVar + [ symbol "_" $> PWild + , pDataConsMatch typeIn + , pName <&> PVar ] pClause :: Text -> Ty.Type -> Parser Clause @@ -133,15 +133,15 @@ pFn = do pType :: Parser Ty.Type pType = choice - [ Ty.int <$ lexeme (string "Int"), - Ty.bool <$ lexeme (string "Bool"), - Ty.throol <$ lexeme (string "Throol"), - do + [ Ty.int <$ lexeme (string "Int") + , Ty.bool <$ lexeme (string "Bool") + , Ty.throol <$ lexeme (string "Throol") + , do _ <- symbol "," l <- pType r <- pType - return $ Ty.pair l r, - do + return $ Ty.pair l r + , do _ <- lexeme (string "Either") l <- pType r <- pType diff --git a/explore/lower-your-guards/src/Play.hs b/explore/lower-your-guards/src/Play.hs index dad78cf1..9ff61c5e 100644 --- a/explore/lower-your-guards/src/Play.hs +++ b/explore/lower-your-guards/src/Play.hs @@ -1,8 +1,8 @@ module Play where thing :: (Int, Bool) -> () -thing (n,True) = () -thing (0,n) = () +thing (n, True) = () +thing (0, n) = () triple :: (Int, Int, Int) -> () triple (7, 5, 3) = () @@ -11,19 +11,19 @@ triple2 :: (Int, (Int, Int)) -> () triple2 (7, (5, 3)) = () foo :: (Either Int Bool, Int) -> Bool -foo (Left 1 , 2) = True -foo (Right False , n) = True -foo (Right True , n) = True -foo (Left 3 , n) = True -foo (Left 3 , n) = True +foo (Left 1, 2) = True +foo (Right False, n) = True +foo (Right True, n) = True +foo (Left 3, n) = True +foo (Left 3, n) = True foo2 :: (Either Int Bool, Int) -> Bool -foo2 (Left 1 , n) = True -foo2 (Right False , n) = True +foo2 (Left 1, n) = True +foo2 (Right False, n) = True foo3 :: (Either Bool Bool, Bool) -> Bool -foo3 (Left True , b) = True -foo3 (Right False , b) = True +foo3 (Left True, b) = True +foo3 (Right False, b) = True foo4 :: (Int, Int) -> Bool foo4 (1, n) = True @@ -42,24 +42,25 @@ foo7 (1, 2, 3) = False foo8 :: (Either Int Bool, Int) -> () foo8 (Left 10, 2) = () + -- foo8 (Right True, 5) = () data Pat where - Base :: Pat - Kon :: Pat -> Pat - DonKon :: Pat -> Pat -> Pat - deriving (Show, Eq) + Base :: Pat + Kon :: Pat -> Pat + DonKon :: Pat -> Pat -> Pat + deriving (Show, Eq) timelineSplitter :: Int -> [Pat] timelineSplitter p = do - case p of - 0 -> return Base - 2 -> [Base, Base] - 4 -> do - a <- timelineSplitter (p - 1) - b <- timelineSplitter (p - 2) - - return $ DonKon a b - _ -> do - n <- timelineSplitter (p - 1) - return $ Kon n + case p of + 0 -> return Base + 2 -> [Base, Base] + 4 -> do + a <- timelineSplitter (p - 1) + b <- timelineSplitter (p - 2) + + return $ DonKon a b + _ -> do + n <- timelineSplitter (p - 1) + return $ Kon n diff --git a/explore/lower-your-guards/src/Possibilities.hs b/explore/lower-your-guards/src/Possibilities.hs index 359e0618..96232977 100644 --- a/explore/lower-your-guards/src/Possibilities.hs +++ b/explore/lower-your-guards/src/Possibilities.hs @@ -55,10 +55,10 @@ retSingle i = return $ Possibilities [i] -- cartesian product of multiple sets allCombinations :: [Possibilities a] -> Possibilities [a] allCombinations = foldr prod nil - where - -- note, nil /= mempty - -- VERY important - nil = Possibilities [[]] + where + -- note, nil /= mempty + -- VERY important + nil = Possibilities [[]] prod :: Possibilities a -> Possibilities [a] -> Possibilities [a] prod (Possibilities xs) (Possibilities yss) = Possibilities [x : ys | x <- xs, ys <- yss] diff --git a/explore/lower-your-guards/src/Types.hs b/explore/lower-your-guards/src/Types.hs index 24f21d0c..81f25aec 100644 --- a/explore/lower-your-guards/src/Types.hs +++ b/explore/lower-your-guards/src/Types.hs @@ -1,4 +1,5 @@ {-# OPTIONS_GHC -Wno-missing-export-lists #-} + module Types where import Data.Text (Text) @@ -8,17 +9,17 @@ data TypeConstructor = TBool | TPair | TEither | TInt | TThrool deriving (Show, Eq, Ord) data Type = Type - { typeCons :: TypeConstructor, - dataCons :: Maybe [DataConstructor] + { typeCons :: TypeConstructor + , dataCons :: Maybe [DataConstructor] } deriving (Eq, Ord) instance Show Type where - show Type { typeCons = t } = "Type: " ++ show t + show Type {typeCons = t} = "Type: " ++ show t data DataConstructor = DataConstructor - { dcIdent :: DataConName, - dcTypes :: [Type] + { dcIdent :: DataConName + , dcTypes :: [Type] } deriving (Eq, Ord) @@ -36,34 +37,37 @@ instance Show DataConstructor where show dc = "(\'" ++ T.unpack (dcName dc) ++ "\' <" ++ (show . length $ dcTypes dc) ++ ">)" intCon :: Int -> DataConstructor -intCon i = DataConstructor { dcIdent = NameInt i, dcTypes = []} +intCon i = DataConstructor {dcIdent = NameInt i, dcTypes = []} bool :: Type bool = Type - { typeCons = TBool, - dataCons = Just - [ DataConstructor {dcIdent = NameText "True", dcTypes = []}, - DataConstructor {dcIdent = NameText "False", dcTypes = []} + { typeCons = TBool + , dataCons = + Just + [ DataConstructor {dcIdent = NameText "True", dcTypes = []} + , DataConstructor {dcIdent = NameText "False", dcTypes = []} ] } throol :: Type throol = Type - { typeCons = TThrool, - dataCons = Just - [ DataConstructor {dcIdent = NameText "Foo", dcTypes = []}, - DataConstructor {dcIdent = NameText "Bar", dcTypes = []}, - DataConstructor {dcIdent = NameText "Baz", dcTypes = []} + { typeCons = TThrool + , dataCons = + Just + [ DataConstructor {dcIdent = NameText "Foo", dcTypes = []} + , DataConstructor {dcIdent = NameText "Bar", dcTypes = []} + , DataConstructor {dcIdent = NameText "Baz", dcTypes = []} ] } pair :: Type -> Type -> Type pair a b = Type - { typeCons = TPair, - dataCons = Just + { typeCons = TPair + , dataCons = + Just [ DataConstructor {dcIdent = NameText ",", dcTypes = [a, b]} ] } @@ -71,17 +75,18 @@ pair a b = either :: Type -> Type -> Type either a b = Type - { typeCons = TEither, - dataCons = Just - [ DataConstructor {dcIdent = NameText "Left", dcTypes = [a]}, - DataConstructor {dcIdent = NameText "Right", dcTypes = [b]} + { typeCons = TEither + , dataCons = + Just + [ DataConstructor {dcIdent = NameText "Left", dcTypes = [a]} + , DataConstructor {dcIdent = NameText "Right", dcTypes = [b]} ] } int :: Type int = Type - { typeCons = TInt, - -- int is an opaque type + { typeCons = TInt + , -- int is an opaque type dataCons = Nothing } diff --git a/explore/lower-your-guards/src/UA.hs b/explore/lower-your-guards/src/UA.hs index 96bef30c..b70d1825 100644 --- a/explore/lower-your-guards/src/UA.hs +++ b/explore/lower-your-guards/src/UA.hs @@ -31,8 +31,8 @@ ua nrefs gdt = case gdt of (n', u) <- ua n t n'' <- addLitMulti nrefs $ varInfo (Not k) return (n'' ++ n', u) - where - varInfo = U.Info var + where + varInfo = U.Info var addLitMulti :: [I.NormRefType] -> U.Literal -> F.Fresh [I.NormRefType] addLitMulti [] _ = return [] diff --git a/explore/lower-your-guards/src/Uncovered.hs b/explore/lower-your-guards/src/Uncovered.hs index 00cd3f01..875025f0 100644 --- a/explore/lower-your-guards/src/Uncovered.hs +++ b/explore/lower-your-guards/src/Uncovered.hs @@ -29,12 +29,12 @@ uncovered r g = case g of uncovered (uncovered r t1) t2 G.Guarded (var, guard) t -> case guard of G.GMatch dataCon ys -> noMatch `union` matchedPath - where - noMatch = r `liftAndLit` varInfo (Not dataCon) - matchedPath = uncovered (r `liftAndLit` varInfo (Match dataCon ys)) t + where + noMatch = r `liftAndLit` varInfo (Not dataCon) + matchedPath = uncovered (r `liftAndLit` varInfo (Match dataCon ys)) t G.GWas old -> uncovered (r `liftAndLit` varInfo (WasOriginally old)) t - where - varInfo = Info var + where + varInfo = Info var liftAndLit :: RefinementType -> Literal -> RefinementType liftAndLit (cont, form) f = (cont, form `And` Literal f)