59ba87f · rowtype-yoga/purescript-native

psci/Completion.hs+6

compare with golang

unifiedsplit

@@ -1,13 +1,19 @@

1+{-# LANGUAGE CPP #-}

2+

1module Completion where

3module Completion where

2

4

3import Data.Maybe (mapMaybe)

5import Data.Maybe (mapMaybe)

4import Data.List (nub, nubBy, sortBy, isPrefixOf, stripPrefix)

6import Data.List (nub, nubBy, sortBy, isPrefixOf, stripPrefix)

5import Data.Char (isUpper)

7import Data.Char (isUpper)

6import Data.Function (on)

8import Data.Function (on)

9+#if __GLASGOW_HASKELL__ < 710

7import Data.Traversable (traverse)

10import Data.Traversable (traverse)

11+#endif

8

12

9import Control.Arrow (second)

13import Control.Arrow (second)

14+#if __GLASGOW_HASKELL__ < 710

10import Control.Applicative ((<$>), (<*>))

15import Control.Applicative ((<$>), (<*>))

16+#endif

11import Control.Monad.Trans.Reader (asks, runReaderT, ReaderT)

17import Control.Monad.Trans.Reader (asks, runReaderT, ReaderT)

12import Control.Monad.Trans.State.Strict

18import Control.Monad.Trans.State.Strict

13

19

psci/PSCi.hs+3

@@ -17,12 +17,15 @@

17{-# LANGUAGE GeneralizedNewtypeDeriving #-}

18{-# LANGUAGE RecordWildCards #-}

19{-# LANGUAGE TupleSections #-}

20+{-# LANGUAGE CPP #-}

20

21

21module PSCi where

22module PSCi where

22

23

23import Data.Foldable (traverse_)

24import Data.Foldable (traverse_)

24import Data.List (intercalate, nub, sort)

25import Data.List (intercalate, nub, sort)

26+#if __GLASGOW_HASKELL__ < 710

25import Data.Traversable (traverse)

27import Data.Traversable (traverse)

28+#endif

26import Data.Tuple (swap)

29import Data.Tuple (swap)

27import Data.Version (showVersion)

30import Data.Version (showVersion)

28import qualified Data.Map as M

31import qualified Data.Map as M

psci/Parser.hs+4

@@ -13,6 +13,8 @@

13--

14-----------------------------------------------------------------------------

15

16+{-# LANGUAGE CPP #-}

17+

16module Parser

18module Parser

17 ( parseCommand

19 ( parseCommand

18 ) where

20 ) where

@@ -22,7 +24,9 @@ import Prelude hiding (lex)

22import Data.Char (isSpace)

24import Data.Char (isSpace)

23import Data.List (intercalate)

25import Data.List (intercalate)

24

26

27+#if __GLASGOW_HASKELL__ < 710

25import Control.Applicative hiding (many)

28import Control.Applicative hiding (many)

29+#endif

26

30

27import Text.Parsec hiding ((<|>))

31import Text.Parsec hiding ((<|>))

28

32

psci/tests/Main.hs+2−1

@@ -1,4 +1,5 @@

1−{-# LANGUAGE RecordWildCards, TupleSections #-}

1+{-# LANGUAGE RecordWildCards #-}

2+{-# LANGUAGE TupleSections #-}

2

3

3module Main where

4module Main where

4

5

purescript.cabal+7−7

@@ -162,7 +162,7 @@ library

162 buildable: True

163 hs-source-dirs: src

164 other-modules: Paths_purescript

165− ghc-options: -Wall -O2

165+ ghc-options: -Wall -Werror -O2

166

167executable psc

168 build-depends: base >=4 && <5, containers -any, directory -any, filepath -any,

@@ -171,7 +171,7 @@ executable psc

171 main-is: Main.hs

172 buildable: True

173 hs-source-dirs: psc

174− ghc-options: -Wall -O2 -fno-warn-unused-do-bind

174+ ghc-options: -Wall -Werror -O2 -fno-warn-unused-do-bind

175

176executable psci

177 build-depends: base >=4 && <5, containers -any, directory -any, filepath -any,

@@ -188,7 +188,7 @@ executable psci

188 Completion

189 PSCi

190 IO

191− ghc-options: -Wall -O2

191+ ghc-options: -Wall -Werror -O2

192

193executable psc-docs

194 build-depends: base >=4 && <5, purescript -any,

@@ -201,14 +201,14 @@ executable psc-docs

201 other-modules: Ctags

202 Etags

203 Tags

204− ghc-options: -Wall -O2

204+ ghc-options: -Wall -Werror -O2

205

206executable psc-publish

207 build-depends: base >=4 && <5, purescript -any, bytestring -any, aeson -any, optparse-applicative -any

208 main-is: Main.hs

209 buildable: True

210 hs-source-dirs: psc-publish

211− ghc-options: -Wall -O2

211+ ghc-options: -Wall -Werror -O2

212

213executable psc-hierarchy

214 build-depends: base >=4 && <5, purescript -any, optparse-applicative >= 0.10.0,

@@ -218,7 +218,7 @@ executable psc-hierarchy

218 buildable: True

219 hs-source-dirs: hierarchy

220 other-modules:

221− ghc-options: -Wall -O2

221+ ghc-options: -Wall -Werror -O2

222

223executable psc-bundle

224 main-is: Main.hs

@@ -233,7 +233,7 @@ executable psc-bundle

233 transformers-compat -any,

234 optparse-applicative >= 0.10.0,

235 Glob -any

236− ghc-options: -Wall -O2

236+ ghc-options: -Wall -Werror -O2

237 hs-source-dirs: psc-bundle

238

239test-suite tests

src/Control/Monad/Supply.hs+3

@@ -14,12 +14,15 @@

14-----------------------------------------------------------------------------

15

16{-# LANGUAGE GeneralizedNewtypeDeriving #-}

17+{-# LANGUAGE CPP #-}

17

18

18module Control.Monad.Supply where

19module Control.Monad.Supply where

19

20

20import Data.Functor.Identity

21import Data.Functor.Identity

21

22

23+#if __GLASGOW_HASKELL__ < 710

22import Control.Applicative

24import Control.Applicative

25+#endif

23import Control.Monad.State

26import Control.Monad.State

24import Control.Monad.Error.Class (MonadError(..))

27import Control.Monad.Error.Class (MonadError(..))

25import Control.Monad.Reader

28import Control.Monad.Reader

src/Language/PureScript/AST/Declarations.hs+5−1

@@ -12,7 +12,9 @@

12--

13-----------------------------------------------------------------------------

14

15−{-# LANGUAGE DeriveDataTypeable, ScopedTypeVariables #-}

15+{-# LANGUAGE DeriveDataTypeable #-}

16+{-# LANGUAGE ScopedTypeVariables #-}

17+{-# LANGUAGE CPP #-}

16

18

17module Language.PureScript.AST.Declarations where

19module Language.PureScript.AST.Declarations where

18

20

@@ -21,7 +23,9 @@ import qualified Data.Map as M

21

23

22import Control.Monad.Identity

24import Control.Monad.Identity

23

25

26+#if __GLASGOW_HASKELL__ < 710

24import Control.Applicative

27import Control.Applicative

28+#endif

25

29

26import Language.PureScript.AST.Binders

30import Language.PureScript.AST.Binders

27import Language.PureScript.AST.Operators

31import Language.PureScript.AST.Operators

src/Language/PureScript/AST/SourcePos.hs+4−1

@@ -12,7 +12,10 @@

12--

13-----------------------------------------------------------------------------

14

15−{-# LANGUAGE DeriveDataTypeable, ScopedTypeVariables, RecordWildCards, OverloadedStrings #-}

15+{-# LANGUAGE DeriveDataTypeable #-}

16+{-# LANGUAGE ScopedTypeVariables #-}

17+{-# LANGUAGE RecordWildCards #-}

18+{-# LANGUAGE OverloadedStrings #-}

16

19

17module Language.PureScript.AST.SourcePos where

20module Language.PureScript.AST.SourcePos where

18

21

src/Language/PureScript/AST/Traversals.hs+8

@@ -12,13 +12,21 @@

12--

13-----------------------------------------------------------------------------

14

15+{-# LANGUAGE CPP #-}

16+

15module Language.PureScript.AST.Traversals where

17module Language.PureScript.AST.Traversals where

16

18

19+#if __GLASGOW_HASKELL__ < 710

17import Data.Monoid (Monoid(..), mconcat)

20import Data.Monoid (Monoid(..), mconcat)

21+#endif

18import Data.Maybe (mapMaybe)

22import Data.Maybe (mapMaybe)

23+#if __GLASGOW_HASKELL__ < 710

19import Data.Traversable (traverse)

24import Data.Traversable (traverse)

25+#endif

20

26

27+#if __GLASGOW_HASKELL__ < 710

21import Control.Applicative

28import Control.Applicative

29+#endif

22import Control.Monad

30import Control.Monad

23import Control.Arrow ((***), (+++), second)

31import Control.Arrow ((***), (+++), second)

24

32

src/Language/PureScript/Bundle.hs+3

@@ -20,6 +20,7 @@

20{-# LANGUAGE ScopedTypeVariables #-}

21{-# LANGUAGE TupleSections #-}

22{-# LANGUAGE RecordWildCards #-}

23+{-# LANGUAGE CPP #-}

23

24

24module Language.PureScript.Bundle (

25module Language.PureScript.Bundle (

25 bundle

26 bundle

@@ -38,7 +39,9 @@ import Data.Version (showVersion)

38

39

39import qualified Data.Set as S

40import qualified Data.Set as S

40

41

42+#if __GLASGOW_HASKELL__ < 710

41import Control.Applicative

43import Control.Applicative

44+#endif

42import Control.Monad

45import Control.Monad

43import Control.Monad.Error.Class

46import Control.Monad.Error.Class

44import Language.JavaScript.Parser

47import Language.JavaScript.Parser

src/Language/PureScript/CodeGen/JS.hs+3

@@ -17,6 +17,7 @@

17{-# LANGUAGE ViewPatterns #-}

18{-# LANGUAGE FlexibleContexts #-}

19{-# LANGUAGE ScopedTypeVariables #-}

20+{-# LANGUAGE CPP #-}

20

21

21module Language.PureScript.CodeGen.JS

22module Language.PureScript.CodeGen.JS

22 ( module AST

23 ( module AST

@@ -28,7 +29,9 @@ module Language.PureScript.CodeGen.JS

28import Data.List ((\\), delete, intersect)

29import Data.List ((\\), delete, intersect)

29import qualified Data.Traversable as T (traverse)

30import qualified Data.Traversable as T (traverse)

30

31

32+#if __GLASGOW_HASKELL__ < 710

31import Control.Applicative

33import Control.Applicative

34+#endif

32import Control.Arrow ((&&&))

35import Control.Arrow ((&&&))

33import Control.Monad (replicateM, forM)

36import Control.Monad (replicateM, forM)

34import Control.Monad.Reader (MonadReader, asks)

37import Control.Monad.Reader (MonadReader, asks)

src/Language/PureScript/CodeGen/JS/AST.hs+5

@@ -14,13 +14,18 @@

14-----------------------------------------------------------------------------

15

16{-# LANGUAGE DeriveDataTypeable #-}

17+{-# LANGUAGE CPP #-}

17

18

18module Language.PureScript.CodeGen.JS.AST where

19module Language.PureScript.CodeGen.JS.AST where

19

20

21+#if __GLASGOW_HASKELL__ < 710

20import Control.Applicative (Applicative, (<$>), (<*>))

22import Control.Applicative (Applicative, (<$>), (<*>))

23+#endif

21import Control.Monad.Identity

24import Control.Monad.Identity

22import Data.Data

25import Data.Data

26+#if __GLASGOW_HASKELL__ < 710

23import Data.Traversable (traverse)

27import Data.Traversable (traverse)

28+#endif

24

29

25import Language.PureScript.Comments

30import Language.PureScript.Comments

26import Language.PureScript.Traversals

31import Language.PureScript.Traversals

src/Language/PureScript/CodeGen/JS/Optimizer.hs+3

@@ -32,12 +32,15 @@

32-----------------------------------------------------------------------------

33

34{-# LANGUAGE FlexibleContexts #-}

35+{-# LANGUAGE CPP #-}

35

36

36module Language.PureScript.CodeGen.JS.Optimizer (

37module Language.PureScript.CodeGen.JS.Optimizer (

37 optimize

38 optimize

38) where

39) where

39

40

41+#if __GLASGOW_HASKELL__ < 710

40import Control.Applicative (Applicative)

42import Control.Applicative (Applicative)

43+#endif

41import Control.Monad.Reader (MonadReader, ask, asks)

44import Control.Monad.Reader (MonadReader, ask, asks)

42import Control.Monad.Supply.Class (MonadSupply)

45import Control.Monad.Supply.Class (MonadSupply)

43

46

src/Language/PureScript/CodeGen/JS/Optimizer/Inliner.hs+4

@@ -13,6 +13,8 @@

13--

14-----------------------------------------------------------------------------

15

16+{-# LANGUAGE CPP #-}

17+

16module Language.PureScript.CodeGen.JS.Optimizer.Inliner (

18module Language.PureScript.CodeGen.JS.Optimizer.Inliner (

17 inlineVariables,

19 inlineVariables,

18 inlineValues,

20 inlineValues,

@@ -24,7 +26,9 @@ module Language.PureScript.CodeGen.JS.Optimizer.Inliner (

24 evaluateIifes

26 evaluateIifes

25) where

27) where

26

28

29+#if __GLASGOW_HASKELL__ < 710

27import Control.Applicative (Applicative)

30import Control.Applicative (Applicative)

31+#endif

28import Control.Monad.Supply.Class (MonadSupply, freshName)

32import Control.Monad.Supply.Class (MonadSupply, freshName)

29import Data.Maybe (fromMaybe)

33import Data.Maybe (fromMaybe)

30

34

src/Language/PureScript/Docs/ParseAndDesugar.hs+3

@@ -1,4 +1,5 @@

1{-# LANGUAGE TupleSections #-}

2+{-# LANGUAGE CPP #-}

2

3

3module Language.PureScript.Docs.ParseAndDesugar

4module Language.PureScript.Docs.ParseAndDesugar

4 ( parseAndDesugar

5 ( parseAndDesugar

@@ -8,7 +9,9 @@ module Language.PureScript.Docs.ParseAndDesugar

8import qualified Data.Map as M

9import qualified Data.Map as M

9import Control.Arrow (first)

10import Control.Arrow (first)

10import Control.Monad

11import Control.Monad

12+#if __GLASGOW_HASKELL__ < 710

11import Control.Applicative

13import Control.Applicative

14+#endif

12

15

13import Control.Monad.Trans.Except

16import Control.Monad.Trans.Except

14import Control.Monad.Writer.Strict (runWriterT)

17import Control.Monad.Writer.Strict (runWriterT)

src/Language/PureScript/Docs/RenderedCode/Render.hs+5

@@ -1,3 +1,4 @@

1+{-# LANGUAGE CPP #-}

1

2

2-- | Functions for producing RenderedCode values from PureScript Type values.

3-- | Functions for producing RenderedCode values from PureScript Type values.

3

4

@@ -11,7 +12,11 @@ module Language.PureScript.Docs.RenderedCode.Render (

11 renderTypeWithOptions

12 renderTypeWithOptions

12) where

13) where

13

14

15+#if __GLASGOW_HASKELL__ < 710

14import Data.Monoid ((<>), mconcat, mempty)

16import Data.Monoid ((<>), mconcat, mempty)

17+#else

18+import Data.Monoid ((<>))

19+#endif

15import Data.Maybe (fromMaybe)

20import Data.Maybe (fromMaybe)

16

21

17import Control.Arrow ((<+>))

22import Control.Arrow ((<+>))

src/Language/PureScript/Docs/RenderedCode/Types.hs+3

@@ -1,5 +1,6 @@

1{-# LANGUAGE GeneralizedNewtypeDeriving #-}

2{-# LANGUAGE OverloadedStrings #-}

3+{-# LANGUAGE CPP #-}

3

4

4-- | Data types and functions for representing a simplified form of PureScript

5-- | Data types and functions for representing a simplified form of PureScript

5-- code, intended for use in e.g. HTML documentation.

6-- code, intended for use in e.g. HTML documentation.

@@ -30,9 +31,11 @@ module Language.PureScript.Docs.RenderedCode.Types

30 , keywordWhere

31 , keywordWhere

31 ) where

32 ) where

32

33

34+#if __GLASGOW_HASKELL__ < 710

33import Control.Applicative ((<$>), (<*>), (*>), pure)

35import Control.Applicative ((<$>), (<*>), (*>), pure)

34import Data.Foldable

36import Data.Foldable

35import Data.Monoid

37import Data.Monoid

38+#endif

36import qualified Data.Aeson as A

39import qualified Data.Aeson as A

37import Data.Aeson.BetterErrors

40import Data.Aeson.BetterErrors

38import Control.Monad.Error.Class (MonadError(..))

41import Control.Monad.Error.Class (MonadError(..))

src/Language/PureScript/Docs/Types.hs+4−2

@@ -2,6 +2,7 @@

2{-# LANGUAGE OverloadedStrings #-}

3{-# LANGUAGE TupleSections #-}

4{-# LANGUAGE RankNTypes #-}

5+{-# LANGUAGE CPP #-}

5

6

6module Language.PureScript.Docs.Types

7module Language.PureScript.Docs.Types

7 ( module Language.PureScript.Docs.Types

8 ( module Language.PureScript.Docs.Types

@@ -10,9 +11,10 @@ module Language.PureScript.Docs.Types

10 where

11 where

11

12

12import Control.Arrow (first, (***))

13import Control.Arrow (first, (***))

14+#if __GLASGOW_HASKELL__ < 710

13−import Control.Applicative ((<$>), (<*>), pure)

15+import Control.Applicative ((<$>), (<$), (<*>), pure)

16+#endif

14import Control.Monad (when)

17import Control.Monad (when)

15−import Data.Functor ((<$))

16import Data.Maybe (mapMaybe)

18import Data.Maybe (mapMaybe)

17import Data.Version

19import Data.Version

18import Data.Aeson ((.=))

20import Data.Aeson ((.=))

src/Language/PureScript/Errors.hs+7−1

@@ -15,14 +15,18 @@

15{-# LANGUAGE GeneralizedNewtypeDeriving #-}

16{-# LANGUAGE FlexibleContexts #-}

17{-# LANGUAGE MultiParamTypeClasses #-}

18+{-# LANGUAGE CPP #-}

18

19

19module Language.PureScript.Errors where

20module Language.PureScript.Errors where

20

21

21import Data.Either (lefts, rights)

22import Data.Either (lefts, rights)

22import Data.List (intercalate, transpose)

23import Data.List (intercalate, transpose)

23import Data.Function (on)

24import Data.Function (on)

24−import Data.Monoid

25+#if __GLASGOW_HASKELL__ < 710

25import Data.Foldable (fold, foldMap)

26import Data.Foldable (fold, foldMap)

27+#else

28+import Data.Foldable (fold)

29+#endif

26

30

27import qualified Data.Map as M

31import qualified Data.Map as M

28

32

@@ -30,7 +34,9 @@ import Control.Monad

30import Control.Monad.Unify

34import Control.Monad.Unify

31import Control.Monad.Writer

35import Control.Monad.Writer

32import Control.Monad.Error.Class (MonadError(..))

36import Control.Monad.Error.Class (MonadError(..))

37+#if __GLASGOW_HASKELL__ < 710

33import Control.Applicative ((<$>), (<*>), Applicative, pure)

38import Control.Applicative ((<$>), (<*>), Applicative, pure)

39+#endif

34import Control.Monad.Trans.State.Lazy

40import Control.Monad.Trans.State.Lazy

35import Control.Arrow(first)

41import Control.Arrow(first)

36

42

src/Language/PureScript/Kinds.hs+3

@@ -14,13 +14,16 @@

14

15{-# LANGUAGE DeriveDataTypeable #-}

16{-# LANGUAGE TemplateHaskell #-}

17+{-# LANGUAGE CPP #-}

17

18

18module Language.PureScript.Kinds where

19module Language.PureScript.Kinds where

19

20

20import Data.Data

21import Data.Data

21import qualified Data.Aeson.TH as A

22import qualified Data.Aeson.TH as A

22

23

24+#if __GLASGOW_HASKELL__ < 710

23import Control.Applicative

25import Control.Applicative

26+#endif

24import Control.Monad.Unify (Unknown)

27import Control.Monad.Unify (Unknown)

25

28

26-- |

29-- |

src/Language/PureScript/Linter.hs+3

@@ -15,6 +15,7 @@

15{-# LANGUAGE GeneralizedNewtypeDeriving #-}

16{-# LANGUAGE FlexibleContexts #-}

17{-# LANGUAGE ScopedTypeVariables #-}

18+{-# LANGUAGE CPP #-}

18

19

19module Language.PureScript.Linter (lint, module L) where

20module Language.PureScript.Linter (lint, module L) where

20

21

@@ -24,7 +25,9 @@ import Data.Monoid

24

25

25import qualified Data.Set as S

26import qualified Data.Set as S

26

27

28+#if __GLASGOW_HASKELL__ < 710

27import Control.Applicative

29import Control.Applicative

30+#endif

28import Control.Monad.Writer.Class

31import Control.Monad.Writer.Class

29

32

30import Language.PureScript.AST

33import Language.PureScript.AST

src/Language/PureScript/Linter/Exhaustive.hs+3

@@ -18,6 +18,7 @@

18

19{-# LANGUAGE FlexibleContexts #-}

20{-# LANGUAGE ScopedTypeVariables #-}

21+{-# LANGUAGE CPP #-}

21

22

22module Language.PureScript.Linter.Exhaustive

23module Language.PureScript.Linter.Exhaustive

23 ( checkExhaustive

24 ( checkExhaustive

@@ -237,8 +238,10 @@ checkExhaustive env mn numArgs cas = makeResult . first nub $ foldl' step ([init

237 cond = or <$> sequenceA pr

238 cond = or <$> sequenceA pr

238 in (concat missed, (liftA2 (&&) cond nec,

239 in (concat missed, (liftA2 (&&) cond nec,

239 if fromMaybe True cond then redundant else caseAlternativeBinders ca : redundant))

240 if fromMaybe True cond then redundant else caseAlternativeBinders ca : redundant))

241+#if __GLASGOW_HASKELL__ < 710

240 where

242 where

241 sequenceA = foldr (liftA2 (:)) (pure [])

243 sequenceA = foldr (liftA2 (:)) (pure [])

244+#endif

242

245

243 makeResult :: ([[Binder]], (Maybe Bool, [[Binder]])) -> m ()

246 makeResult :: ([[Binder]], (Maybe Bool, [[Binder]])) -> m ()

244 makeResult (bss, (_, bss')) =

247 makeResult (bss, (_, bss')) =

src/Language/PureScript/Make.hs+5

@@ -19,6 +19,7 @@

19{-# LANGUAGE RankNTypes #-}

20{-# LANGUAGE RecordWildCards #-}

21{-# LANGUAGE ScopedTypeVariables #-}

22+{-# LANGUAGE CPP #-}

22

23

23module Language.PureScript.Make

24module Language.PureScript.Make

24 (

25 (

@@ -35,7 +36,9 @@ module Language.PureScript.Make

35 , buildMakeActions

36 , buildMakeActions

36 ) where

37 ) where

37

38

39+#if __GLASGOW_HASKELL__ < 710

38import Control.Applicative

40import Control.Applicative

41+#endif

39import Control.Arrow ((&&&))

42import Control.Arrow ((&&&))

40import Control.Monad

43import Control.Monad

41import Control.Monad.Error.Class (MonadError(..))

44import Control.Monad.Error.Class (MonadError(..))

@@ -49,7 +52,9 @@ import Data.List (sortBy, groupBy)

49import Data.Maybe (fromMaybe)

52import Data.Maybe (fromMaybe)

50import Data.Time.Clock

53import Data.Time.Clock

51import Data.Foldable (for_)

54import Data.Foldable (for_)

55+#if __GLASGOW_HASKELL__ < 710

52import Data.Traversable (traverse)

56import Data.Traversable (traverse)

57+#endif

53import Data.Version (showVersion)

58import Data.Version (showVersion)

54import qualified Data.Map as M

59import qualified Data.Map as M

55import qualified Data.Set as S

60import qualified Data.Set as S

src/Language/PureScript/Names.hs+3−1

@@ -13,7 +13,9 @@

13--

14-----------------------------------------------------------------------------

15

16−{-# LANGUAGE DeriveDataTypeable, DeriveFunctor, GADTs #-}

16+{-# LANGUAGE DeriveDataTypeable #-}

17+{-# LANGUAGE DeriveFunctor #-}

18+{-# LANGUAGE GADTs #-}

17

19

18module Language.PureScript.Names where

20module Language.PureScript.Names where

19

21

src/Language/PureScript/Parser/JS.hs+3

@@ -13,13 +13,16 @@

13-----------------------------------------------------------------------------

14

15{-# LANGUAGE FlexibleContexts #-}

16+{-# LANGUAGE CPP #-}

16

17

17module Language.PureScript.Parser.JS

18module Language.PureScript.Parser.JS

18 ( ForeignJS()

19 ( ForeignJS()

19 , parseForeignModulesFromFiles

20 , parseForeignModulesFromFiles

20 ) where

21 ) where

21

22

23+#if __GLASGOW_HASKELL__ < 710

22import Control.Applicative ((*>), (<*))

24import Control.Applicative ((*>), (<*))

25+#endif

23import Control.Monad (forM_, when, msum)

26import Control.Monad (forM_, when, msum)

24import Control.Monad.Error.Class (MonadError(..))

27import Control.Monad.Error.Class (MonadError(..))

25import Control.Monad.Writer.Class (MonadWriter(..))

28import Control.Monad.Writer.Class (MonadWriter(..))

src/Language/PureScript/Parser/Kinds.hs+4

@@ -13,6 +13,8 @@

13--

14-----------------------------------------------------------------------------

15

16+{-# LANGUAGE CPP #-}

17+

16module Language.PureScript.Parser.Kinds (

18module Language.PureScript.Parser.Kinds (

17 parseKind

19 parseKind

18) where

20) where

@@ -20,7 +22,9 @@ module Language.PureScript.Parser.Kinds (

20import Language.PureScript.Kinds

22import Language.PureScript.Kinds

21import Language.PureScript.Parser.Common

23import Language.PureScript.Parser.Common

22import Language.PureScript.Parser.Lexer

24import Language.PureScript.Parser.Lexer

25+#if __GLASGOW_HASKELL__ < 710

23import Control.Applicative

26import Control.Applicative

27+#endif

24import qualified Text.Parsec as P

28import qualified Text.Parsec as P

25import qualified Text.Parsec.Expr as P

29import qualified Text.Parsec.Expr as P

26

30

src/Language/PureScript/Pretty/JS.hs+4

@@ -13,6 +13,8 @@

13--

14-----------------------------------------------------------------------------

15

16+{-# LANGUAGE CPP #-}

17+

16module Language.PureScript.Pretty.JS (

18module Language.PureScript.Pretty.JS (

17 prettyPrintJS

19 prettyPrintJS

18) where

20) where

@@ -20,7 +22,9 @@ module Language.PureScript.Pretty.JS (

20import Data.List

22import Data.List

21import Data.Maybe (fromMaybe)

23import Data.Maybe (fromMaybe)

22

24

25+#if __GLASGOW_HASKELL__ < 710

23import Control.Applicative

26import Control.Applicative

27+#endif

24import Control.Arrow ((<+>))

28import Control.Arrow ((<+>))

25import Control.Monad.State

29import Control.Monad.State

26import Control.PatternArrows

30import Control.PatternArrows

src/Language/PureScript/Pretty/Values.hs+4

@@ -13,6 +13,8 @@

13--

14-----------------------------------------------------------------------------

15

16+{-# LANGUAGE CPP #-}

17+

16module Language.PureScript.Pretty.Values (

18module Language.PureScript.Pretty.Values (

17 prettyPrintValue,

19 prettyPrintValue,

18 prettyPrintBinder,

20 prettyPrintBinder,

@@ -25,7 +27,9 @@ import Data.List (intercalate)

25import Control.Arrow ((<+>), runKleisli, second)

27import Control.Arrow ((<+>), runKleisli, second)

26import Control.PatternArrows

28import Control.PatternArrows

27import Control.Monad.State

29import Control.Monad.State

30+#if __GLASGOW_HASKELL__ < 710

28import Control.Applicative

31import Control.Applicative

32+#endif

29

33

30import Language.PureScript.AST

34import Language.PureScript.AST

31import Language.PureScript.Names

35import Language.PureScript.Names

src/Language/PureScript/Publish.hs+3

@@ -2,6 +2,7 @@

2{-# LANGUAGE RecordWildCards #-}

3{-# LANGUAGE TupleSections #-}

4{-# LANGUAGE GeneralizedNewtypeDeriving #-}

5+{-# LANGUAGE CPP #-}

5

6

6module Language.PureScript.Publish

7module Language.PureScript.Publish

7 ( preparePackage

8 ( preparePackage

@@ -32,7 +33,9 @@ import Safe (headMay)

32import Data.Aeson.BetterErrors

33import Data.Aeson.BetterErrors

33import qualified Data.Text as T

34import qualified Data.Text as T

34

35

36+#if __GLASGOW_HASKELL__ < 710

35import Control.Applicative

37import Control.Applicative

38+#endif

36import Control.Category ((>>>))

39import Control.Category ((>>>))

37import Control.Arrow ((***))

40import Control.Arrow ((***))

38import Control.Exception (catch, try)

41import Control.Exception (catch, try)

src/Language/PureScript/Publish/ErrorsWarnings.hs+5

@@ -1,5 +1,6 @@

1{-# LANGUAGE OverloadedStrings #-}

2{-# LANGUAGE RecordWildCards #-}

3+{-# LANGUAGE CPP #-}

3

4

4module Language.PureScript.Publish.ErrorsWarnings

5module Language.PureScript.Publish.ErrorsWarnings

5 ( PackageError(..)

6 ( PackageError(..)

@@ -15,12 +16,16 @@ module Language.PureScript.Publish.ErrorsWarnings

15 , renderWarnings

16 , renderWarnings

16 ) where

17 ) where

17

18

19+#if __GLASGOW_HASKELL__ < 710

18import Control.Applicative ((<$>))

20import Control.Applicative ((<$>))

21+#endif

19import Data.Aeson.BetterErrors

22import Data.Aeson.BetterErrors

20import Data.Version

23import Data.Version

21import Data.Maybe

24import Data.Maybe

22import Data.Monoid

25import Data.Monoid

26+#if __GLASGOW_HASKELL__ < 710

23import Data.Foldable (foldMap)

27import Data.Foldable (foldMap)

28+#endif

24import Data.List (intersperse, intercalate)

29import Data.List (intersperse, intercalate)

25import Data.List.NonEmpty (NonEmpty(..))

30import Data.List.NonEmpty (NonEmpty(..))

26import qualified Data.List.NonEmpty as NonEmpty

31import qualified Data.List.NonEmpty as NonEmpty

src/Language/PureScript/Renamer.hs+5−1

@@ -14,11 +14,15 @@

14--

15-----------------------------------------------------------------------------

16

17−{-# LANGUAGE FlexibleContexts, ScopedTypeVariables #-}

17+{-# LANGUAGE FlexibleContexts #-}

18+{-# LANGUAGE ScopedTypeVariables #-}

19+{-# LANGUAGE CPP #-}

18

20

19module Language.PureScript.Renamer (renameInModules) where

21module Language.PureScript.Renamer (renameInModules) where

20

22

23+#if __GLASGOW_HASKELL__ < 710

21import Control.Applicative

24import Control.Applicative

25+#endif

22import Control.Monad.State

26import Control.Monad.State

23

27

24import Data.List (find)

28import Data.List (find)

src/Language/PureScript/Sugar.hs+3

@@ -14,12 +14,15 @@

14-----------------------------------------------------------------------------

15

16{-# LANGUAGE FlexibleContexts #-}

17+{-# LANGUAGE CPP #-}

17

18

18module Language.PureScript.Sugar (desugar, module S) where

19module Language.PureScript.Sugar (desugar, module S) where

19

20

20import Control.Monad

21import Control.Monad

21import Control.Category ((>>>))

22import Control.Category ((>>>))

23+#if __GLASGOW_HASKELL__ < 710

22import Control.Applicative

24import Control.Applicative

25+#endif

23import Control.Monad.Error.Class (MonadError())

26import Control.Monad.Error.Class (MonadError())

24import Control.Monad.Writer.Class (MonadWriter())

27import Control.Monad.Writer.Class (MonadWriter())

25import Control.Monad.Supply.Class

28import Control.Monad.Supply.Class

src/Language/PureScript/Sugar/BindingGroups.hs+3

@@ -15,6 +15,7 @@

15-----------------------------------------------------------------------------

16

17{-# LANGUAGE FlexibleContexts #-}

18+{-# LANGUAGE CPP #-}

18

19

19module Language.PureScript.Sugar.BindingGroups (

20module Language.PureScript.Sugar.BindingGroups (

20 createBindingGroups,

21 createBindingGroups,

@@ -26,7 +27,9 @@ module Language.PureScript.Sugar.BindingGroups (

26import Data.Graph

27import Data.Graph

27import Data.List (nub, intersect)

28import Data.List (nub, intersect)

28import Data.Maybe (isJust, mapMaybe)

29import Data.Maybe (isJust, mapMaybe)

30+#if __GLASGOW_HASKELL__ < 710

29import Control.Applicative

31import Control.Applicative

32+#endif

30import Control.Monad ((<=<))

33import Control.Monad ((<=<))

31import Control.Monad.Error.Class (MonadError(..))

34import Control.Monad.Error.Class (MonadError(..))

32

35

src/Language/PureScript/Sugar/CaseDeclarations.hs+5−1

@@ -14,7 +14,9 @@

14--

15-----------------------------------------------------------------------------

16

17−{-# LANGUAGE FlexibleContexts, ScopedTypeVariables #-}

17+{-# LANGUAGE FlexibleContexts #-}

18+{-# LANGUAGE ScopedTypeVariables #-}

19+{-# LANGUAGE CPP #-}

18

20

19module Language.PureScript.Sugar.CaseDeclarations (

21module Language.PureScript.Sugar.CaseDeclarations (

20 desugarCases,

22 desugarCases,

@@ -24,7 +26,9 @@ module Language.PureScript.Sugar.CaseDeclarations (

24import Data.Maybe (catMaybes)

26import Data.Maybe (catMaybes)

25import Data.List (nub, groupBy)

27import Data.List (nub, groupBy)

26

28

29+#if __GLASGOW_HASKELL__ < 710

27import Control.Applicative

30import Control.Applicative

31+#endif

28import Control.Monad ((<=<), forM, replicateM, join, unless)

32import Control.Monad ((<=<), forM, replicateM, join, unless)

29import Control.Monad.Error.Class (MonadError(..))

33import Control.Monad.Error.Class (MonadError(..))

30import Control.Monad.Supply.Class

34import Control.Monad.Supply.Class

src/Language/PureScript/Sugar/DoNotation.hs+3

@@ -16,6 +16,7 @@

16

17{-# LANGUAGE FlexibleContexts #-}

18{-# LANGUAGE ScopedTypeVariables #-}

19+{-# LANGUAGE CPP #-}

19

20

20module Language.PureScript.Sugar.DoNotation (

21module Language.PureScript.Sugar.DoNotation (

21 desugarDoModule

22 desugarDoModule

@@ -27,7 +28,9 @@ import Language.PureScript.Errors

27

28

28import qualified Language.PureScript.Constants as C

29import qualified Language.PureScript.Constants as C

29

30

31+#if __GLASGOW_HASKELL__ < 710

30import Control.Applicative

32import Control.Applicative

33+#endif

31import Control.Monad.Error.Class (MonadError(..))

34import Control.Monad.Error.Class (MonadError(..))

32import Control.Monad.Supply.Class

35import Control.Monad.Supply.Class

33

36

src/Language/PureScript/Sugar/Names.hs+3

@@ -15,6 +15,7 @@

15{-# LANGUAGE FlexibleContexts #-}

16{-# LANGUAGE ScopedTypeVariables #-}

17{-# LANGUAGE PatternGuards #-}

18+{-# LANGUAGE CPP #-}

18

19

19module Language.PureScript.Sugar.Names (

20module Language.PureScript.Sugar.Names (

20 desugarImports

21 desugarImports

@@ -23,7 +24,9 @@ module Language.PureScript.Sugar.Names (

23import Data.List (find, nub, (\\))

24import Data.List (find, nub, (\\))

24import Data.Maybe (catMaybes, fromMaybe, isJust, isNothing, mapMaybe)

25import Data.Maybe (catMaybes, fromMaybe, isJust, isNothing, mapMaybe)

25

26

27+#if __GLASGOW_HASKELL__ < 710

26import Control.Applicative (Applicative(..), (<$>), (<*>))

28import Control.Applicative (Applicative(..), (<$>), (<*>))

29+#endif

27import Control.Monad

30import Control.Monad

28import Control.Monad.Error.Class (MonadError(..))

31import Control.Monad.Error.Class (MonadError(..))

29import Control.Monad.Writer (MonadWriter(..), censor)

32import Control.Monad.Writer (MonadWriter(..), censor)

src/Language/PureScript/Sugar/ObjectWildcards.hs+3

@@ -14,12 +14,15 @@

14

15{-# LANGUAGE FlexibleContexts #-}

16{-# LANGUAGE ScopedTypeVariables #-}

17+{-# LANGUAGE CPP #-}

17

18

18module Language.PureScript.Sugar.ObjectWildcards (

19module Language.PureScript.Sugar.ObjectWildcards (

19 desugarObjectConstructors

20 desugarObjectConstructors

20) where

21) where

21

22

23+#if __GLASGOW_HASKELL__ < 710

22import Control.Applicative

24import Control.Applicative

25+#endif

23import Control.Arrow (second)

26import Control.Arrow (second)

24import Control.Monad.Error.Class (MonadError(..))

27import Control.Monad.Error.Class (MonadError(..))

25import Control.Monad.Supply.Class

28import Control.Monad.Supply.Class

src/Language/PureScript/Sugar/Operators.hs+3

@@ -20,6 +20,7 @@

20{-# LANGUAGE Rank2Types #-}

21{-# LANGUAGE FlexibleContexts #-}

22{-# LANGUAGE ScopedTypeVariables #-}

23+{-# LANGUAGE CPP #-}

23

24

24module Language.PureScript.Sugar.Operators (

25module Language.PureScript.Sugar.Operators (

25 rebracket,

26 rebracket,

@@ -31,7 +32,9 @@ import Language.PureScript.AST

31import Language.PureScript.Errors

32import Language.PureScript.Errors

32import Language.PureScript.Names

33import Language.PureScript.Names

33

34

35+#if __GLASGOW_HASKELL__ < 710

34import Control.Applicative

36import Control.Applicative

37+#endif

35import Control.Monad.State

38import Control.Monad.State

36import Control.Monad.Error.Class (MonadError(..))

39import Control.Monad.Error.Class (MonadError(..))

37import Control.Monad.Supply.Class

40import Control.Monad.Supply.Class

src/Language/PureScript/Sugar/TypeClasses.hs+3

@@ -15,6 +15,7 @@

15-----------------------------------------------------------------------------

16

17{-# LANGUAGE FlexibleContexts #-}

18+{-# LANGUAGE CPP #-}

18

19

19module Language.PureScript.Sugar.TypeClasses

20module Language.PureScript.Sugar.TypeClasses

20 ( desugarTypeClasses

21 ( desugarTypeClasses

@@ -33,7 +34,9 @@ import Language.PureScript.Types

33

34

34import qualified Language.PureScript.Constants as C

35import qualified Language.PureScript.Constants as C

35

36

37+#if __GLASGOW_HASKELL__ < 710

36import Control.Applicative

38import Control.Applicative

39+#endif

37import Control.Arrow (first, second)

40import Control.Arrow (first, second)

38import Control.Monad.Error.Class (MonadError(..))

41import Control.Monad.Error.Class (MonadError(..))

39import Control.Monad.State

42import Control.Monad.State

src/Language/PureScript/Sugar/TypeClasses/Deriving.hs+3

@@ -19,6 +19,7 @@

19{-# LANGUAGE PatternGuards #-}

20{-# LANGUAGE RankNTypes #-}

21{-# LANGUAGE ScopedTypeVariables #-}

22+{-# LANGUAGE CPP #-}

22

23

23module Language.PureScript.Sugar.TypeClasses.Deriving (

24module Language.PureScript.Sugar.TypeClasses.Deriving (

24 deriveInstances

25 deriveInstances

@@ -28,7 +29,9 @@ import Data.List

28import Data.Maybe (fromMaybe)

29import Data.Maybe (fromMaybe)

29import Data.Ord (comparing)

30import Data.Ord (comparing)

30

31

32+#if __GLASGOW_HASKELL__ < 710

31import Control.Applicative

33import Control.Applicative

34+#endif

32import Control.Monad (replicateM)

35import Control.Monad (replicateM)

33import Control.Monad.Supply.Class (MonadSupply, freshName)

36import Control.Monad.Supply.Class (MonadSupply, freshName)

34import Control.Monad.Error.Class (MonadError(..))

37import Control.Monad.Error.Class (MonadError(..))

src/Language/PureScript/Sugar/TypeDeclarations.hs+3

@@ -15,13 +15,16 @@

15-----------------------------------------------------------------------------

16

17{-# LANGUAGE FlexibleContexts #-}

18+{-# LANGUAGE CPP #-}

18

19

19module Language.PureScript.Sugar.TypeDeclarations (

20module Language.PureScript.Sugar.TypeDeclarations (

20 desugarTypeDeclarations,

21 desugarTypeDeclarations,

21 desugarTypeDeclarationsModule

22 desugarTypeDeclarationsModule

22) where

23) where

23

24

25+#if __GLASGOW_HASKELL__ < 710

24import Control.Applicative

26import Control.Applicative

27+#endif

25import Control.Monad (forM)

28import Control.Monad (forM)

26import Control.Monad.Error.Class (MonadError(..))

29import Control.Monad.Error.Class (MonadError(..))

27

30

src/Language/PureScript/Traversals.hs+4

@@ -12,9 +12,13 @@

12--

13-----------------------------------------------------------------------------

14

15+{-# LANGUAGE CPP #-}

16+

15module Language.PureScript.Traversals where

17module Language.PureScript.Traversals where

16

18

19+#if __GLASGOW_HASKELL__ < 710

17import Control.Applicative

20import Control.Applicative

21+#endif

18

22

19fstM :: (Functor f) => (a -> f c) -> (a, b) -> f (c, b)

23fstM :: (Functor f) => (a -> f c) -> (a, b) -> f (c, b)

20fstM f (a, b) = flip (,) b <$> f a

24fstM f (a, b) = flip (,) b <$> f a

src/Language/PureScript/TypeChecker.hs+3

@@ -14,6 +14,7 @@

14-----------------------------------------------------------------------------

15

16{-# LANGUAGE FlexibleInstances #-}

17+{-# LANGUAGE CPP #-}

17

18

18module Language.PureScript.TypeChecker (

19module Language.PureScript.TypeChecker (

19 module T,

20 module T,

@@ -31,7 +32,9 @@ import Data.Foldable (for_)

31

32

32import qualified Data.Map as M

33import qualified Data.Map as M

33

34

35+#if __GLASGOW_HASKELL__ < 710

34import Control.Applicative ((<$>), (<*))

36import Control.Applicative ((<$>), (<*))

37+#endif

35import Control.Monad.State

38import Control.Monad.State

36import Control.Monad.Error.Class (MonadError(..))

39import Control.Monad.Error.Class (MonadError(..))

37

40

src/Language/PureScript/TypeChecker/Entailment.hs+3

@@ -14,6 +14,7 @@

14-----------------------------------------------------------------------------

15

16{-# LANGUAGE GeneralizedNewtypeDeriving #-}

17+{-# LANGUAGE CPP #-}

17

18

18module Language.PureScript.TypeChecker.Entailment (

19module Language.PureScript.TypeChecker.Entailment (

19 entails

20 entails

@@ -22,7 +23,9 @@ module Language.PureScript.TypeChecker.Entailment (

22import Data.Function (on)

23import Data.Function (on)

23import Data.List

24import Data.List

24import Data.Maybe (maybeToList)

25import Data.Maybe (maybeToList)

26+#if __GLASGOW_HASKELL__ < 710

25import Data.Foldable (foldMap)

27import Data.Foldable (foldMap)

28+#endif

26import qualified Data.Map as M

29import qualified Data.Map as M

27

30

28import Control.Applicative

31import Control.Applicative

src/Language/PureScript/TypeChecker/Kinds.hs+9−4

@@ -14,7 +14,10 @@

14-----------------------------------------------------------------------------

15

16{-# OPTIONS_GHC -fno-warn-orphans #-}

17−{-# LANGUAGE MultiParamTypeClasses, FlexibleInstances, TupleSections #-}

17+{-# LANGUAGE MultiParamTypeClasses #-}

18+{-# LANGUAGE FlexibleInstances #-}

19+{-# LANGUAGE TupleSections #-}

20+{-# LANGUAGE CPP #-}

18

21

19module Language.PureScript.TypeChecker.Kinds (

22module Language.PureScript.TypeChecker.Kinds (

20 kindOf,

23 kindOf,

@@ -29,7 +32,9 @@ import qualified Data.HashMap.Strict as H

29import qualified Data.Map as M

32import qualified Data.Map as M

30

33

31import Control.Arrow (second)

34import Control.Arrow (second)

35+#if __GLASGOW_HASKELL__ < 710

32import Control.Applicative

36import Control.Applicative

37+#endif

33import Control.Monad

38import Control.Monad

34import Control.Monad.Error.Class (MonadError(..))

39import Control.Monad.Error.Class (MonadError(..))

35import Control.Monad.State

40import Control.Monad.State

@@ -72,12 +77,12 @@ instance Unifiable Check Kind where

72--

77--

73kindOf :: ModuleName -> Type -> Check Kind

78kindOf :: ModuleName -> Type -> Check Kind

74kindOf _ ty = fst <$> kindOfWithScopedVars ty

79kindOf _ ty = fst <$> kindOfWithScopedVars ty

75−

80+

76-- |

81-- |

77-- Infer the kind of a single type, returning the kinds of any scoped type variables

82-- Infer the kind of a single type, returning the kinds of any scoped type variables

78--

83--

79−kindOfWithScopedVars :: Type -> Check (Kind, [(String, Kind)])

84+kindOfWithScopedVars :: Type -> Check (Kind, [(String, Kind)])

80−kindOfWithScopedVars ty =

85+kindOfWithScopedVars ty =

81 rethrow (onErrorMessages (ErrorCheckingKind ty)) $

86 rethrow (onErrorMessages (ErrorCheckingKind ty)) $

82 fmap tidyUp . liftUnify $ infer ty

87 fmap tidyUp . liftUnify $ infer ty

83 where

88 where

src/Language/PureScript/TypeChecker/Monad.hs+9−2

@@ -13,15 +13,22 @@

13--

14-----------------------------------------------------------------------------

15

16−{-# LANGUAGE GeneralizedNewtypeDeriving, FlexibleInstances, RankNTypes,

16+{-# LANGUAGE GeneralizedNewtypeDeriving #-}

17+{-# LANGUAGE FlexibleInstances #-}

18+{-# LANGUAGE RankNTypes #-}

17− MultiParamTypeClasses, FlexibleContexts, GADTs #-}

19+{-# LANGUAGE MultiParamTypeClasses #-}

20+{-# LANGUAGE FlexibleContexts #-}

21+{-# LANGUAGE GADTs #-}

22+{-# LANGUAGE CPP #-}

18

23

19module Language.PureScript.TypeChecker.Monad where

24module Language.PureScript.TypeChecker.Monad where

20

25

21import Data.Maybe

26import Data.Maybe

22import qualified Data.Map as M

27import qualified Data.Map as M

23

28

29+#if __GLASGOW_HASKELL__ < 710

24import Control.Applicative

30import Control.Applicative

31+#endif

25import Control.Monad.State

32import Control.Monad.State

26import Control.Monad.Unify

33import Control.Monad.Unify

27import Control.Monad.Writer.Strict

34import Control.Monad.Writer.Strict

src/Language/PureScript/TypeChecker/Skolems.hs+4

@@ -13,6 +13,8 @@

13--

14-----------------------------------------------------------------------------

15

16+{-# LANGUAGE CPP #-}

17+

16module Language.PureScript.TypeChecker.Skolems (

18module Language.PureScript.TypeChecker.Skolems (

17 newSkolemConstant,

19 newSkolemConstant,

18 introduceSkolemScope,

20 introduceSkolemScope,

@@ -25,7 +27,9 @@ module Language.PureScript.TypeChecker.Skolems (

25import Data.List (nub, (\\))

27import Data.List (nub, (\\))

26import Data.Monoid

28import Data.Monoid

27

29

30+#if __GLASGOW_HASKELL__ < 710

28import Control.Applicative

31import Control.Applicative

32+#endif

29import Control.Monad.Error.Class (MonadError(..))

33import Control.Monad.Error.Class (MonadError(..))

30import Control.Monad.Unify

34import Control.Monad.Unify

31

35

src/Language/PureScript/TypeChecker/Synonyms.hs+6−1

@@ -13,7 +13,10 @@

13--

14-----------------------------------------------------------------------------

15

16−{-# LANGUAGE FlexibleContexts, MultiParamTypeClasses, GADTs #-}

16+{-# LANGUAGE FlexibleContexts #-}

17+{-# LANGUAGE MultiParamTypeClasses #-}

18+{-# LANGUAGE GADTs #-}

19+{-# LANGUAGE CPP #-}

17

20

18module Language.PureScript.TypeChecker.Synonyms (

21module Language.PureScript.TypeChecker.Synonyms (

19 saturateAllTypeSynonyms,

22 saturateAllTypeSynonyms,

@@ -27,7 +30,9 @@ module Language.PureScript.TypeChecker.Synonyms (

27import Data.Maybe (fromMaybe)

30import Data.Maybe (fromMaybe)

28import qualified Data.Map as M

31import qualified Data.Map as M

29

32

33+#if __GLASGOW_HASKELL__ < 710

30import Control.Applicative

34import Control.Applicative

35+#endif

31import Control.Monad.Error.Class (MonadError(..))

36import Control.Monad.Error.Class (MonadError(..))

32import Control.Monad.State

37import Control.Monad.State

33

38

src/Language/PureScript/TypeChecker/Types.hs+6−1

@@ -13,7 +13,10 @@

13--

14-----------------------------------------------------------------------------

15

16−{-# LANGUAGE FlexibleContexts, MultiParamTypeClasses, OverloadedStrings #-}

16+{-# LANGUAGE FlexibleContexts #-}

17+{-# LANGUAGE MultiParamTypeClasses #-}

18+{-# LANGUAGE OverloadedStrings #-}

19+{-# LANGUAGE CPP #-}

17

20

18module Language.PureScript.TypeChecker.Types (

21module Language.PureScript.TypeChecker.Types (

19 typesOf

22 typesOf

@@ -40,7 +43,9 @@ import Data.List

40import Data.Maybe (fromMaybe)

43import Data.Maybe (fromMaybe)

41import qualified Data.Map as M

44import qualified Data.Map as M

42

45

46+#if __GLASGOW_HASKELL__ < 710

43import Control.Applicative

47import Control.Applicative

48+#endif

44import Control.Monad

49import Control.Monad

45import Control.Monad.State

50import Control.Monad.State

46import Control.Monad.Unify

51import Control.Monad.Unify

src/Language/PureScript/TypeChecker/Unify.hs+5−3

@@ -14,7 +14,9 @@

14-----------------------------------------------------------------------------

15

16{-# OPTIONS_GHC -fno-warn-orphans #-}

17−{-# LANGUAGE FlexibleInstances, FlexibleContexts, MultiParamTypeClasses #-}

17+{-# LANGUAGE FlexibleInstances #-}

18+{-# LANGUAGE FlexibleContexts #-}

19+{-# LANGUAGE MultiParamTypeClasses #-}

18

20

19module Language.PureScript.TypeChecker.Unify (

21module Language.PureScript.TypeChecker.Unify (

20 unifyTypes,

22 unifyTypes,

@@ -157,14 +159,14 @@ unifiesWith _ REmpty REmpty = True

157unifiesWith e r1@(RCons _ _ _) r2@(RCons _ _ _) =

159unifiesWith e r1@(RCons _ _ _) r2@(RCons _ _ _) =

158 let (s1, r1') = rowToList r1

160 let (s1, r1') = rowToList r1

159 (s2, r2') = rowToList r2

161 (s2, r2') = rowToList r2

160−

162+

161 int = [ (t1, t2) | (name, t1) <- s1, (name', t2) <- s2, name == name' ]

163 int = [ (t1, t2) | (name, t1) <- s1, (name', t2) <- s2, name == name' ]

162 sd1 = [ (name, t1) | (name, t1) <- s1, name `notElem` map fst s2 ]

164 sd1 = [ (name, t1) | (name, t1) <- s1, name `notElem` map fst s2 ]

163 sd2 = [ (name, t2) | (name, t2) <- s2, name `notElem` map fst s1 ]

165 sd2 = [ (name, t2) | (name, t2) <- s2, name `notElem` map fst s1 ]

164 in all (\(t1, t2) -> unifiesWith e t1 t2) int && go sd1 r1' sd2 r2'

166 in all (\(t1, t2) -> unifiesWith e t1 t2) int && go sd1 r1' sd2 r2'

165 where

167 where

166 go :: [(String, Type)] -> Type -> [(String, Type)] -> Type -> Bool

168 go :: [(String, Type)] -> Type -> [(String, Type)] -> Type -> Bool

167− go [] REmpty [] REmpty = True

169+ go [] REmpty [] REmpty = True

168 go [] (TypeVar v1) [] (TypeVar v2) = v1 == v2

170 go [] (TypeVar v1) [] (TypeVar v2) = v1 == v2

169 go [] (Skolem _ s1 _) [] (Skolem _ s2 _) = s1 == s2

171 go [] (Skolem _ s1 _) [] (Skolem _ s2 _) = s1 == s2

170 go _ (TUnknown _) _ _ = True

172 go _ (TUnknown _) _ _ = True

src/Language/PureScript/Types.hs+3

@@ -16,6 +16,7 @@

16{-# LANGUAGE DeriveDataTypeable #-}

17{-# LANGUAGE GeneralizedNewtypeDeriving #-}

18{-# LANGUAGE TemplateHaskell #-}

19+{-# LANGUAGE CPP #-}

19

20

20module Language.PureScript.Types where

21module Language.PureScript.Types where

21

22

@@ -26,7 +27,9 @@ import qualified Data.Aeson.TH as A

26

27

27import Control.Monad.Unify

28import Control.Monad.Unify

28import Control.Arrow (second)

29import Control.Arrow (second)

30+#if __GLASGOW_HASKELL__ < 710

29import Control.Applicative

31import Control.Applicative

32+#endif

30import Control.Monad ((<=<))

33import Control.Monad ((<=<))

31

34

32import Language.PureScript.Names

35import Language.PureScript.Names