From 36ae4dd5e0f5974e41a0ab15c28a280898139a1e Mon Sep 17 00:00:00 2001 From: VegOwOtenks Date: Fri, 15 Aug 2025 10:28:13 +0200 Subject: [PATCH] feat[dev]: import Prelude --- app/Main.hs | 4 +- package.yaml | 2 +- scalie.cabal | 10 ++--- src/Data/Map/Implicit.hs | 24 ++++++------ src/Language/Scalie/Bytecode/Instruction.hs | 6 +-- src/Language/Scalie/Bytecode/Object.hs | 10 +++-- .../Scalie/Bytecode/Object/Builder.hs | 6 +-- src/Language/Scalie/Compiler/Bytecode.hs | 38 ++++--------------- src/Language/Scalie/Core/Definition.hs | 24 ++++++------ src/Language/Scalie/Core/Expression.hs | 23 +++++------ .../Core/Expression/ConstructorIdentifier.hs | 13 ++++--- .../Scalie/Core/Expression/Pattern.hs | 19 ++++++---- .../Core/Expression/PatternMatchCase.hs | 12 +++--- .../Core/Expression/VariableIdentifier.hs | 12 +++--- src/Language/Scalie/Core/Module.hs | 4 +- src/Language/Scalie/Core/Pattern.hs | 30 --------------- src/Language/Scalie/Core/Provenance.hs | 12 ++---- test/Spec.hs | 2 - test/Test/Data/Map/Implicit.hs | 21 +++++----- test/Test/QuickCheck/Roundtrip.hs | 2 - 20 files changed, 102 insertions(+), 172 deletions(-) delete mode 100644 src/Language/Scalie/Core/Pattern.hs diff --git a/app/Main.hs b/app/Main.hs index 986782b..f5e2cc8 100644 --- a/app/Main.hs +++ b/app/Main.hs @@ -1,7 +1,5 @@ +{-# LANGUAGE Safe #-} module Main (main) where -import Control.Applicative (pure) -import System.IO (IO) - main :: IO () main = pure () diff --git a/package.yaml b/package.yaml index 043e986..70fb2cf 100644 --- a/package.yaml +++ b/package.yaml @@ -21,7 +21,6 @@ description: Please see the README on GitHub at >>)) -import Data.Functor ((<$>)) -import Data.Ord (Ord) -import Data.Eq (Eq) + +import Data.Kind (Type, Constraint) + +import Data.Map (Map) +import Data.Map qualified as Map +import Data.List qualified as List + +import Text.Read (Read (readPrec), ReadPrec) + import Test.QuickCheck.Arbitrary (Arbitrary (arbitrary)) import Test.QuickCheck.Gen (Gen) -import Data.Maybe (Maybe) -- | This map will use the 'ImplicitKeyOf' class to compute the keys of the values. diff --git a/src/Language/Scalie/Bytecode/Instruction.hs b/src/Language/Scalie/Bytecode/Instruction.hs index e15156c..f863523 100644 --- a/src/Language/Scalie/Bytecode/Instruction.hs +++ b/src/Language/Scalie/Bytecode/Instruction.hs @@ -1,11 +1,9 @@ {-# LANGUAGE Safe #-} {-# LANGUAGE EmptyDataDeriving #-} -- instruction doesn't have any cases yet module Language.Scalie.Bytecode.Instruction (Instruction(..)) where + import Data.Kind (Type) -import Text.Show (Show) -import Text.Read (Read) -import Data.Eq (Eq) -import Prelude (Integer) -- this is apparently the only safe way to import 'Integer' + import Data.Word (Word8) type Instruction :: Type diff --git a/src/Language/Scalie/Bytecode/Object.hs b/src/Language/Scalie/Bytecode/Object.hs index acb158f..cfe1559 100644 --- a/src/Language/Scalie/Bytecode/Object.hs +++ b/src/Language/Scalie/Bytecode/Object.hs @@ -4,15 +4,17 @@ -- | This module describes a Bytecode Object, similar to a java classfile. It will hold source information, shared constants and module Language.Scalie.Bytecode.Object (Object(..)) where + +-- meta import Data.Kind (Type) + +-- data structures import Data.Vector (Vector) + +-- Scalie import Language.Scalie.Core.Provenance (Provenance) import Language.Scalie.Bytecode.Instruction (Instruction) import Language.Scalie.Core.Provenance.SourceLocation (SourceLocation) -import Text.Show (Show) -import Text.Read (Read) -import Data.Semigroup (Semigroup) -import Data.Monoid (Monoid) type Object :: Type type role Object diff --git a/src/Language/Scalie/Bytecode/Object/Builder.hs b/src/Language/Scalie/Bytecode/Object/Builder.hs index c75cd33..664ee05 100644 --- a/src/Language/Scalie/Bytecode/Object/Builder.hs +++ b/src/Language/Scalie/Bytecode/Object/Builder.hs @@ -2,12 +2,10 @@ {-# LANGUAGE DeriveFunctor #-} {-# LANGUAGE InstanceSigs #-} module Language.Scalie.Bytecode.Object.Builder (Builder, runBuilder) where + import Data.Kind (Type) + import Language.Scalie.Bytecode.Object qualified as Bytecode -import Data.Functor (Functor) -import Control.Applicative (Applicative (pure, (<*>))) -import Control.Monad (Monad ((>>=))) -import Prelude (undefined) type Builder :: Type -> Type type role Builder representational diff --git a/src/Language/Scalie/Compiler/Bytecode.hs b/src/Language/Scalie/Compiler/Bytecode.hs index 1e067d1..954a334 100644 --- a/src/Language/Scalie/Compiler/Bytecode.hs +++ b/src/Language/Scalie/Compiler/Bytecode.hs @@ -1,23 +1,11 @@ -{-# LANGUAGE Trustworthy #-} -- uses vector operations -{-# LANGUAGE OverloadedRecordDot #-} -module Language.Scalie.Compiler.Bytecode (EntryPoint, compile, CompilationError(..)) where -import Language.Scalie.Core.Module (Module (definitions)) -import Data.Text (Text) -import Language.Scalie.Core.Provenance (Provenance (value, Provenance, source)) -import Language.Scalie.Core.Provenance.SourceLocation (SourceLocation) -import Language.Scalie.Bytecode.Object qualified as Bytecode +{-# LANGUAGE Safe #-} +module Language.Scalie.Compiler.Bytecode (EntryPoint, CompilationError(..)) where + +-- meta import Data.Kind (Type) -import Data.Either (Either (Left, Right)) -import Data.Vector qualified as Vector -import Control.Category ((.)) -import Data.Function (($)) -import Data.Functor ((<$>)) -import Data.Map.Implicit qualified as ImplicitMap -import Data.Maybe (Maybe(Nothing, Just)) -import Language.Scalie.Core.Definition (Definition(body, name)) -import Language.Scalie.Core.Expression (Expression(RawInt)) -import Language.Scalie.Bytecode.Instruction qualified as Instruction -import Prelude (undefined) + +-- data structures +import Data.Text (Text) -- | The name of the entrypoint function @@ -26,15 +14,3 @@ type EntryPoint = Text type CompilationError :: Type newtype CompilationError = NameNotFound Text - -compile :: Module (Provenance SourceLocation) -> EntryPoint -> Either CompilationError Bytecode.Object -compile mod entry = undefined -{- let - topLevelDefinitions = mod.definitions.value - in Bytecode.Object . Vector.fromList <$> case ImplicitMap.lookup entry topLevelDefinitions of - Nothing -> Left $ NameNotFound entry - Just def -> Right - [ (\(RawInt i) -> Instruction.PushInteger i) <$> def.body - , Provenance def.name.source (Instruction.ReturnValues 1) - ] --} diff --git a/src/Language/Scalie/Core/Definition.hs b/src/Language/Scalie/Core/Definition.hs index a71a040..c1f0f60 100644 --- a/src/Language/Scalie/Core/Definition.hs +++ b/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) -- diff --git a/src/Language/Scalie/Core/Expression.hs b/src/Language/Scalie/Core/Expression.hs index c8d986b..3c84c15 100644 --- a/src/Language/Scalie/Core/Expression.hs +++ b/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 diff --git a/src/Language/Scalie/Core/Expression/ConstructorIdentifier.hs b/src/Language/Scalie/Core/Expression/ConstructorIdentifier.hs index 0728fc6..29aab85 100644 --- a/src/Language/Scalie/Core/Expression/ConstructorIdentifier.hs +++ b/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. diff --git a/src/Language/Scalie/Core/Expression/Pattern.hs b/src/Language/Scalie/Core/Expression/Pattern.hs index 1d45d36..07f2959 100644 --- a/src/Language/Scalie/Core/Expression/Pattern.hs +++ b/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. diff --git a/src/Language/Scalie/Core/Expression/PatternMatchCase.hs b/src/Language/Scalie/Core/Expression/PatternMatchCase.hs index 6935a45..0e6146f 100644 --- a/src/Language/Scalie/Core/Expression/PatternMatchCase.hs +++ b/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 diff --git a/src/Language/Scalie/Core/Expression/VariableIdentifier.hs b/src/Language/Scalie/Core/Expression/VariableIdentifier.hs index 54c6687..22d1698 100644 --- a/src/Language/Scalie/Core/Expression/VariableIdentifier.hs +++ b/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. diff --git a/src/Language/Scalie/Core/Module.hs b/src/Language/Scalie/Core/Module.hs index 49c25c0..0a0ce69 100644 --- a/src/Language/Scalie/Core/Module.hs +++ b/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)) } diff --git a/src/Language/Scalie/Core/Pattern.hs b/src/Language/Scalie/Core/Pattern.hs deleted file mode 100644 index 501ddd0..0000000 --- a/src/Language/Scalie/Core/Pattern.hs +++ /dev/null @@ -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) - diff --git a/src/Language/Scalie/Core/Provenance.hs b/src/Language/Scalie/Core/Provenance.hs index a39a889..d067c69 100644 --- a/src/Language/Scalie/Core/Provenance.hs +++ b/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 diff --git a/test/Spec.hs b/test/Spec.hs index a3b14ce..58d3a63 100644 --- a/test/Spec.hs +++ b/test/Spec.hs @@ -1,8 +1,6 @@ {-# LANGUAGE Unsafe #-} -- unsafe: Uses functions imported from unsafe modules -import System.IO (IO) import Test.Data.Map.Implicit qualified import Test.Tasty qualified as Tasty -import Data.Function (($)) main :: IO () main = Tasty.defaultMain $ Tasty.testGroup "all" diff --git a/test/Test/Data/Map/Implicit.hs b/test/Test/Data/Map/Implicit.hs index 6f29cf0..44bbb1f 100644 --- a/test/Test/Data/Map/Implicit.hs +++ b/test/Test/Data/Map/Implicit.hs @@ -3,22 +3,21 @@ {-# OPTIONS_GHC -Wno-all-missed-specialisations #-} -- a lot of warnings for unspecialized 'read' and 'show', which I cannot specialize -- I wouldn't know how at least, they're not my datatypes, I cannot use the hint and add an 'INLINABLE' pragma module Test.Data.Map.Implicit (testGroup) where -import Test.QuickCheck.Roundtrip (roundtrips) -import Text.Show (show) -import Text.Read (read) -import Data.Map.Implicit (ImplicitMap) -import Data.Bool (Bool) -import Language.Scalie.Core.Definition (Definition) + import Data.Functor.Identity (Identity) + +import Data.Map.Implicit (ImplicitMap) + +import Language.Scalie.Core.Definition (Definition) + import Test.QuickCheck (Property, allProperties) -import Data.String (String) -import Control.Applicative (pure) -import Data.Maybe (Maybe) -import Test.Tasty.QuickCheck qualified as Tasty.QuickCheck +import Test.QuickCheck.Roundtrip (roundtrips) + import Test.Tasty (TestTree) import Test.Tasty.QuickCheck (QuickCheckMaxSize(QuickCheckMaxSize)) -import Data.Function (($)) + import Test.Tasty qualified as Tasty +import Test.Tasty.QuickCheck qualified as Tasty.QuickCheck -- | This is testworthy since I have somehow hand-hacked the read/show de/serialization of 'ImplicitMap' diff --git a/test/Test/QuickCheck/Roundtrip.hs b/test/Test/QuickCheck/Roundtrip.hs index 0ae6093..e02780e 100644 --- a/test/Test/QuickCheck/Roundtrip.hs +++ b/test/Test/QuickCheck/Roundtrip.hs @@ -1,7 +1,5 @@ {-# LANGUAGE Safe #-} module Test.QuickCheck.Roundtrip (roundtrips) where -import Data.Eq ((==), Eq) -import Data.Bool (Bool) roundtrips :: Eq t1 => (t2 -> t1) -> (t1 -> t2) -> t1 -> Bool roundtrips back forth x = x == back (forth x)