feat[dev]: import Prelude

src/Language/Scalie/Core/Definition.hs

@@ -7,26 +7,26 @@
 {-# LANGUAGE OverloadedRecordDot #-}
 module Language.Scalie.Core.Definition (Definition(..)) where
 
+-- meta
 import Data.Kind (Type)
-import Data.Text (Text)
 
+-- data structures
+import Data.Text (Text)
+import Data.Functor.Identity (Identity)
 import Data.Map.Implicit (ImplicitKeyOf (KeyType, keyOf))
 
-import Language.Scalie.Domain.Type qualified as Scalie.Domain
+import Data.Text qualified as Text
+
+-- scalie
 import Language.Scalie.Core.Expression (Expression)
-import Text.Show (Show)
-import Text.Read (Read)
-import Data.Eq (Eq)
+import Language.Scalie.Core.Provenance (Provenance (value))
+
+import Language.Scalie.Domain.Type qualified as Scalie.Domain
+
+-- library: QuickCheck
 import Test.QuickCheck.Arbitrary (Arbitrary (arbitrary))
 import Test.QuickCheck.Gen (Gen)
-import Control.Applicative (Applicative((<*>)), (<$>))
-import Data.Text qualified as Text
-import Control.Category (Category((.)))
 import Test.QuickCheck.Modifiers (UnicodeString(getUnicodeString))
-import Data.Functor (Functor)
-import Language.Scalie.Core.Provenance (Provenance (value))
-import Data.Functor.Identity (Identity)
-import Data.Maybe (Maybe)
 
 -- | The definition of a value or a function (which is also a value)
 --

src/Language/Scalie/Core/Expression.hs

@@ -4,25 +4,26 @@
 {-# LANGUAGE InstanceSigs #-}
 module Language.Scalie.Core.Expression (Expression(..)) where
 
-import Prelude (Integer, Integral (div))
+-- meta
 import Data.Kind (Type)
-import Text.Show (Show)
-import Text.Read (Read)
-import Data.Eq (Eq)
-import Data.Ratio (Rational)
+
+-- data structures
 import Data.Text (Text)
 import Data.List.NonEmpty (NonEmpty)
+
+import Data.Text qualified as Text
+import Data.List.NonEmpty qualified as NonEmpty
+
+-- scalie
 import Language.Scalie.Core.Expression.PatternMatchCase (PatternMatchCase)
+import Language.Scalie.Core.Expression.VariableIdentifier (VariableIdentifier)
+
+-- library: QuickCheck
 import Test.QuickCheck (Arbitrary (arbitrary), oneof, UnicodeString (getUnicodeString), NonEmptyList (getNonEmpty))
 import Test.QuickCheck.Gen (Gen)
-import Data.Functor ((<$>), Functor)
-import Control.Category ((.))
-import Data.Text qualified as Text
-import Language.Scalie.Core.Expression.VariableIdentifier (VariableIdentifier)
-import Control.Applicative ((<*>))
-import Data.List.NonEmpty qualified as NonEmpty
 import Test.QuickCheck qualified as Gen
 
+
 type Expression :: (Type -> Type) -> Type
 type role Expression nominal
 data Expression f

src/Language/Scalie/Core/Expression/ConstructorIdentifier.hs

@@ -5,15 +5,16 @@
 
 module Language.Scalie.Core.Expression.ConstructorIdentifier (ConstructorIdentifier(..)) where
 
+-- meta
 import Data.Kind (Type)
+
+-- data structures
 import Data.Text (Text)
-import Text.Show (Show)
-import Text.Read (Read)
-import Data.Eq (Eq)
-import Test.QuickCheck (Arbitrary (arbitrary), Gen, getUnicodeString)
-import Control.Category ((.))
+
 import Data.Text qualified as Text
-import Data.Functor ((<$>))
+
+-- library: QuickCheck
+import Test.QuickCheck (Arbitrary (arbitrary), Gen, getUnicodeString)
 
 -- | Encodes the knowledge that the contained text is always a Constructor name.
 

src/Language/Scalie/Core/Expression/Pattern.hs

@@ -6,19 +6,22 @@
 -- | Pattern types for the core language. 'Pattern' enumerates all the possible ways to match on a value.
 
 module Language.Scalie.Core.Expression.Pattern (Pattern(..)) where
+
+-- meta
 import Data.Kind (Type)
+
+-- data structures
+import Data.Vector (Vector)
+
+import Data.Vector qualified as Vector
+
+-- Scalie
 import Language.Scalie.Core.Expression.VariableIdentifier (VariableIdentifier)
 import Language.Scalie.Core.Expression.ConstructorIdentifier (ConstructorIdentifier)
-import Data.Vector (Vector)
-import Text.Show (Show)
-import Text.Read (Read)
-import Data.Eq (Eq)
+
+-- library: QuickCheck
 import Test.QuickCheck (Arbitrary (arbitrary), Gen, oneof)
-import Data.Functor ((<$>), Functor)
-import Control.Applicative ((<*>))
-import Data.Vector qualified as Vector
 import Test.QuickCheck.Gen qualified as Gen
-import Prelude (div) -- seems to be the safe way to import div
 
 -- | This is a single pattern. It may be used for a single argument.
 

src/Language/Scalie/Core/Expression/PatternMatchCase.hs

@@ -3,17 +3,17 @@
 {-# LANGUAGE UndecidableInstances #-}
 {-# LANGUAGE InstanceSigs #-}
 module Language.Scalie.Core.Expression.PatternMatchCase (PatternMatchCase(..)) where
+
+-- meta
 import Data.Kind (Type)
+
+-- scalie
 import {-# SOURCE #-} Language.Scalie.Core.Expression (Expression)
 import Language.Scalie.Core.Expression.Pattern (Pattern)
-import Text.Show (Show)
-import Text.Read (Read)
-import Data.Eq (Eq)
+
+-- library: QuickCheck
 import Test.QuickCheck (Arbitrary (arbitrary), Gen)
-import Data.Functor ((<$>))
-import Control.Applicative ((<*>))
 import Test.QuickCheck.Gen qualified as Gen
-import Prelude (div)
 
 type PatternMatchCase :: (Type -> Type) -> Type
 type role PatternMatchCase nominal

src/Language/Scalie/Core/Expression/VariableIdentifier.hs

@@ -5,15 +5,15 @@
 
 module Language.Scalie.Core.Expression.VariableIdentifier (VariableIdentifier(..)) where
 
+-- meta
 import Data.Kind (Type)
+
+-- data structures
 import Data.Text (Text)
-import Text.Show (Show)
-import Text.Read (Read)
-import Data.Eq (Eq)
-import Test.QuickCheck (Arbitrary (arbitrary), Gen, UnicodeString (getUnicodeString))
-import Control.Category ((.))
 import Data.Text qualified as Text
-import Data.Functor ((<$>))
+
+-- library: QuickCheck
+import Test.QuickCheck (Arbitrary (arbitrary), Gen, UnicodeString (getUnicodeString))
 
 -- | Encodes the knowledge that the contained text is always a variable name.
 

src/Language/Scalie/Core/Module.hs

@@ -8,8 +8,6 @@ module Language.Scalie.Core.Module (Module(..)) where
 import Data.Kind (Type)
 import Language.Scalie.Core.Definition (Definition)
 import Data.Map.Implicit (ImplicitMap)
-import Text.Show (Show)
-import Text.Read (Read)
 
 -- | A module groups multiple related definitions.
 --
@@ -31,7 +29,7 @@ import Text.Read (Read)
 
 type Module :: (Type -> Type) -> Type
 type role Module nominal
-data Module f = Module
+newtype Module f = Module
   { definitions :: f (ImplicitMap (Definition f))
   }
 

src/Language/Scalie/Core/Pattern.hs

@@ -1,30 +0,0 @@
-{-# LANGUAGE Safe #-}
-{-# LANGUAGE DerivingStrategies #-}
-module Language.Scalie.Core.Pattern (Pattern(..)) where
-import Prelude (Integer)
-import Text.Show (Show)
-import Text.Read (Read)
-import Data.Kind qualified
-
-
--- | A pattern in scalie. Used to select branches to jump to, with pattern matching.
---
--- >>> RawInt 15
--- RawInt 15
---
--- >>> import Data.Maybe (Maybe)
--- >>> import Text.Read (readMaybe)
--- >>> readMaybe "RawInt (-5)" :: Maybe Pattern
--- Just (RawInt (-5))
---
--- >>> readMaybe "RawInt (+5)" :: Maybe Pattern
--- Nothing
---
--- >>> readMaybe "RawInt (5)" :: Maybe Pattern
--- Just (RawInt 5)
-
-type Pattern :: Data.Kind.Type
-data Pattern
-  = RawInt Integer
-  deriving stock (Show, Read)
-

src/Language/Scalie/Core/Provenance.hs

@@ -2,18 +2,14 @@
 {-# LANGUAGE InstanceSigs #-}
 {-# LANGUAGE DeriveTraversable #-} -- implies DeriveFunctor and DeriveFoldable
 module Language.Scalie.Core.Provenance (Provenance(..)) where
+
+-- meta
 import Data.Kind (Type)
-import Text.Show (Show)
-import Text.Read (Read)
-import Data.Functor (Functor)
-import Data.Foldable (Foldable)
+
+-- classes
 import Data.Bifunctor (Bifunctor (bimap))
-import Data.Traversable (Traversable)
 import Data.Bifoldable (Bifoldable (bifoldMap))
-import Data.Monoid (Monoid)
-import Data.Semigroup ((<>))
 import Data.Bitraversable (Bitraversable (bitraverse))
-import Control.Applicative (Applicative (liftA2))
 
 type Provenance :: Type -> Type -> Type
 type role Provenance representational representational