packages feed

purescript 0.11.7 → 0.12.0

raw patch · 1411 files changed

+15099/−11653 lines, 1411 filesdep +tastydep +tasty-hspecdep −http-clientdep −pipesdep −pipes-httpdep ~Globdep ~ansi-terminaldep ~basenew-uploaderPVP ok

version bump matches the API change (PVP)

Dependencies added: tasty, tasty-hspec

Dependencies removed: http-client, pipes, pipes-http, silently

Dependency ranges changed: Glob, ansi-terminal, base

API changes (from Hackage documentation)

- Language.PureScript.AST.Declarations: MultipleFFIModules :: ModuleName -> [FilePath] -> SimpleErrorMessage
- Language.PureScript.Constants: __unused :: forall a. (IsString a) => a
- Language.PureScript.Constants: applicativeEffDictionary :: forall a. (IsString a) => a
- Language.PureScript.Constants: bindEffDictionary :: forall a. (IsString a) => a
- Language.PureScript.Constants: monadEffDictionary :: forall a. (IsString a) => a
- Language.PureScript.Constants: typeDataOrdering :: ModuleName
- Language.PureScript.CoreFn.Module: type ForeignDecl = (Ident, Type)
- Language.PureScript.CoreImp.Optimizer.Unused: removeUnusedArg :: AST -> AST
- Language.PureScript.Ide.Command: Pursuit :: PursuitQuery -> PursuitSearchType -> Command
- Language.PureScript.Ide.Command: [pursuitQuery] :: Command -> PursuitQuery
- Language.PureScript.Ide.Command: [pursuitSearchType] :: Command -> PursuitSearchType
- Language.PureScript.Ide.Pursuit: findPackagesForModuleIdent :: Text -> IO [PursuitResponse]
- Language.PureScript.Ide.Pursuit: searchPursuitForDeclarations :: Text -> IO [PursuitResponse]
- Language.PureScript.Ide.Types: DeclarationResponse :: Text -> ModuleIdent -> Text -> (Maybe Text) -> Text -> PursuitResponse
- Language.PureScript.Ide.Types: Identifier :: PursuitSearchType
- Language.PureScript.Ide.Types: ModuleResponse :: ModuleIdent -> Text -> PursuitResponse
- Language.PureScript.Ide.Types: Package :: PursuitSearchType
- Language.PureScript.Ide.Types: PursuitQuery :: Text -> PursuitQuery
- Language.PureScript.Ide.Types: PursuitResult :: [PursuitResponse] -> Success
- Language.PureScript.Ide.Types: data PursuitResponse
- Language.PureScript.Ide.Types: data PursuitSearchType
- Language.PureScript.Ide.Types: instance Data.Aeson.Types.FromJSON.FromJSON Language.PureScript.Ide.Types.PursuitQuery
- Language.PureScript.Ide.Types: instance Data.Aeson.Types.FromJSON.FromJSON Language.PureScript.Ide.Types.PursuitResponse
- Language.PureScript.Ide.Types: instance Data.Aeson.Types.FromJSON.FromJSON Language.PureScript.Ide.Types.PursuitSearchType
- Language.PureScript.Ide.Types: instance Data.Aeson.Types.ToJSON.ToJSON Language.PureScript.Ide.Types.PursuitResponse
- Language.PureScript.Ide.Types: instance GHC.Classes.Eq Language.PureScript.Ide.Types.PursuitQuery
- Language.PureScript.Ide.Types: instance GHC.Classes.Eq Language.PureScript.Ide.Types.PursuitResponse
- Language.PureScript.Ide.Types: instance GHC.Classes.Eq Language.PureScript.Ide.Types.PursuitSearchType
- Language.PureScript.Ide.Types: instance GHC.Show.Show Language.PureScript.Ide.Types.PursuitQuery
- Language.PureScript.Ide.Types: instance GHC.Show.Show Language.PureScript.Ide.Types.PursuitResponse
- Language.PureScript.Ide.Types: instance GHC.Show.Show Language.PureScript.Ide.Types.PursuitSearchType
- Language.PureScript.Ide.Types: newtype PursuitQuery
- Language.PureScript.Interactive.Types: PSCiState :: [ImportedModule] -> [Declaration] -> [(Module, ExternsFile)] -> PSCiState
- Language.PureScript.Interactive.Types: [psciImportedModules] :: PSCiState -> [ImportedModule]
- Language.PureScript.Interactive.Types: [psciLetBindings] :: PSCiState -> [Declaration]
- Language.PureScript.Interactive.Types: [psciLoadedExterns] :: PSCiState -> [(Module, ExternsFile)]
- Language.PureScript.Interactive.Types: allImportsOf :: Module -> PSCiState -> [ImportedModule]
- Language.PureScript.Make: CompilingModule :: ModuleName -> ProgressMessage
- Language.PureScript.Make: Make :: ReaderT Options (ExceptT MultipleErrors (Logger MultipleErrors)) a -> Make a
- Language.PureScript.Make: MakeActions :: (ModuleName -> m (Either RebuildPolicy (Maybe UTCTime))) -> (ModuleName -> m (Maybe UTCTime)) -> (ModuleName -> m (FilePath, Externs)) -> (Module Ann -> Environment -> Externs -> SupplyT m ()) -> (ProgressMessage -> m ()) -> MakeActions m
- Language.PureScript.Make: RebuildAlways :: RebuildPolicy
- Language.PureScript.Make: RebuildNever :: RebuildPolicy
- Language.PureScript.Make: [codegen] :: MakeActions m -> Module Ann -> Environment -> Externs -> SupplyT m ()
- Language.PureScript.Make: [getInputTimestamp] :: MakeActions m -> ModuleName -> m (Either RebuildPolicy (Maybe UTCTime))
- Language.PureScript.Make: [getOutputTimestamp] :: MakeActions m -> ModuleName -> m (Maybe UTCTime)
- Language.PureScript.Make: [progress] :: MakeActions m -> ProgressMessage -> m ()
- Language.PureScript.Make: [readExterns] :: MakeActions m -> ModuleName -> m (FilePath, Externs)
- Language.PureScript.Make: [unMake] :: Make a -> ReaderT Options (ExceptT MultipleErrors (Logger MultipleErrors)) a
- Language.PureScript.Make: buildMakeActions :: FilePath -> Map ModuleName (Either RebuildPolicy FilePath) -> Map ModuleName FilePath -> Bool -> MakeActions Make
- Language.PureScript.Make: data MakeActions m
- Language.PureScript.Make: data ProgressMessage
- Language.PureScript.Make: data RebuildPolicy
- Language.PureScript.Make: instance Control.Monad.Base.MonadBase GHC.Types.IO Language.PureScript.Make.Make
- Language.PureScript.Make: instance Control.Monad.Error.Class.MonadError Language.PureScript.Errors.MultipleErrors Language.PureScript.Make.Make
- Language.PureScript.Make: instance Control.Monad.IO.Class.MonadIO Language.PureScript.Make.Make
- Language.PureScript.Make: instance Control.Monad.Reader.Class.MonadReader Language.PureScript.Options.Options Language.PureScript.Make.Make
- Language.PureScript.Make: instance Control.Monad.Trans.Control.MonadBaseControl GHC.Types.IO Language.PureScript.Make.Make
- Language.PureScript.Make: instance Control.Monad.Writer.Class.MonadWriter Language.PureScript.Errors.MultipleErrors Language.PureScript.Make.Make
- Language.PureScript.Make: instance GHC.Base.Applicative Language.PureScript.Make.Make
- Language.PureScript.Make: instance GHC.Base.Functor Language.PureScript.Make.Make
- Language.PureScript.Make: instance GHC.Base.Monad Language.PureScript.Make.Make
- Language.PureScript.Make: instance GHC.Classes.Eq Language.PureScript.Make.ProgressMessage
- Language.PureScript.Make: instance GHC.Classes.Eq Language.PureScript.Make.RebuildPolicy
- Language.PureScript.Make: instance GHC.Classes.Ord Language.PureScript.Make.ProgressMessage
- Language.PureScript.Make: instance GHC.Classes.Ord Language.PureScript.Make.RebuildPolicy
- Language.PureScript.Make: instance GHC.Show.Show Language.PureScript.Make.ProgressMessage
- Language.PureScript.Make: instance GHC.Show.Show Language.PureScript.Make.RebuildPolicy
- Language.PureScript.Make: makeIO :: (IOError -> ErrorMessage) -> IO a -> Make a
- Language.PureScript.Make: newtype Make a
- Language.PureScript.Make: readTextFile :: FilePath -> Make ByteString
- Language.PureScript.Make: renderProgressMessage :: ProgressMessage -> String
- Language.PureScript.Make: runMake :: Options -> Make a -> IO (Either MultipleErrors a, MultipleErrors)
- Language.PureScript.Make: type Externs = ByteString
- Language.PureScript.Names: instance Data.Aeson.Types.FromJSON.FromJSON a0 => Data.Aeson.Types.FromJSON.FromJSON (Language.PureScript.Names.Qualified a0)
- Language.PureScript.Names: instance Data.Aeson.Types.ToJSON.ToJSON a0 => Data.Aeson.Types.ToJSON.ToJSON (Language.PureScript.Names.Qualified a0)
- Language.PureScript.Options: [optionsDumpCoreFn] :: Options -> Bool
- Language.PureScript.Options: [optionsSourceMaps] :: Options -> Bool
+ Language.PureScript.AST.Declarations: Ado :: [DoNotationElement] -> Expr -> Expr
+ Language.PureScript.AST.Declarations: CannotDefinePrimModules :: ModuleName -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: FromLet :: WhereProvenance
+ Language.PureScript.AST.Declarations: FromWhere :: WhereProvenance
+ Language.PureScript.AST.Declarations: ImplicitQualifiedImportReExport :: ModuleName -> ModuleName -> [DeclarationRef] -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: MixedAssociativityError :: (NonEmpty (Qualified (OpName 'AnyOpName), Associativity)) -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: NonAssociativeError :: (NonEmpty (Qualified (OpName 'AnyOpName))) -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: data WhereProvenance
+ Language.PureScript.AST.Declarations: getModuleDeclarations :: Module -> [Declaration]
+ Language.PureScript.AST.Declarations: instance GHC.Show.Show Language.PureScript.AST.Declarations.WhereProvenance
+ Language.PureScript.AST.SourcePos: nullSourceSpan :: SourceSpan
+ Language.PureScript.AST.Traversals: LocalIdent :: Ident -> ScopedIdent
+ Language.PureScript.AST.Traversals: ToplevelIdent :: Ident -> ScopedIdent
+ Language.PureScript.AST.Traversals: data ScopedIdent
+ Language.PureScript.AST.Traversals: inScope :: Ident -> Set ScopedIdent -> Bool
+ Language.PureScript.AST.Traversals: instance GHC.Classes.Eq Language.PureScript.AST.Traversals.ScopedIdent
+ Language.PureScript.AST.Traversals: instance GHC.Classes.Ord Language.PureScript.AST.Traversals.ScopedIdent
+ Language.PureScript.AST.Traversals: instance GHC.Show.Show Language.PureScript.AST.Traversals.ScopedIdent
+ Language.PureScript.Constants: EffectDictionaries :: PSString -> PSString -> PSString -> EffectDictionaries
+ Language.PureScript.Constants: [edApplicativeDict] :: EffectDictionaries -> PSString
+ Language.PureScript.Constants: [edBindDict] :: EffectDictionaries -> PSString
+ Language.PureScript.Constants: [edMonadDict] :: EffectDictionaries -> PSString
+ Language.PureScript.Constants: compare1 :: forall a. (IsString a) => a
+ Language.PureScript.Constants: controlMonadEffUncurried :: forall a. (IsString a) => a
+ Language.PureScript.Constants: data EffectDictionaries
+ Language.PureScript.Constants: doc :: forall a. (IsString a) => a
+ Language.PureScript.Constants: effDictionaries :: EffectDictionaries
+ Language.PureScript.Constants: effect :: forall a. (IsString a) => a
+ Language.PureScript.Constants: effectDictionaries :: EffectDictionaries
+ Language.PureScript.Constants: effectUncurried :: forall a. (IsString a) => a
+ Language.PureScript.Constants: eq1 :: forall a. (IsString a) => a
+ Language.PureScript.Constants: kindOrdering :: forall a. (IsString a) => a
+ Language.PureScript.Constants: kindRowList :: forall a. (IsString a) => a
+ Language.PureScript.Constants: mkEffFn :: forall a. (IsString a) => a
+ Language.PureScript.Constants: mkEffectFn :: forall a. (IsString a) => a
+ Language.PureScript.Constants: moduleOrdering :: forall a. (IsString a) => a
+ Language.PureScript.Constants: moduleRow :: forall a. (IsString a) => a
+ Language.PureScript.Constants: moduleRowList :: forall a. (IsString a) => a
+ Language.PureScript.Constants: moduleSymbol :: forall a. (IsString a) => a
+ Language.PureScript.Constants: primModules :: [ModuleName]
+ Language.PureScript.Constants: runEffFn :: forall a. (IsString a) => a
+ Language.PureScript.Constants: runEffectFn :: forall a. (IsString a) => a
+ Language.PureScript.Constants: typeError :: forall a. (IsString a) => a
+ Language.PureScript.CoreFn.FromJSON: moduleFromJSON :: Value -> Parser (Version, Module Ann)
+ Language.PureScript.CoreFn.Meta: IsWhere :: Meta
+ Language.PureScript.CoreFn.Module: [modulePath] :: Module a -> FilePath
+ Language.PureScript.CoreFn.Module: [moduleSourceSpan] :: Module a -> SourceSpan
+ Language.PureScript.CoreFn.Optimizer: optimizeCoreFn :: Module Ann -> Module Ann
+ Language.PureScript.CoreImp.Optimizer.MagicDo: inlineST :: AST -> AST
+ Language.PureScript.CoreImp.Optimizer.MagicDo: magicDo' :: AST -> AST
+ Language.PureScript.Docs.Convert: convertTaggedModulesInPackage :: (MonadError MultipleErrors m) => [(FilePath, Module)] -> Map ModuleName PackageName -> m [(FilePath, Module)]
+ Language.PureScript.Docs.Prim: primModules :: [Module]
+ Language.PureScript.Docs.Prim: primRowDocsModule :: Module
+ Language.PureScript.Docs.Prim: primTypeErrorDocsModule :: Module
+ Language.PureScript.Docs.Tags: dumpCtags :: [(String, Module)] -> [String]
+ Language.PureScript.Docs.Tags: dumpEtags :: [(String, Module)] -> [String]
+ Language.PureScript.Docs.Tags: tags :: Module -> [(String, Int)]
+ Language.PureScript.Environment: (-:>) :: Kind -> Kind -> Kind
+ Language.PureScript.Environment: allPrimClasses :: Map (Qualified (ProperName 'ClassName)) TypeClassData
+ Language.PureScript.Environment: allPrimKinds :: Set (Qualified (ProperName 'KindName))
+ Language.PureScript.Environment: allPrimTypes :: Map (Qualified (ProperName 'TypeName)) (Kind, TypeKind)
+ Language.PureScript.Environment: infixr 4 -:>
+ Language.PureScript.Environment: kindConstraint :: Kind
+ Language.PureScript.Environment: kindDoc :: Kind
+ Language.PureScript.Environment: kindOrdering :: Kind
+ Language.PureScript.Environment: kindRowList :: Kind
+ Language.PureScript.Environment: primOrderingKinds :: Set (Qualified (ProperName 'KindName))
+ Language.PureScript.Environment: primOrderingTypes :: Map (Qualified (ProperName 'TypeName)) (Kind, TypeKind)
+ Language.PureScript.Environment: primRowClasses :: Map (Qualified (ProperName 'ClassName)) TypeClassData
+ Language.PureScript.Environment: primRowListClasses :: Map (Qualified (ProperName 'ClassName)) TypeClassData
+ Language.PureScript.Environment: primRowListKinds :: Set (Qualified (ProperName 'KindName))
+ Language.PureScript.Environment: primRowListTypes :: Map (Qualified (ProperName 'TypeName)) (Kind, TypeKind)
+ Language.PureScript.Environment: primRowTypes :: Map (Qualified (ProperName 'TypeName)) (Kind, TypeKind)
+ Language.PureScript.Environment: primSubKind :: Text -> Text -> Kind
+ Language.PureScript.Environment: primSubName :: Text -> Text -> Qualified (ProperName a)
+ Language.PureScript.Environment: primSymbolClasses :: Map (Qualified (ProperName 'ClassName)) TypeClassData
+ Language.PureScript.Environment: primSymbolTypes :: Map (Qualified (ProperName 'TypeName)) (Kind, TypeKind)
+ Language.PureScript.Environment: primTypeErrorClasses :: Map (Qualified (ProperName 'ClassName)) TypeClassData
+ Language.PureScript.Environment: primTypeErrorKinds :: Set (Qualified (ProperName 'KindName))
+ Language.PureScript.Environment: primTypeErrorTypes :: Map (Qualified (ProperName 'TypeName)) (Kind, TypeKind)
+ Language.PureScript.Errors: errorMessage'' :: NonEmpty SourceSpan -> SimpleErrorMessage -> MultipleErrors
+ Language.PureScript.Errors: positionedError :: SourceSpan -> ErrorMessageHint
+ Language.PureScript.Errors.JSON: [allSpans] :: JSONError -> [SourceSpan]
+ Language.PureScript.Externs: [edInstanceChainIndex] :: ExternsDeclaration -> Integer
+ Language.PureScript.Externs: [edInstanceChain] :: ExternsDeclaration -> [Qualified Ident]
+ Language.PureScript.Ide.Command: FindUsages :: ModuleName -> Text -> IdeNamespace -> Command
+ Language.PureScript.Ide.Command: [usagesIdentifier] :: Command -> Text
+ Language.PureScript.Ide.Command: [usagesModule] :: Command -> ModuleName
+ Language.PureScript.Ide.Command: [usagesNamespace] :: Command -> IdeNamespace
+ Language.PureScript.Ide.State: getFileState :: Ide m => m IdeFileState
+ Language.PureScript.Ide.Types: UsagesResult :: [SourceSpan] -> Success
+ Language.PureScript.Ide.Usage: applySearch :: Module -> Search -> [SourceSpan]
+ Language.PureScript.Ide.Usage: directDependants :: IdeDeclaration -> ModuleMap Module -> ModuleName -> ModuleMap (NonEmpty Search)
+ Language.PureScript.Ide.Usage: eligibleModules :: (ModuleName, IdeDeclaration) -> ModuleMap [IdeDeclarationAnn] -> ModuleMap Module -> ModuleMap (NonEmpty Search)
+ Language.PureScript.Ide.Usage: findReexportingModules :: (ModuleName, IdeDeclaration) -> ModuleMap [IdeDeclarationAnn] -> [ModuleName]
+ Language.PureScript.Ide.Usage: findUsages :: (MonadIO m, Ide m) => IdeDeclaration -> ModuleName -> m (ModuleMap (NonEmpty SourceSpan))
+ Language.PureScript.Interactive.Parser: parseDotFile :: FilePath -> String -> Either String [Command]
+ Language.PureScript.Interactive.Types: psciExports :: PSCiState -> Exports
+ Language.PureScript.Interactive.Types: psciImportedModules :: PSCiState -> [ImportedModule]
+ Language.PureScript.Interactive.Types: psciImports :: PSCiState -> Imports
+ Language.PureScript.Interactive.Types: psciLetBindings :: PSCiState -> [Declaration]
+ Language.PureScript.Interactive.Types: psciLoadedExterns :: PSCiState -> [(Module, ExternsFile)]
+ Language.PureScript.Make.Actions: CompilingModule :: ModuleName -> ProgressMessage
+ Language.PureScript.Make.Actions: MakeActions :: (ModuleName -> m (Either RebuildPolicy (Maybe UTCTime))) -> (ModuleName -> m (Maybe UTCTime)) -> (ModuleName -> m (FilePath, Externs)) -> (Module Ann -> Environment -> Externs -> SupplyT m ()) -> (ProgressMessage -> m ()) -> MakeActions m
+ Language.PureScript.Make.Actions: RebuildAlways :: RebuildPolicy
+ Language.PureScript.Make.Actions: RebuildNever :: RebuildPolicy
+ Language.PureScript.Make.Actions: [codegen] :: MakeActions m -> Module Ann -> Environment -> Externs -> SupplyT m ()
+ Language.PureScript.Make.Actions: [getInputTimestamp] :: MakeActions m -> ModuleName -> m (Either RebuildPolicy (Maybe UTCTime))
+ Language.PureScript.Make.Actions: [getOutputTimestamp] :: MakeActions m -> ModuleName -> m (Maybe UTCTime)
+ Language.PureScript.Make.Actions: [progress] :: MakeActions m -> ProgressMessage -> m ()
+ Language.PureScript.Make.Actions: [readExterns] :: MakeActions m -> ModuleName -> m (FilePath, Externs)
+ Language.PureScript.Make.Actions: buildMakeActions :: FilePath -> Map ModuleName (Either RebuildPolicy FilePath) -> Map ModuleName FilePath -> Bool -> MakeActions Make
+ Language.PureScript.Make.Actions: data MakeActions m
+ Language.PureScript.Make.Actions: data ProgressMessage
+ Language.PureScript.Make.Actions: data RebuildPolicy
+ Language.PureScript.Make.Actions: instance GHC.Classes.Eq Language.PureScript.Make.Actions.ProgressMessage
+ Language.PureScript.Make.Actions: instance GHC.Classes.Eq Language.PureScript.Make.Actions.RebuildPolicy
+ Language.PureScript.Make.Actions: instance GHC.Classes.Ord Language.PureScript.Make.Actions.ProgressMessage
+ Language.PureScript.Make.Actions: instance GHC.Classes.Ord Language.PureScript.Make.Actions.RebuildPolicy
+ Language.PureScript.Make.Actions: instance GHC.Show.Show Language.PureScript.Make.Actions.ProgressMessage
+ Language.PureScript.Make.Actions: instance GHC.Show.Show Language.PureScript.Make.Actions.RebuildPolicy
+ Language.PureScript.Make.Actions: type Externs = ByteString
+ Language.PureScript.Make.BuildPlan: collectErrors :: (MonadBaseControl IO m) => BuildPlan -> m [MultipleErrors]
+ Language.PureScript.Make.BuildPlan: collectResults :: (MonadBaseControl IO m) => BuildPlan -> m (Map ModuleName ExternsFile)
+ Language.PureScript.Make.BuildPlan: construct :: forall m. (Monad m, MonadBaseControl IO m) => MakeActions m -> ([Module], [(ModuleName, [ModuleName])]) -> m BuildPlan
+ Language.PureScript.Make.BuildPlan: data BuildPlan
+ Language.PureScript.Make.BuildPlan: getResult :: (MonadBaseControl IO m) => BuildPlan -> ModuleName -> m (Maybe (MultipleErrors, ExternsFile))
+ Language.PureScript.Make.BuildPlan: markComplete :: (MonadBaseControl IO m) => BuildPlan -> ModuleName -> Maybe (MultipleErrors, ExternsFile) -> Maybe MultipleErrors -> m ()
+ Language.PureScript.Make.BuildPlan: needsRebuild :: BuildPlan -> ModuleName -> Bool
+ Language.PureScript.Make.Monad: Make :: ReaderT Options (ExceptT MultipleErrors (Logger MultipleErrors)) a -> Make a
+ Language.PureScript.Make.Monad: [unMake] :: Make a -> ReaderT Options (ExceptT MultipleErrors (Logger MultipleErrors)) a
+ Language.PureScript.Make.Monad: instance Control.Monad.Base.MonadBase GHC.Types.IO Language.PureScript.Make.Monad.Make
+ Language.PureScript.Make.Monad: instance Control.Monad.Error.Class.MonadError Language.PureScript.Errors.MultipleErrors Language.PureScript.Make.Monad.Make
+ Language.PureScript.Make.Monad: instance Control.Monad.IO.Class.MonadIO Language.PureScript.Make.Monad.Make
+ Language.PureScript.Make.Monad: instance Control.Monad.Reader.Class.MonadReader Language.PureScript.Options.Options Language.PureScript.Make.Monad.Make
+ Language.PureScript.Make.Monad: instance Control.Monad.Trans.Control.MonadBaseControl GHC.Types.IO Language.PureScript.Make.Monad.Make
+ Language.PureScript.Make.Monad: instance Control.Monad.Writer.Class.MonadWriter Language.PureScript.Errors.MultipleErrors Language.PureScript.Make.Monad.Make
+ Language.PureScript.Make.Monad: instance GHC.Base.Applicative Language.PureScript.Make.Monad.Make
+ Language.PureScript.Make.Monad: instance GHC.Base.Functor Language.PureScript.Make.Monad.Make
+ Language.PureScript.Make.Monad: instance GHC.Base.Monad Language.PureScript.Make.Monad.Make
+ Language.PureScript.Make.Monad: makeIO :: (IOError -> ErrorMessage) -> IO a -> Make a
+ Language.PureScript.Make.Monad: newtype Make a
+ Language.PureScript.Make.Monad: readTextFile :: FilePath -> Make ByteString
+ Language.PureScript.Make.Monad: runMake :: Options -> Make a -> IO (Either MultipleErrors a, MultipleErrors)
+ Language.PureScript.Names: AnyOpName :: OpNameType
+ Language.PureScript.Names: UnusedIdent :: Ident
+ Language.PureScript.Names: eraseOpName :: OpName a -> OpName 'AnyOpName
+ Language.PureScript.Names: instance Data.Aeson.Types.FromJSON.FromJSON a => Data.Aeson.Types.FromJSON.FromJSON (Language.PureScript.Names.Qualified a)
+ Language.PureScript.Names: instance Data.Aeson.Types.ToJSON.ToJSON a => Data.Aeson.Types.ToJSON.ToJSON (Language.PureScript.Names.Qualified a)
+ Language.PureScript.Names: instance Data.Foldable.Foldable Language.PureScript.Names.Qualified
+ Language.PureScript.Names: instance Data.Traversable.Traversable Language.PureScript.Names.Qualified
+ Language.PureScript.Names: isBuiltinModuleName :: ModuleName -> Bool
+ Language.PureScript.Options: CoreFn :: CodegenTarget
+ Language.PureScript.Options: JS :: CodegenTarget
+ Language.PureScript.Options: JSSourceMap :: CodegenTarget
+ Language.PureScript.Options: [optionsCodegenTargets] :: Options -> Set CodegenTarget
+ Language.PureScript.Options: data CodegenTarget
+ Language.PureScript.Options: instance GHC.Classes.Eq Language.PureScript.Options.CodegenTarget
+ Language.PureScript.Options: instance GHC.Classes.Ord Language.PureScript.Options.CodegenTarget
+ Language.PureScript.Options: instance GHC.Show.Show Language.PureScript.Options.CodegenTarget
+ Language.PureScript.Parser.Common: withSourceSpanF :: Parsec [PositionedToken] u (SourceSpan -> a) -> Parsec [PositionedToken] u a
+ Language.PureScript.Sugar.AdoNotation: desugarAdoModule :: forall m. (MonadSupply m, MonadError MultipleErrors m) => Module -> m Module
+ Language.PureScript.Sugar.Names: [importSourceSpan] :: ImportRecord a -> SourceSpan
+ Language.PureScript.Sugar.Names: primEnv :: Env
+ Language.PureScript.Sugar.Names.Env: [importSourceSpan] :: ImportRecord a -> SourceSpan
+ Language.PureScript.Sugar.Names.Env: primExports :: Exports
+ Language.PureScript.Sugar.Operators.Common: type FromOp nameType a = a -> Maybe (SourceSpan, Qualified (OpName nameType))
+ Language.PureScript.Sugar.Operators.Common: type Reapply nameType a = SourceSpan -> Qualified (OpName nameType) -> a -> a -> a
+ Language.PureScript.TypeChecker.Entailment: instance GHC.Base.Functor Language.PureScript.TypeChecker.Entailment.Matched
+ Language.PureScript.TypeChecker.Entailment: instance GHC.Base.Monoid t => GHC.Base.Monoid (Language.PureScript.TypeChecker.Entailment.Matched t)
+ Language.PureScript.TypeChecker.Entailment: instance GHC.Classes.Eq t => GHC.Classes.Eq (Language.PureScript.TypeChecker.Entailment.Matched t)
+ Language.PureScript.TypeChecker.Entailment: instance GHC.Show.Show t => GHC.Show.Show (Language.PureScript.TypeChecker.Entailment.Matched t)
+ Language.PureScript.TypeChecker.Monad: lookupTypeClassDictionariesForClass :: (MonadState CheckState m) => Maybe ModuleName -> Qualified (ProperName 'ClassName) -> m (Map (Qualified Ident) NamedDict)
+ Language.PureScript.TypeClassDictionaries: [tcdChain] :: TypeClassDictionaryInScope v -> [Qualified Ident]
+ Language.PureScript.TypeClassDictionaries: [tcdIndex] :: TypeClassDictionaryInScope v -> Integer
- Control.Monad.Supply.Class: class Monad m => MonadSupply m where fresh = lift fresh peek = lift peek
+ Control.Monad.Supply.Class: class Monad m => MonadSupply m
- Language.PureScript.AST.Binders: ConstructorBinder :: (Qualified (ProperName ConstructorName)) -> [Binder] -> Binder
+ Language.PureScript.AST.Binders: ConstructorBinder :: SourceSpan -> (Qualified (ProperName 'ConstructorName)) -> [Binder] -> Binder
- Language.PureScript.AST.Binders: LiteralBinder :: (Literal Binder) -> Binder
+ Language.PureScript.AST.Binders: LiteralBinder :: SourceSpan -> (Literal Binder) -> Binder
- Language.PureScript.AST.Binders: NamedBinder :: Ident -> Binder -> Binder
+ Language.PureScript.AST.Binders: NamedBinder :: SourceSpan -> Ident -> Binder -> Binder
- Language.PureScript.AST.Binders: OpBinder :: (Qualified (OpName ValueOpName)) -> Binder
+ Language.PureScript.AST.Binders: OpBinder :: SourceSpan -> (Qualified (OpName 'ValueOpName)) -> Binder
- Language.PureScript.AST.Binders: VarBinder :: Ident -> Binder
+ Language.PureScript.AST.Binders: VarBinder :: SourceSpan -> Ident -> Binder
- Language.PureScript.AST.Declarations: CannotDerive :: (Qualified (ProperName ClassName)) -> [Type] -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: CannotDerive :: (Qualified (ProperName 'ClassName)) -> [Type] -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: CannotDeriveNewtypeForData :: (ProperName TypeName) -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: CannotDeriveNewtypeForData :: (ProperName 'TypeName) -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: CannotFindDerivingType :: (ProperName TypeName) -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: CannotFindDerivingType :: (ProperName 'TypeName) -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: ClassInstanceArityMismatch :: Ident -> (Qualified (ProperName ClassName)) -> Int -> Int -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: ClassInstanceArityMismatch :: Ident -> (Qualified (ProperName 'ClassName)) -> Int -> Int -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: Constructor :: (Qualified (ProperName ConstructorName)) -> Expr
+ Language.PureScript.AST.Declarations: Constructor :: SourceSpan -> (Qualified (ProperName 'ConstructorName)) -> Expr
- Language.PureScript.AST.Declarations: CycleInTypeSynonym :: (Maybe (ProperName TypeName)) -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: CycleInTypeSynonym :: (Maybe (ProperName 'TypeName)) -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: DataDeclaration :: SourceAnn -> DataDeclType -> (ProperName TypeName) -> [(Text, Maybe Kind)] -> [(ProperName ConstructorName, [Type])] -> Declaration
+ Language.PureScript.AST.Declarations: DataDeclaration :: SourceAnn -> DataDeclType -> (ProperName 'TypeName) -> [(Text, Maybe Kind)] -> [(ProperName 'ConstructorName, [Type])] -> Declaration
- Language.PureScript.AST.Declarations: DeferredDictionary :: (Qualified (ProperName ClassName)) -> [Type] -> Expr
+ Language.PureScript.AST.Declarations: DeferredDictionary :: (Qualified (ProperName 'ClassName)) -> [Type] -> Expr
- Language.PureScript.AST.Declarations: DuplicateModule :: ModuleName -> [SourceSpan] -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: DuplicateModule :: ModuleName -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: DuplicateTypeClass :: (ProperName ClassName) -> SourceSpan -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: DuplicateTypeClass :: (ProperName 'ClassName) -> SourceSpan -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: ErrorInDataBindingGroup :: [ProperName TypeName] -> ErrorMessageHint
+ Language.PureScript.AST.Declarations: ErrorInDataBindingGroup :: [ProperName 'TypeName] -> ErrorMessageHint
- Language.PureScript.AST.Declarations: ErrorInDataConstructor :: (ProperName ConstructorName) -> ErrorMessageHint
+ Language.PureScript.AST.Declarations: ErrorInDataConstructor :: (ProperName 'ConstructorName) -> ErrorMessageHint
- Language.PureScript.AST.Declarations: ErrorInInstance :: (Qualified (ProperName ClassName)) -> [Type] -> ErrorMessageHint
+ Language.PureScript.AST.Declarations: ErrorInInstance :: (Qualified (ProperName 'ClassName)) -> [Type] -> ErrorMessageHint
- Language.PureScript.AST.Declarations: ErrorInTypeClassDeclaration :: (ProperName ClassName) -> ErrorMessageHint
+ Language.PureScript.AST.Declarations: ErrorInTypeClassDeclaration :: (ProperName 'ClassName) -> ErrorMessageHint
- Language.PureScript.AST.Declarations: ErrorInTypeConstructor :: (ProperName TypeName) -> ErrorMessageHint
+ Language.PureScript.AST.Declarations: ErrorInTypeConstructor :: (ProperName 'TypeName) -> ErrorMessageHint
- Language.PureScript.AST.Declarations: ErrorInTypeSynonym :: (ProperName TypeName) -> ErrorMessageHint
+ Language.PureScript.AST.Declarations: ErrorInTypeSynonym :: (ProperName 'TypeName) -> ErrorMessageHint
- Language.PureScript.AST.Declarations: ExpectedTypeConstructor :: (Qualified (ProperName ClassName)) -> [Type] -> Type -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: ExpectedTypeConstructor :: (Qualified (ProperName 'ClassName)) -> [Type] -> Type -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: ExpectedWildcard :: (ProperName TypeName) -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: ExpectedWildcard :: (ProperName 'TypeName) -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: ExternDataDeclaration :: SourceAnn -> (ProperName TypeName) -> Kind -> Declaration
+ Language.PureScript.AST.Declarations: ExternDataDeclaration :: SourceAnn -> (ProperName 'TypeName) -> Kind -> Declaration
- Language.PureScript.AST.Declarations: ExternKindDeclaration :: SourceAnn -> (ProperName KindName) -> Declaration
+ Language.PureScript.AST.Declarations: ExternKindDeclaration :: SourceAnn -> (ProperName 'KindName) -> Declaration
- Language.PureScript.AST.Declarations: ExtraneousClassMember :: Ident -> (Qualified (ProperName ClassName)) -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: ExtraneousClassMember :: Ident -> (Qualified (ProperName 'ClassName)) -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: IncorrectConstructorArity :: (Qualified (ProperName ConstructorName)) -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: IncorrectConstructorArity :: (Qualified (ProperName 'ConstructorName)) -> Int -> Int -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: InvalidDerivedInstance :: (Qualified (ProperName ClassName)) -> [Type] -> Int -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: InvalidDerivedInstance :: (Qualified (ProperName 'ClassName)) -> [Type] -> Int -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: InvalidNewtype :: (ProperName TypeName) -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: InvalidNewtype :: (ProperName 'TypeName) -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: InvalidNewtypeInstance :: (Qualified (ProperName ClassName)) -> [Type] -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: InvalidNewtypeInstance :: (Qualified (ProperName 'ClassName)) -> [Type] -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: InvalidOperatorInBinder :: (Qualified (OpName ValueOpName)) -> (Qualified Ident) -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: InvalidOperatorInBinder :: (Qualified (OpName 'ValueOpName)) -> (Qualified Ident) -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: KindRef :: SourceSpan -> (ProperName KindName) -> DeclarationRef
+ Language.PureScript.AST.Declarations: KindRef :: SourceSpan -> (ProperName 'KindName) -> DeclarationRef
- Language.PureScript.AST.Declarations: Let :: [Declaration] -> Expr -> Expr
+ Language.PureScript.AST.Declarations: Let :: WhereProvenance -> [Declaration] -> Expr -> Expr
- Language.PureScript.AST.Declarations: Literal :: (Literal Expr) -> Expr
+ Language.PureScript.AST.Declarations: Literal :: SourceSpan -> (Literal Expr) -> Expr
- Language.PureScript.AST.Declarations: MisleadingEmptyTypeImport :: ModuleName -> (ProperName TypeName) -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: MisleadingEmptyTypeImport :: ModuleName -> (ProperName 'TypeName) -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: MissingNewtypeSuperclassInstance :: (Qualified (ProperName ClassName)) -> (Qualified (ProperName ClassName)) -> [Type] -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: MissingNewtypeSuperclassInstance :: (Qualified (ProperName 'ClassName)) -> (Qualified (ProperName 'ClassName)) -> [Type] -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: MultipleTypeOpFixities :: (OpName TypeOpName) -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: MultipleTypeOpFixities :: (OpName 'TypeOpName) -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: MultipleValueOpFixities :: (OpName ValueOpName) -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: MultipleValueOpFixities :: (OpName 'ValueOpName) -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: Op :: (Qualified (OpName ValueOpName)) -> Expr
+ Language.PureScript.AST.Declarations: Op :: SourceSpan -> (Qualified (OpName 'ValueOpName)) -> Expr
- Language.PureScript.AST.Declarations: OrphanInstance :: Ident -> (Qualified (ProperName ClassName)) -> (Set ModuleName) -> [Type] -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: OrphanInstance :: Ident -> (Qualified (ProperName 'ClassName)) -> (Set ModuleName) -> [Type] -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: OverlappingInstances :: (Qualified (ProperName ClassName)) -> [Type] -> [Qualified Ident] -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: OverlappingInstances :: (Qualified (ProperName 'ClassName)) -> [Type] -> [Qualified Ident] -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: PartiallyAppliedSynonym :: (Qualified (ProperName TypeName)) -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: PartiallyAppliedSynonym :: (Qualified (ProperName 'TypeName)) -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: PositionedError :: SourceSpan -> ErrorMessageHint
+ Language.PureScript.AST.Declarations: PositionedError :: (NonEmpty SourceSpan) -> ErrorMessageHint
- Language.PureScript.AST.Declarations: PossiblyInfiniteInstance :: (Qualified (ProperName ClassName)) -> [Type] -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: PossiblyInfiniteInstance :: (Qualified (ProperName 'ClassName)) -> [Type] -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: TransitiveDctorExportError :: DeclarationRef -> (ProperName ConstructorName) -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: TransitiveDctorExportError :: DeclarationRef -> (ProperName 'ConstructorName) -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: TypeClassDeclaration :: SourceAnn -> (ProperName ClassName) -> [(Text, Maybe Kind)] -> [Constraint] -> [FunctionalDependency] -> [Declaration] -> Declaration
+ Language.PureScript.AST.Declarations: TypeClassDeclaration :: SourceAnn -> (ProperName 'ClassName) -> [(Text, Maybe Kind)] -> [Constraint] -> [FunctionalDependency] -> [Declaration] -> Declaration
- Language.PureScript.AST.Declarations: TypeClassDictionary :: Constraint -> (Map (Maybe ModuleName) (Map (Qualified (ProperName ClassName)) (Map (Qualified Ident) NamedDict))) -> [ErrorMessageHint] -> Expr
+ Language.PureScript.AST.Declarations: TypeClassDictionary :: Constraint -> (Map (Maybe ModuleName) (Map (Qualified (ProperName 'ClassName)) (Map (Qualified Ident) NamedDict))) -> [ErrorMessageHint] -> Expr
- Language.PureScript.AST.Declarations: TypeClassDictionaryAccessor :: (Qualified (ProperName ClassName)) -> Ident -> Expr
+ Language.PureScript.AST.Declarations: TypeClassDictionaryAccessor :: (Qualified (ProperName 'ClassName)) -> Ident -> Expr
- Language.PureScript.AST.Declarations: TypeClassDictionaryConstructorApp :: (Qualified (ProperName ClassName)) -> Expr -> Expr
+ Language.PureScript.AST.Declarations: TypeClassDictionaryConstructorApp :: (Qualified (ProperName 'ClassName)) -> Expr -> Expr
- Language.PureScript.AST.Declarations: TypeClassRef :: SourceSpan -> (ProperName ClassName) -> DeclarationRef
+ Language.PureScript.AST.Declarations: TypeClassRef :: SourceSpan -> (ProperName 'ClassName) -> DeclarationRef
- Language.PureScript.AST.Declarations: TypeFixity :: Fixity -> (Qualified (ProperName TypeName)) -> (OpName TypeOpName) -> TypeFixity
+ Language.PureScript.AST.Declarations: TypeFixity :: Fixity -> (Qualified (ProperName 'TypeName)) -> (OpName 'TypeOpName) -> TypeFixity
- Language.PureScript.AST.Declarations: TypeInstanceDeclaration :: SourceAnn -> Ident -> [Constraint] -> (Qualified (ProperName ClassName)) -> [Type] -> TypeInstanceBody -> Declaration
+ Language.PureScript.AST.Declarations: TypeInstanceDeclaration :: SourceAnn -> [Ident] -> Integer -> Ident -> [Constraint] -> (Qualified (ProperName 'ClassName)) -> [Type] -> TypeInstanceBody -> Declaration
- Language.PureScript.AST.Declarations: TypeOpRef :: SourceSpan -> (OpName TypeOpName) -> DeclarationRef
+ Language.PureScript.AST.Declarations: TypeOpRef :: SourceSpan -> (OpName 'TypeOpName) -> DeclarationRef
- Language.PureScript.AST.Declarations: TypeRef :: SourceSpan -> (ProperName TypeName) -> (Maybe [ProperName ConstructorName]) -> DeclarationRef
+ Language.PureScript.AST.Declarations: TypeRef :: SourceSpan -> (ProperName 'TypeName) -> (Maybe [ProperName 'ConstructorName]) -> DeclarationRef
- Language.PureScript.AST.Declarations: TypeSynonymDeclaration :: SourceAnn -> (ProperName TypeName) -> [(Text, Maybe Kind)] -> Type -> Declaration
+ Language.PureScript.AST.Declarations: TypeSynonymDeclaration :: SourceAnn -> (ProperName 'TypeName) -> [(Text, Maybe Kind)] -> Type -> Declaration
- Language.PureScript.AST.Declarations: UnaryMinus :: Expr -> Expr
+ Language.PureScript.AST.Declarations: UnaryMinus :: SourceSpan -> Expr -> Expr
- Language.PureScript.AST.Declarations: UndefinedTypeVariable :: (ProperName TypeName) -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: UndefinedTypeVariable :: (ProperName 'TypeName) -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: UnknownClass :: (Qualified (ProperName ClassName)) -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: UnknownClass :: (Qualified (ProperName 'ClassName)) -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: UnknownExportDataConstructor :: (ProperName TypeName) -> (ProperName ConstructorName) -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: UnknownExportDataConstructor :: (ProperName 'TypeName) -> (ProperName 'ConstructorName) -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: UnknownImportDataConstructor :: ModuleName -> (ProperName TypeName) -> (ProperName ConstructorName) -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: UnknownImportDataConstructor :: ModuleName -> (ProperName 'TypeName) -> (ProperName 'ConstructorName) -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: UnusedDctorExplicitImport :: ModuleName -> (ProperName TypeName) -> [ProperName ConstructorName] -> (Maybe ModuleName) -> [DeclarationRef] -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: UnusedDctorExplicitImport :: ModuleName -> (ProperName 'TypeName) -> [ProperName 'ConstructorName] -> (Maybe ModuleName) -> [DeclarationRef] -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: UnusedDctorImport :: ModuleName -> (ProperName TypeName) -> (Maybe ModuleName) -> [DeclarationRef] -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: UnusedDctorImport :: ModuleName -> (ProperName 'TypeName) -> (Maybe ModuleName) -> [DeclarationRef] -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: UnverifiableSuperclassInstance :: (Qualified (ProperName ClassName)) -> (Qualified (ProperName ClassName)) -> [Type] -> SimpleErrorMessage
+ Language.PureScript.AST.Declarations: UnverifiableSuperclassInstance :: (Qualified (ProperName 'ClassName)) -> (Qualified (ProperName 'ClassName)) -> [Type] -> SimpleErrorMessage
- Language.PureScript.AST.Declarations: ValueFixity :: Fixity -> (Qualified (Either Ident (ProperName ConstructorName))) -> (OpName ValueOpName) -> ValueFixity
+ Language.PureScript.AST.Declarations: ValueFixity :: Fixity -> (Qualified (Either Ident (ProperName 'ConstructorName))) -> (OpName 'ValueOpName) -> ValueFixity
- Language.PureScript.AST.Declarations: ValueOpRef :: SourceSpan -> (OpName ValueOpName) -> DeclarationRef
+ Language.PureScript.AST.Declarations: ValueOpRef :: SourceSpan -> (OpName 'ValueOpName) -> DeclarationRef
- Language.PureScript.AST.Declarations: Var :: (Qualified Ident) -> Expr
+ Language.PureScript.AST.Declarations: Var :: SourceSpan -> (Qualified Ident) -> Expr
- Language.PureScript.AST.Declarations: getKindRef :: DeclarationRef -> Maybe (ProperName KindName)
+ Language.PureScript.AST.Declarations: getKindRef :: DeclarationRef -> Maybe (ProperName 'KindName)
- Language.PureScript.AST.Declarations: getTypeClassRef :: DeclarationRef -> Maybe (ProperName ClassName)
+ Language.PureScript.AST.Declarations: getTypeClassRef :: DeclarationRef -> Maybe (ProperName 'ClassName)
- Language.PureScript.AST.Declarations: getTypeOpRef :: DeclarationRef -> Maybe (OpName TypeOpName)
+ Language.PureScript.AST.Declarations: getTypeOpRef :: DeclarationRef -> Maybe (OpName 'TypeOpName)
- Language.PureScript.AST.Declarations: getTypeRef :: DeclarationRef -> Maybe (ProperName TypeName, Maybe [ProperName ConstructorName])
+ Language.PureScript.AST.Declarations: getTypeRef :: DeclarationRef -> Maybe (ProperName 'TypeName, Maybe [ProperName 'ConstructorName])
- Language.PureScript.AST.Declarations: getValueOpRef :: DeclarationRef -> Maybe (OpName ValueOpName)
+ Language.PureScript.AST.Declarations: getValueOpRef :: DeclarationRef -> Maybe (OpName 'ValueOpName)
- Language.PureScript.AST.Traversals: everythingWithScope :: forall r. (Monoid r) => (Set Ident -> Declaration -> r) -> (Set Ident -> Expr -> r) -> (Set Ident -> Binder -> r) -> (Set Ident -> CaseAlternative -> r) -> (Set Ident -> DoNotationElement -> r) -> (Set Ident -> Declaration -> r, Set Ident -> Expr -> r, Set Ident -> Binder -> r, Set Ident -> CaseAlternative -> r, Set Ident -> DoNotationElement -> r)
+ Language.PureScript.AST.Traversals: everythingWithScope :: forall r. (Monoid r) => (Set ScopedIdent -> Declaration -> r) -> (Set ScopedIdent -> Expr -> r) -> (Set ScopedIdent -> Binder -> r) -> (Set ScopedIdent -> CaseAlternative -> r) -> (Set ScopedIdent -> DoNotationElement -> r) -> (Set ScopedIdent -> Declaration -> r, Set ScopedIdent -> Expr -> r, Set ScopedIdent -> Binder -> r, Set ScopedIdent -> CaseAlternative -> r, Set ScopedIdent -> DoNotationElement -> r)
- Language.PureScript.Constants: orderingEQ :: Qualified (ProperName TypeName)
+ Language.PureScript.Constants: orderingEQ :: Qualified (ProperName 'TypeName)
- Language.PureScript.Constants: orderingGT :: Qualified (ProperName TypeName)
+ Language.PureScript.Constants: orderingGT :: Qualified (ProperName 'TypeName)
- Language.PureScript.Constants: orderingLT :: Qualified (ProperName TypeName)
+ Language.PureScript.Constants: orderingLT :: Qualified (ProperName 'TypeName)
- Language.PureScript.CoreFn.Binders: ConstructorBinder :: a -> (Qualified (ProperName TypeName)) -> (Qualified (ProperName ConstructorName)) -> [Binder a] -> Binder a
+ Language.PureScript.CoreFn.Binders: ConstructorBinder :: a -> (Qualified (ProperName 'TypeName)) -> (Qualified (ProperName 'ConstructorName)) -> [Binder a] -> Binder a
- Language.PureScript.CoreFn.Expr: Constructor :: a -> (ProperName TypeName) -> (ProperName ConstructorName) -> [Ident] -> Expr a
+ Language.PureScript.CoreFn.Expr: Constructor :: a -> (ProperName 'TypeName) -> (ProperName 'ConstructorName) -> [Ident] -> Expr a
- Language.PureScript.CoreFn.Module: Module :: [Comment] -> ModuleName -> [(a, ModuleName)] -> [Ident] -> [ForeignDecl] -> [Bind a] -> Module a
+ Language.PureScript.CoreFn.Module: Module :: SourceSpan -> [Comment] -> ModuleName -> FilePath -> [(a, ModuleName)] -> [Ident] -> [Ident] -> [Bind a] -> Module a
- Language.PureScript.CoreFn.Module: [moduleForeign] :: Module a -> [ForeignDecl]
+ Language.PureScript.CoreFn.Module: [moduleForeign] :: Module a -> [Ident]
- Language.PureScript.CoreFn.ToJSON: moduleToJSON :: Version -> Module a -> Value
+ Language.PureScript.CoreFn.ToJSON: moduleToJSON :: Version -> Module Ann -> Value
- Language.PureScript.Docs.ParseInPackage: parseFilesInPackages :: (MonadError MultipleErrors m, MonadIO m) => [FilePath] -> [(PackageName, FilePath)] -> m ([Module], Map ModuleName PackageName)
+ Language.PureScript.Docs.ParseInPackage: parseFilesInPackages :: (MonadError MultipleErrors m, MonadIO m) => [FilePath] -> [(PackageName, FilePath)] -> m ([(FilePath, Module)], Map ModuleName PackageName)
- Language.PureScript.Docs.RenderedCode.Types: dataCtor :: Qualified (ProperName ConstructorName) -> RenderedCode
+ Language.PureScript.Docs.RenderedCode.Types: dataCtor :: Qualified (ProperName 'ConstructorName) -> RenderedCode
- Language.PureScript.Docs.RenderedCode.Types: kind :: Qualified (ProperName KindName) -> RenderedCode
+ Language.PureScript.Docs.RenderedCode.Types: kind :: Qualified (ProperName 'KindName) -> RenderedCode
- Language.PureScript.Docs.RenderedCode.Types: type FixityAlias = Qualified (Either (ProperName TypeName) (Either Ident (ProperName ConstructorName)))
+ Language.PureScript.Docs.RenderedCode.Types: type FixityAlias = Qualified (Either (ProperName 'TypeName) (Either Ident (ProperName 'ConstructorName)))
- Language.PureScript.Docs.RenderedCode.Types: typeCtor :: Qualified (ProperName TypeName) -> RenderedCode
+ Language.PureScript.Docs.RenderedCode.Types: typeCtor :: Qualified (ProperName 'TypeName) -> RenderedCode
- Language.PureScript.Docs.RenderedCode.Types: typeOp :: Qualified (OpName TypeOpName) -> RenderedCode
+ Language.PureScript.Docs.RenderedCode.Types: typeOp :: Qualified (OpName 'TypeOpName) -> RenderedCode
- Language.PureScript.Environment: DataType :: [(Text, Maybe Kind)] -> [(ProperName ConstructorName, [Type])] -> TypeKind
+ Language.PureScript.Environment: DataType :: [(Text, Maybe Kind)] -> [(ProperName 'ConstructorName, [Type])] -> TypeKind
- Language.PureScript.Environment: Environment :: Map (Qualified Ident) (Type, NameKind, NameVisibility) -> Map (Qualified (ProperName TypeName)) (Kind, TypeKind) -> Map (Qualified (ProperName ConstructorName)) (DataDeclType, ProperName TypeName, Type, [Ident]) -> Map (Qualified (ProperName TypeName)) ([(Text, Maybe Kind)], Type) -> Map (Maybe ModuleName) (Map (Qualified (ProperName ClassName)) (Map (Qualified Ident) NamedDict)) -> Map (Qualified (ProperName ClassName)) TypeClassData -> Set (Qualified (ProperName KindName)) -> Environment
+ Language.PureScript.Environment: Environment :: Map (Qualified Ident) (Type, NameKind, NameVisibility) -> Map (Qualified (ProperName 'TypeName)) (Kind, TypeKind) -> Map (Qualified (ProperName 'ConstructorName)) (DataDeclType, ProperName 'TypeName, Type, [Ident]) -> Map (Qualified (ProperName 'TypeName)) ([(Text, Maybe Kind)], Type) -> Map (Maybe ModuleName) (Map (Qualified (ProperName 'ClassName)) (Map (Qualified Ident) NamedDict)) -> Map (Qualified (ProperName 'ClassName)) TypeClassData -> Set (Qualified (ProperName 'KindName)) -> Environment
- Language.PureScript.Environment: [dataConstructors] :: Environment -> Map (Qualified (ProperName ConstructorName)) (DataDeclType, ProperName TypeName, Type, [Ident])
+ Language.PureScript.Environment: [dataConstructors] :: Environment -> Map (Qualified (ProperName 'ConstructorName)) (DataDeclType, ProperName 'TypeName, Type, [Ident])
- Language.PureScript.Environment: [kinds] :: Environment -> Set (Qualified (ProperName KindName))
+ Language.PureScript.Environment: [kinds] :: Environment -> Set (Qualified (ProperName 'KindName))
- Language.PureScript.Environment: [typeClassDictionaries] :: Environment -> Map (Maybe ModuleName) (Map (Qualified (ProperName ClassName)) (Map (Qualified Ident) NamedDict))
+ Language.PureScript.Environment: [typeClassDictionaries] :: Environment -> Map (Maybe ModuleName) (Map (Qualified (ProperName 'ClassName)) (Map (Qualified Ident) NamedDict))
- Language.PureScript.Environment: [typeClasses] :: Environment -> Map (Qualified (ProperName ClassName)) TypeClassData
+ Language.PureScript.Environment: [typeClasses] :: Environment -> Map (Qualified (ProperName 'ClassName)) TypeClassData
- Language.PureScript.Environment: [typeSynonyms] :: Environment -> Map (Qualified (ProperName TypeName)) ([(Text, Maybe Kind)], Type)
+ Language.PureScript.Environment: [typeSynonyms] :: Environment -> Map (Qualified (ProperName 'TypeName)) ([(Text, Maybe Kind)], Type)
- Language.PureScript.Environment: [types] :: Environment -> Map (Qualified (ProperName TypeName)) (Kind, TypeKind)
+ Language.PureScript.Environment: [types] :: Environment -> Map (Qualified (ProperName 'TypeName)) (Kind, TypeKind)
- Language.PureScript.Environment: isNewtypeConstructor :: Environment -> Qualified (ProperName ConstructorName) -> Bool
+ Language.PureScript.Environment: isNewtypeConstructor :: Environment -> Qualified (ProperName 'ConstructorName) -> Bool
- Language.PureScript.Environment: lookupConstructor :: Environment -> Qualified (ProperName ConstructorName) -> (DataDeclType, ProperName TypeName, Type, [Ident])
+ Language.PureScript.Environment: lookupConstructor :: Environment -> Qualified (ProperName 'ConstructorName) -> (DataDeclType, ProperName 'TypeName, Type, [Ident])
- Language.PureScript.Environment: primClasses :: Map (Qualified (ProperName ClassName)) TypeClassData
+ Language.PureScript.Environment: primClasses :: Map (Qualified (ProperName 'ClassName)) TypeClassData
- Language.PureScript.Environment: primKinds :: Set (Qualified (ProperName KindName))
+ Language.PureScript.Environment: primKinds :: Set (Qualified (ProperName 'KindName))
- Language.PureScript.Environment: primTypes :: Map (Qualified (ProperName TypeName)) (Kind, TypeKind)
+ Language.PureScript.Environment: primTypes :: Map (Qualified (ProperName 'TypeName)) (Kind, TypeKind)
- Language.PureScript.Errors: errorSpan :: ErrorMessage -> Maybe SourceSpan
+ Language.PureScript.Errors: errorSpan :: ErrorMessage -> Maybe (NonEmpty SourceSpan)
- Language.PureScript.Errors.JSON: JSONError :: Maybe ErrorPosition -> String -> Text -> Text -> Maybe String -> Maybe Text -> Maybe ErrorSuggestion -> JSONError
+ Language.PureScript.Errors.JSON: JSONError :: Maybe ErrorPosition -> String -> Text -> Text -> Maybe String -> Maybe Text -> Maybe ErrorSuggestion -> [SourceSpan] -> JSONError
- Language.PureScript.Externs: EDClass :: ProperName ClassName -> [(Text, Maybe Kind)] -> [(Ident, Type)] -> [Constraint] -> [FunctionalDependency] -> ExternsDeclaration
+ Language.PureScript.Externs: EDClass :: ProperName 'ClassName -> [(Text, Maybe Kind)] -> [(Ident, Type)] -> [Constraint] -> [FunctionalDependency] -> ExternsDeclaration
- Language.PureScript.Externs: EDDataConstructor :: ProperName ConstructorName -> DataDeclType -> ProperName TypeName -> Type -> [Ident] -> ExternsDeclaration
+ Language.PureScript.Externs: EDDataConstructor :: ProperName 'ConstructorName -> DataDeclType -> ProperName 'TypeName -> Type -> [Ident] -> ExternsDeclaration
- Language.PureScript.Externs: EDInstance :: Qualified (ProperName ClassName) -> Ident -> [Type] -> Maybe [Constraint] -> ExternsDeclaration
+ Language.PureScript.Externs: EDInstance :: Qualified (ProperName 'ClassName) -> Ident -> [Type] -> Maybe [Constraint] -> [Qualified Ident] -> Integer -> ExternsDeclaration
- Language.PureScript.Externs: EDKind :: ProperName KindName -> ExternsDeclaration
+ Language.PureScript.Externs: EDKind :: ProperName 'KindName -> ExternsDeclaration
- Language.PureScript.Externs: EDType :: ProperName TypeName -> Kind -> TypeKind -> ExternsDeclaration
+ Language.PureScript.Externs: EDType :: ProperName 'TypeName -> Kind -> TypeKind -> ExternsDeclaration
- Language.PureScript.Externs: EDTypeSynonym :: ProperName TypeName -> [(Text, Maybe Kind)] -> Type -> ExternsDeclaration
+ Language.PureScript.Externs: EDTypeSynonym :: ProperName 'TypeName -> [(Text, Maybe Kind)] -> Type -> ExternsDeclaration
- Language.PureScript.Externs: ExternsFixity :: Associativity -> Precedence -> OpName ValueOpName -> Qualified (Either Ident (ProperName ConstructorName)) -> ExternsFixity
+ Language.PureScript.Externs: ExternsFixity :: Associativity -> Precedence -> OpName 'ValueOpName -> Qualified (Either Ident (ProperName 'ConstructorName)) -> ExternsFixity
- Language.PureScript.Externs: ExternsTypeFixity :: Associativity -> Precedence -> OpName TypeOpName -> Qualified (ProperName TypeName) -> ExternsTypeFixity
+ Language.PureScript.Externs: ExternsTypeFixity :: Associativity -> Precedence -> OpName 'TypeOpName -> Qualified (ProperName 'TypeName) -> ExternsTypeFixity
- Language.PureScript.Externs: [edClassName] :: ExternsDeclaration -> ProperName ClassName
+ Language.PureScript.Externs: [edClassName] :: ExternsDeclaration -> ProperName 'ClassName
- Language.PureScript.Externs: [edDataCtorName] :: ExternsDeclaration -> ProperName ConstructorName
+ Language.PureScript.Externs: [edDataCtorName] :: ExternsDeclaration -> ProperName 'ConstructorName
- Language.PureScript.Externs: [edDataCtorTypeCtor] :: ExternsDeclaration -> ProperName TypeName
+ Language.PureScript.Externs: [edDataCtorTypeCtor] :: ExternsDeclaration -> ProperName 'TypeName
- Language.PureScript.Externs: [edInstanceClassName] :: ExternsDeclaration -> Qualified (ProperName ClassName)
+ Language.PureScript.Externs: [edInstanceClassName] :: ExternsDeclaration -> Qualified (ProperName 'ClassName)
- Language.PureScript.Externs: [edKindName] :: ExternsDeclaration -> ProperName KindName
+ Language.PureScript.Externs: [edKindName] :: ExternsDeclaration -> ProperName 'KindName
- Language.PureScript.Externs: [edTypeName] :: ExternsDeclaration -> ProperName TypeName
+ Language.PureScript.Externs: [edTypeName] :: ExternsDeclaration -> ProperName 'TypeName
- Language.PureScript.Externs: [edTypeSynonymName] :: ExternsDeclaration -> ProperName TypeName
+ Language.PureScript.Externs: [edTypeSynonymName] :: ExternsDeclaration -> ProperName 'TypeName
- Language.PureScript.Externs: [efAlias] :: ExternsFixity -> Qualified (Either Ident (ProperName ConstructorName))
+ Language.PureScript.Externs: [efAlias] :: ExternsFixity -> Qualified (Either Ident (ProperName 'ConstructorName))
- Language.PureScript.Externs: [efOperator] :: ExternsFixity -> OpName ValueOpName
+ Language.PureScript.Externs: [efOperator] :: ExternsFixity -> OpName 'ValueOpName
- Language.PureScript.Externs: [efTypeAlias] :: ExternsTypeFixity -> Qualified (ProperName TypeName)
+ Language.PureScript.Externs: [efTypeAlias] :: ExternsTypeFixity -> Qualified (ProperName 'TypeName)
- Language.PureScript.Externs: [efTypeOperator] :: ExternsTypeFixity -> OpName TypeOpName
+ Language.PureScript.Externs: [efTypeOperator] :: ExternsTypeFixity -> OpName 'TypeOpName
- Language.PureScript.Hierarchy: SuperMap :: Either (ProperName ClassName) (ProperName ClassName, ProperName ClassName) -> SuperMap
+ Language.PureScript.Hierarchy: SuperMap :: Either (ProperName 'ClassName) (ProperName 'ClassName, ProperName 'ClassName) -> SuperMap
- Language.PureScript.Hierarchy: [_unSuperMap] :: SuperMap -> Either (ProperName ClassName) (ProperName ClassName, ProperName ClassName)
+ Language.PureScript.Hierarchy: [_unSuperMap] :: SuperMap -> Either (ProperName 'ClassName) (ProperName 'ClassName, ProperName 'ClassName)
- Language.PureScript.Ide.Prim: idePrimDeclarations :: [IdeDeclarationAnn]
+ Language.PureScript.Ide.Prim: idePrimDeclarations :: [(ModuleName, [IdeDeclarationAnn])]
- Language.PureScript.Ide.State: getAllModules :: Ide m => Maybe ModuleName -> m [(ModuleName, [IdeDeclarationAnn])]
+ Language.PureScript.Ide.State: getAllModules :: Ide m => Maybe ModuleName -> m (ModuleMap [IdeDeclarationAnn])
- Language.PureScript.Ide.Types: IdeDataConstructor :: ProperName ConstructorName -> ProperName TypeName -> Type -> IdeDataConstructor
+ Language.PureScript.Ide.Types: IdeDataConstructor :: ProperName 'ConstructorName -> ProperName 'TypeName -> Type -> IdeDataConstructor
- Language.PureScript.Ide.Types: IdeDeclKind :: (ProperName KindName) -> IdeDeclaration
+ Language.PureScript.Ide.Types: IdeDeclKind :: (ProperName 'KindName) -> IdeDeclaration
- Language.PureScript.Ide.Types: IdeType :: ProperName TypeName -> Kind -> [(ProperName ConstructorName, Type)] -> IdeType
+ Language.PureScript.Ide.Types: IdeType :: ProperName 'TypeName -> Kind -> [(ProperName 'ConstructorName, Type)] -> IdeType
- Language.PureScript.Ide.Types: IdeTypeClass :: ProperName ClassName -> Kind -> [IdeInstance] -> IdeTypeClass
+ Language.PureScript.Ide.Types: IdeTypeClass :: ProperName 'ClassName -> Kind -> [IdeInstance] -> IdeTypeClass
- Language.PureScript.Ide.Types: IdeTypeOperator :: OpName TypeOpName -> Qualified (ProperName TypeName) -> Precedence -> Associativity -> Maybe Kind -> IdeTypeOperator
+ Language.PureScript.Ide.Types: IdeTypeOperator :: OpName 'TypeOpName -> Qualified (ProperName 'TypeName) -> Precedence -> Associativity -> Maybe Kind -> IdeTypeOperator
- Language.PureScript.Ide.Types: IdeTypeSynonym :: ProperName TypeName -> Type -> Kind -> IdeTypeSynonym
+ Language.PureScript.Ide.Types: IdeTypeSynonym :: ProperName 'TypeName -> Type -> Kind -> IdeTypeSynonym
- Language.PureScript.Ide.Types: IdeValueOperator :: OpName ValueOpName -> Qualified (Either Ident (ProperName ConstructorName)) -> Precedence -> Associativity -> Maybe Type -> IdeValueOperator
+ Language.PureScript.Ide.Types: IdeValueOperator :: OpName 'ValueOpName -> Qualified (Either Ident (ProperName 'ConstructorName)) -> Precedence -> Associativity -> Maybe Type -> IdeValueOperator
- Language.PureScript.Ide.Types: [_ideDtorName] :: IdeDataConstructor -> ProperName ConstructorName
+ Language.PureScript.Ide.Types: [_ideDtorName] :: IdeDataConstructor -> ProperName 'ConstructorName
- Language.PureScript.Ide.Types: [_ideDtorTypeName] :: IdeDataConstructor -> ProperName TypeName
+ Language.PureScript.Ide.Types: [_ideDtorTypeName] :: IdeDataConstructor -> ProperName 'TypeName
- Language.PureScript.Ide.Types: [_ideSynonymName] :: IdeTypeSynonym -> ProperName TypeName
+ Language.PureScript.Ide.Types: [_ideSynonymName] :: IdeTypeSynonym -> ProperName 'TypeName
- Language.PureScript.Ide.Types: [_ideTCName] :: IdeTypeClass -> ProperName ClassName
+ Language.PureScript.Ide.Types: [_ideTCName] :: IdeTypeClass -> ProperName 'ClassName
- Language.PureScript.Ide.Types: [_ideTypeDtors] :: IdeType -> [(ProperName ConstructorName, Type)]
+ Language.PureScript.Ide.Types: [_ideTypeDtors] :: IdeType -> [(ProperName 'ConstructorName, Type)]
- Language.PureScript.Ide.Types: [_ideTypeName] :: IdeType -> ProperName TypeName
+ Language.PureScript.Ide.Types: [_ideTypeName] :: IdeType -> ProperName 'TypeName
- Language.PureScript.Ide.Types: [_ideTypeOpAlias] :: IdeTypeOperator -> Qualified (ProperName TypeName)
+ Language.PureScript.Ide.Types: [_ideTypeOpAlias] :: IdeTypeOperator -> Qualified (ProperName 'TypeName)
- Language.PureScript.Ide.Types: [_ideTypeOpName] :: IdeTypeOperator -> OpName TypeOpName
+ Language.PureScript.Ide.Types: [_ideTypeOpName] :: IdeTypeOperator -> OpName 'TypeOpName
- Language.PureScript.Ide.Types: [_ideValueOpAlias] :: IdeValueOperator -> Qualified (Either Ident (ProperName ConstructorName))
+ Language.PureScript.Ide.Types: [_ideValueOpAlias] :: IdeValueOperator -> Qualified (Either Ident (ProperName 'ConstructorName))
- Language.PureScript.Ide.Types: [_ideValueOpName] :: IdeValueOperator -> OpName ValueOpName
+ Language.PureScript.Ide.Types: [_ideValueOpName] :: IdeValueOperator -> OpName 'ValueOpName
- Language.PureScript.Ide.Util: ideReadFile :: (MonadIO m, MonadError IdeError m) => FilePath -> m Text
+ Language.PureScript.Ide.Util: ideReadFile :: (MonadIO m, MonadError IdeError m) => FilePath -> m (FilePath, Text)
- Language.PureScript.Ide.Util: typeOperatorAliasT :: Qualified (ProperName TypeName) -> Text
+ Language.PureScript.Ide.Util: typeOperatorAliasT :: Qualified (ProperName 'TypeName) -> Text
- Language.PureScript.Ide.Util: valueOperatorAliasT :: Qualified (Either Ident (ProperName ConstructorName)) -> Text
+ Language.PureScript.Ide.Util: valueOperatorAliasT :: Qualified (Either Ident (ProperName 'ConstructorName)) -> Text
- Language.PureScript.Kinds: NamedKind :: (Qualified (ProperName KindName)) -> Kind
+ Language.PureScript.Kinds: NamedKind :: (Qualified (ProperName 'KindName)) -> Kind
- Language.PureScript.Linter.Imports: DctorName :: (ProperName ConstructorName) -> Name
+ Language.PureScript.Linter.Imports: DctorName :: (ProperName 'ConstructorName) -> Name
- Language.PureScript.Linter.Imports: KiName :: (ProperName KindName) -> Name
+ Language.PureScript.Linter.Imports: KiName :: (ProperName 'KindName) -> Name
- Language.PureScript.Linter.Imports: TyClassName :: (ProperName ClassName) -> Name
+ Language.PureScript.Linter.Imports: TyClassName :: (ProperName 'ClassName) -> Name
- Language.PureScript.Linter.Imports: TyName :: (ProperName TypeName) -> Name
+ Language.PureScript.Linter.Imports: TyName :: (ProperName 'TypeName) -> Name
- Language.PureScript.Linter.Imports: TyOpName :: (OpName TypeOpName) -> Name
+ Language.PureScript.Linter.Imports: TyOpName :: (OpName 'TypeOpName) -> Name
- Language.PureScript.Linter.Imports: ValOpName :: (OpName ValueOpName) -> Name
+ Language.PureScript.Linter.Imports: ValOpName :: (OpName 'ValueOpName) -> Name
- Language.PureScript.Names: DctorName :: (ProperName ConstructorName) -> Name
+ Language.PureScript.Names: DctorName :: (ProperName 'ConstructorName) -> Name
- Language.PureScript.Names: KiName :: (ProperName KindName) -> Name
+ Language.PureScript.Names: KiName :: (ProperName 'KindName) -> Name
- Language.PureScript.Names: ModuleName :: [ProperName Namespace] -> ModuleName
+ Language.PureScript.Names: ModuleName :: [ProperName 'Namespace] -> ModuleName
- Language.PureScript.Names: TyClassName :: (ProperName ClassName) -> Name
+ Language.PureScript.Names: TyClassName :: (ProperName 'ClassName) -> Name
- Language.PureScript.Names: TyName :: (ProperName TypeName) -> Name
+ Language.PureScript.Names: TyName :: (ProperName 'TypeName) -> Name
- Language.PureScript.Names: TyOpName :: (OpName TypeOpName) -> Name
+ Language.PureScript.Names: TyOpName :: (OpName 'TypeOpName) -> Name
- Language.PureScript.Names: ValOpName :: (OpName ValueOpName) -> Name
+ Language.PureScript.Names: ValOpName :: (OpName 'ValueOpName) -> Name
- Language.PureScript.Names: getClassName :: Name -> Maybe (ProperName ClassName)
+ Language.PureScript.Names: getClassName :: Name -> Maybe (ProperName 'ClassName)
- Language.PureScript.Names: getDctorName :: Name -> Maybe (ProperName ConstructorName)
+ Language.PureScript.Names: getDctorName :: Name -> Maybe (ProperName 'ConstructorName)
- Language.PureScript.Names: getKindName :: Name -> Maybe (ProperName KindName)
+ Language.PureScript.Names: getKindName :: Name -> Maybe (ProperName 'KindName)
- Language.PureScript.Names: getTypeName :: Name -> Maybe (ProperName TypeName)
+ Language.PureScript.Names: getTypeName :: Name -> Maybe (ProperName 'TypeName)
- Language.PureScript.Names: getTypeOpName :: Name -> Maybe (OpName TypeOpName)
+ Language.PureScript.Names: getTypeOpName :: Name -> Maybe (OpName 'TypeOpName)
- Language.PureScript.Names: getValOpName :: Name -> Maybe (OpName ValueOpName)
+ Language.PureScript.Names: getValOpName :: Name -> Maybe (OpName 'ValueOpName)
- Language.PureScript.Options: Options :: Bool -> Bool -> Bool -> Bool -> Options
+ Language.PureScript.Options: Options :: Bool -> Bool -> Set CodegenTarget -> Options
- Language.PureScript.Parser.Common: dataConstructorName :: TokenParser (ProperName ConstructorName)
+ Language.PureScript.Parser.Common: dataConstructorName :: TokenParser (ProperName 'ConstructorName)
- Language.PureScript.Parser.Common: kindName :: TokenParser (ProperName KindName)
+ Language.PureScript.Parser.Common: kindName :: TokenParser (ProperName 'KindName)
- Language.PureScript.Parser.Common: typeName :: TokenParser (ProperName TypeName)
+ Language.PureScript.Parser.Common: typeName :: TokenParser (ProperName 'TypeName)
- Language.PureScript.Parser.Declarations: parseDeclaration :: TokenParser Declaration
+ Language.PureScript.Parser.Declarations: parseDeclaration :: TokenParser [Declaration]
- Language.PureScript.Sugar.Names: Exports :: Map (ProperName TypeName) ([ProperName ConstructorName], ModuleName) -> Map (OpName TypeOpName) ModuleName -> Map (ProperName ClassName) ModuleName -> Map Ident ModuleName -> Map (OpName ValueOpName) ModuleName -> Map (ProperName KindName) ModuleName -> Exports
+ Language.PureScript.Sugar.Names: Exports :: Map (ProperName 'TypeName) ([ProperName 'ConstructorName], ModuleName) -> Map (OpName 'TypeOpName) ModuleName -> Map (ProperName 'ClassName) ModuleName -> Map Ident ModuleName -> Map (OpName 'ValueOpName) ModuleName -> Map (ProperName 'KindName) ModuleName -> Exports
- Language.PureScript.Sugar.Names: ImportRecord :: Qualified a -> ModuleName -> ImportProvenance -> ImportRecord a
+ Language.PureScript.Sugar.Names: ImportRecord :: Qualified a -> ModuleName -> SourceSpan -> ImportProvenance -> ImportRecord a
- Language.PureScript.Sugar.Names: Imports :: ImportMap (ProperName TypeName) -> ImportMap (OpName TypeOpName) -> ImportMap (ProperName ConstructorName) -> ImportMap (ProperName ClassName) -> ImportMap Ident -> ImportMap (OpName ValueOpName) -> Set ModuleName -> Set ModuleName -> ImportMap (ProperName KindName) -> Imports
+ Language.PureScript.Sugar.Names: Imports :: ImportMap (ProperName 'TypeName) -> ImportMap (OpName 'TypeOpName) -> ImportMap (ProperName 'ConstructorName) -> ImportMap (ProperName 'ClassName) -> ImportMap Ident -> ImportMap (OpName 'ValueOpName) -> Set ModuleName -> Set ModuleName -> ImportMap (ProperName 'KindName) -> Imports
- Language.PureScript.Sugar.Names: [exportedKinds] :: Exports -> Map (ProperName KindName) ModuleName
+ Language.PureScript.Sugar.Names: [exportedKinds] :: Exports -> Map (ProperName 'KindName) ModuleName
- Language.PureScript.Sugar.Names: [exportedTypeClasses] :: Exports -> Map (ProperName ClassName) ModuleName
+ Language.PureScript.Sugar.Names: [exportedTypeClasses] :: Exports -> Map (ProperName 'ClassName) ModuleName
- Language.PureScript.Sugar.Names: [exportedTypeOps] :: Exports -> Map (OpName TypeOpName) ModuleName
+ Language.PureScript.Sugar.Names: [exportedTypeOps] :: Exports -> Map (OpName 'TypeOpName) ModuleName
- Language.PureScript.Sugar.Names: [exportedTypes] :: Exports -> Map (ProperName TypeName) ([ProperName ConstructorName], ModuleName)
+ Language.PureScript.Sugar.Names: [exportedTypes] :: Exports -> Map (ProperName 'TypeName) ([ProperName 'ConstructorName], ModuleName)
- Language.PureScript.Sugar.Names: [exportedValueOps] :: Exports -> Map (OpName ValueOpName) ModuleName
+ Language.PureScript.Sugar.Names: [exportedValueOps] :: Exports -> Map (OpName 'ValueOpName) ModuleName
- Language.PureScript.Sugar.Names: [importedDataConstructors] :: Imports -> ImportMap (ProperName ConstructorName)
+ Language.PureScript.Sugar.Names: [importedDataConstructors] :: Imports -> ImportMap (ProperName 'ConstructorName)
- Language.PureScript.Sugar.Names: [importedKinds] :: Imports -> ImportMap (ProperName KindName)
+ Language.PureScript.Sugar.Names: [importedKinds] :: Imports -> ImportMap (ProperName 'KindName)
- Language.PureScript.Sugar.Names: [importedTypeClasses] :: Imports -> ImportMap (ProperName ClassName)
+ Language.PureScript.Sugar.Names: [importedTypeClasses] :: Imports -> ImportMap (ProperName 'ClassName)
- Language.PureScript.Sugar.Names: [importedTypeOps] :: Imports -> ImportMap (OpName TypeOpName)
+ Language.PureScript.Sugar.Names: [importedTypeOps] :: Imports -> ImportMap (OpName 'TypeOpName)
- Language.PureScript.Sugar.Names: [importedTypes] :: Imports -> ImportMap (ProperName TypeName)
+ Language.PureScript.Sugar.Names: [importedTypes] :: Imports -> ImportMap (ProperName 'TypeName)
- Language.PureScript.Sugar.Names: [importedValueOps] :: Imports -> ImportMap (OpName ValueOpName)
+ Language.PureScript.Sugar.Names: [importedValueOps] :: Imports -> ImportMap (OpName 'ValueOpName)
- Language.PureScript.Sugar.Names.Env: Exports :: Map (ProperName TypeName) ([ProperName ConstructorName], ModuleName) -> Map (OpName TypeOpName) ModuleName -> Map (ProperName ClassName) ModuleName -> Map Ident ModuleName -> Map (OpName ValueOpName) ModuleName -> Map (ProperName KindName) ModuleName -> Exports
+ Language.PureScript.Sugar.Names.Env: Exports :: Map (ProperName 'TypeName) ([ProperName 'ConstructorName], ModuleName) -> Map (OpName 'TypeOpName) ModuleName -> Map (ProperName 'ClassName) ModuleName -> Map Ident ModuleName -> Map (OpName 'ValueOpName) ModuleName -> Map (ProperName 'KindName) ModuleName -> Exports
- Language.PureScript.Sugar.Names.Env: ImportRecord :: Qualified a -> ModuleName -> ImportProvenance -> ImportRecord a
+ Language.PureScript.Sugar.Names.Env: ImportRecord :: Qualified a -> ModuleName -> SourceSpan -> ImportProvenance -> ImportRecord a
- Language.PureScript.Sugar.Names.Env: Imports :: ImportMap (ProperName TypeName) -> ImportMap (OpName TypeOpName) -> ImportMap (ProperName ConstructorName) -> ImportMap (ProperName ClassName) -> ImportMap Ident -> ImportMap (OpName ValueOpName) -> Set ModuleName -> Set ModuleName -> ImportMap (ProperName KindName) -> Imports
+ Language.PureScript.Sugar.Names.Env: Imports :: ImportMap (ProperName 'TypeName) -> ImportMap (OpName 'TypeOpName) -> ImportMap (ProperName 'ConstructorName) -> ImportMap (ProperName 'ClassName) -> ImportMap Ident -> ImportMap (OpName 'ValueOpName) -> Set ModuleName -> Set ModuleName -> ImportMap (ProperName 'KindName) -> Imports
- Language.PureScript.Sugar.Names.Env: [exportedKinds] :: Exports -> Map (ProperName KindName) ModuleName
+ Language.PureScript.Sugar.Names.Env: [exportedKinds] :: Exports -> Map (ProperName 'KindName) ModuleName
- Language.PureScript.Sugar.Names.Env: [exportedTypeClasses] :: Exports -> Map (ProperName ClassName) ModuleName
+ Language.PureScript.Sugar.Names.Env: [exportedTypeClasses] :: Exports -> Map (ProperName 'ClassName) ModuleName
- Language.PureScript.Sugar.Names.Env: [exportedTypeOps] :: Exports -> Map (OpName TypeOpName) ModuleName
+ Language.PureScript.Sugar.Names.Env: [exportedTypeOps] :: Exports -> Map (OpName 'TypeOpName) ModuleName
- Language.PureScript.Sugar.Names.Env: [exportedTypes] :: Exports -> Map (ProperName TypeName) ([ProperName ConstructorName], ModuleName)
+ Language.PureScript.Sugar.Names.Env: [exportedTypes] :: Exports -> Map (ProperName 'TypeName) ([ProperName 'ConstructorName], ModuleName)
- Language.PureScript.Sugar.Names.Env: [exportedValueOps] :: Exports -> Map (OpName ValueOpName) ModuleName
+ Language.PureScript.Sugar.Names.Env: [exportedValueOps] :: Exports -> Map (OpName 'ValueOpName) ModuleName
- Language.PureScript.Sugar.Names.Env: [importedDataConstructors] :: Imports -> ImportMap (ProperName ConstructorName)
+ Language.PureScript.Sugar.Names.Env: [importedDataConstructors] :: Imports -> ImportMap (ProperName 'ConstructorName)
- Language.PureScript.Sugar.Names.Env: [importedKinds] :: Imports -> ImportMap (ProperName KindName)
+ Language.PureScript.Sugar.Names.Env: [importedKinds] :: Imports -> ImportMap (ProperName 'KindName)
- Language.PureScript.Sugar.Names.Env: [importedTypeClasses] :: Imports -> ImportMap (ProperName ClassName)
+ Language.PureScript.Sugar.Names.Env: [importedTypeClasses] :: Imports -> ImportMap (ProperName 'ClassName)
- Language.PureScript.Sugar.Names.Env: [importedTypeOps] :: Imports -> ImportMap (OpName TypeOpName)
+ Language.PureScript.Sugar.Names.Env: [importedTypeOps] :: Imports -> ImportMap (OpName 'TypeOpName)
- Language.PureScript.Sugar.Names.Env: [importedTypes] :: Imports -> ImportMap (ProperName TypeName)
+ Language.PureScript.Sugar.Names.Env: [importedTypes] :: Imports -> ImportMap (ProperName 'TypeName)
- Language.PureScript.Sugar.Names.Env: [importedValueOps] :: Imports -> ImportMap (OpName ValueOpName)
+ Language.PureScript.Sugar.Names.Env: [importedValueOps] :: Imports -> ImportMap (OpName 'ValueOpName)
- Language.PureScript.Sugar.Names.Env: checkImportConflicts :: forall m a. (MonadError MultipleErrors m, MonadWriter MultipleErrors m) => ModuleName -> (a -> Name) -> [ImportRecord a] -> m (ModuleName, ModuleName)
+ Language.PureScript.Sugar.Names.Env: checkImportConflicts :: forall m a. (MonadError MultipleErrors m, MonadWriter MultipleErrors m) => SourceSpan -> ModuleName -> (a -> Name) -> [ImportRecord a] -> m (ModuleName, ModuleName)
- Language.PureScript.Sugar.Names.Env: exportKind :: MonadError MultipleErrors m => Exports -> ProperName KindName -> ModuleName -> m Exports
+ Language.PureScript.Sugar.Names.Env: exportKind :: MonadError MultipleErrors m => SourceSpan -> Exports -> ProperName 'KindName -> ModuleName -> m Exports
- Language.PureScript.Sugar.Names.Env: exportType :: MonadError MultipleErrors m => ExportMode -> Exports -> ProperName TypeName -> [ProperName ConstructorName] -> ModuleName -> m Exports
+ Language.PureScript.Sugar.Names.Env: exportType :: MonadError MultipleErrors m => SourceSpan -> ExportMode -> Exports -> ProperName 'TypeName -> [ProperName 'ConstructorName] -> ModuleName -> m Exports
- Language.PureScript.Sugar.Names.Env: exportTypeClass :: MonadError MultipleErrors m => ExportMode -> Exports -> ProperName ClassName -> ModuleName -> m Exports
+ Language.PureScript.Sugar.Names.Env: exportTypeClass :: MonadError MultipleErrors m => SourceSpan -> ExportMode -> Exports -> ProperName 'ClassName -> ModuleName -> m Exports
- Language.PureScript.Sugar.Names.Env: exportTypeOp :: MonadError MultipleErrors m => Exports -> OpName TypeOpName -> ModuleName -> m Exports
+ Language.PureScript.Sugar.Names.Env: exportTypeOp :: MonadError MultipleErrors m => SourceSpan -> Exports -> OpName 'TypeOpName -> ModuleName -> m Exports
- Language.PureScript.Sugar.Names.Env: exportValue :: MonadError MultipleErrors m => Exports -> Ident -> ModuleName -> m Exports
+ Language.PureScript.Sugar.Names.Env: exportValue :: MonadError MultipleErrors m => SourceSpan -> Exports -> Ident -> ModuleName -> m Exports
- Language.PureScript.Sugar.Names.Env: exportValueOp :: MonadError MultipleErrors m => Exports -> OpName ValueOpName -> ModuleName -> m Exports
+ Language.PureScript.Sugar.Names.Env: exportValueOp :: MonadError MultipleErrors m => SourceSpan -> Exports -> OpName 'ValueOpName -> ModuleName -> m Exports
- Language.PureScript.Sugar.Operators.Binders: matchBinderOperators :: [[(Qualified (OpName ValueOpName), Associativity)]] -> Binder -> Binder
+ Language.PureScript.Sugar.Operators.Binders: matchBinderOperators :: MonadError MultipleErrors m => [[(Qualified (OpName 'ValueOpName), Associativity)]] -> Binder -> m Binder
- Language.PureScript.Sugar.Operators.Common: matchOp :: (a -> Maybe (Qualified (OpName nameType))) -> Qualified (OpName nameType) -> Parsec (Chain a) () ()
+ Language.PureScript.Sugar.Operators.Common: matchOp :: FromOp nameType a -> Qualified (OpName nameType) -> Parsec (Chain a) () SourceSpan
- Language.PureScript.Sugar.Operators.Common: matchOperators :: forall a nameType. Show a => (a -> Bool) -> (a -> Maybe (a, a, a)) -> (a -> Maybe (Qualified (OpName nameType))) -> (Qualified (OpName nameType) -> a -> a -> a) -> ([[Operator (Chain a) () Identity a]] -> OperatorTable (Chain a) () Identity a) -> [[(Qualified (OpName nameType), Associativity)]] -> a -> a
+ Language.PureScript.Sugar.Operators.Common: matchOperators :: forall m a nameType. Show a => MonadError MultipleErrors m => (a -> Bool) -> (a -> Maybe (a, a, a)) -> FromOp nameType a -> Reapply nameType a -> ([[Operator (Chain a) () Identity a]] -> OperatorTable (Chain a) () Identity a) -> [[(Qualified (OpName nameType), Associativity)]] -> a -> m a
- Language.PureScript.Sugar.Operators.Common: opTable :: [[(Qualified (OpName nameType), Associativity)]] -> (a -> Maybe (Qualified (OpName nameType))) -> (Qualified (OpName nameType) -> a -> a -> a) -> [[Operator (Chain a) () Identity a]]
+ Language.PureScript.Sugar.Operators.Common: opTable :: [[(Qualified (OpName nameType), Associativity)]] -> FromOp nameType a -> Reapply nameType a -> [[Operator (Chain a) () Identity a]]
- Language.PureScript.Sugar.Operators.Common: parseOp :: (a -> Maybe (Qualified (OpName nameType))) -> Parsec (Chain a) () (Qualified (OpName nameType))
+ Language.PureScript.Sugar.Operators.Common: parseOp :: FromOp nameType a -> Parsec (Chain a) () (SourceSpan, Qualified (OpName nameType))
- Language.PureScript.Sugar.Operators.Expr: matchExprOperators :: [[(Qualified (OpName ValueOpName), Associativity)]] -> Expr -> Expr
+ Language.PureScript.Sugar.Operators.Expr: matchExprOperators :: MonadError MultipleErrors m => [[(Qualified (OpName 'ValueOpName), Associativity)]] -> Expr -> m Expr
- Language.PureScript.Sugar.Operators.Types: matchTypeOperators :: [[(Qualified (OpName TypeOpName), Associativity)]] -> Type -> Type
+ Language.PureScript.Sugar.Operators.Types: matchTypeOperators :: MonadError MultipleErrors m => SourceSpan -> [[(Qualified (OpName 'TypeOpName), Associativity)]] -> Type -> m Type
- Language.PureScript.TypeChecker: checkNewtype :: forall m. MonadError MultipleErrors m => ProperName TypeName -> [(ProperName ConstructorName, [Type])] -> m ()
+ Language.PureScript.TypeChecker: checkNewtype :: forall m. MonadError MultipleErrors m => ProperName 'TypeName -> [(ProperName 'ConstructorName, [Type])] -> m ()
- Language.PureScript.TypeChecker.Entailment: newDictionaries :: MonadState CheckState m => [(Qualified (ProperName ClassName), Integer)] -> Qualified Ident -> Constraint -> m [NamedDict]
+ Language.PureScript.TypeChecker.Entailment: newDictionaries :: MonadState CheckState m => [(Qualified (ProperName 'ClassName), Integer)] -> Qualified Ident -> Constraint -> m [NamedDict]
- Language.PureScript.TypeChecker.Entailment: type InstanceContext = Map (Maybe ModuleName) (Map (Qualified (ProperName ClassName)) (Map (Qualified Ident) NamedDict))
+ Language.PureScript.TypeChecker.Entailment: type InstanceContext = Map (Maybe ModuleName) (Map (Qualified (ProperName 'ClassName)) (Map (Qualified Ident) NamedDict))
- Language.PureScript.TypeChecker.Kinds: kindsOf :: (MonadError MultipleErrors m, MonadState CheckState m) => Bool -> ModuleName -> ProperName TypeName -> [(Text, Maybe Kind)] -> [Type] -> m Kind
+ Language.PureScript.TypeChecker.Kinds: kindsOf :: (MonadError MultipleErrors m, MonadState CheckState m) => Bool -> ModuleName -> ProperName 'TypeName -> [(Text, Maybe Kind)] -> [Type] -> m Kind
- Language.PureScript.TypeChecker.Kinds: kindsOfAll :: (MonadError MultipleErrors m, MonadState CheckState m) => ModuleName -> [(ProperName TypeName, [(Text, Maybe Kind)], Type)] -> [(ProperName TypeName, [(Text, Maybe Kind)], [Type])] -> m ([Kind], [Kind])
+ Language.PureScript.TypeChecker.Kinds: kindsOfAll :: (MonadError MultipleErrors m, MonadState CheckState m) => ModuleName -> [(ProperName 'TypeName, [(Text, Maybe Kind)], Type)] -> [(ProperName 'TypeName, [(Text, Maybe Kind)], [Type])] -> m ([Kind], [Kind])
- Language.PureScript.TypeChecker.Monad: bindLocalTypeVariables :: (MonadState CheckState m) => ModuleName -> [(ProperName TypeName, Kind)] -> m a -> m a
+ Language.PureScript.TypeChecker.Monad: bindLocalTypeVariables :: (MonadState CheckState m) => ModuleName -> [(ProperName 'TypeName, Kind)] -> m a -> m a
- Language.PureScript.TypeChecker.Monad: bindTypes :: MonadState CheckState m => Map (Qualified (ProperName TypeName)) (Kind, TypeKind) -> m a -> m a
+ Language.PureScript.TypeChecker.Monad: bindTypes :: MonadState CheckState m => Map (Qualified (ProperName 'TypeName)) (Kind, TypeKind) -> m a -> m a
- Language.PureScript.TypeChecker.Monad: getTypeClassDictionaries :: (MonadState CheckState m) => m (Map (Maybe ModuleName) (Map (Qualified (ProperName ClassName)) (Map (Qualified Ident) NamedDict)))
+ Language.PureScript.TypeChecker.Monad: getTypeClassDictionaries :: (MonadState CheckState m) => m (Map (Maybe ModuleName) (Map (Qualified (ProperName 'ClassName)) (Map (Qualified Ident) NamedDict)))
- Language.PureScript.TypeChecker.Monad: lookupTypeClassDictionaries :: (MonadState CheckState m) => Maybe ModuleName -> m (Map (Qualified (ProperName ClassName)) (Map (Qualified Ident) NamedDict))
+ Language.PureScript.TypeChecker.Monad: lookupTypeClassDictionaries :: (MonadState CheckState m) => Maybe ModuleName -> m (Map (Qualified (ProperName 'ClassName)) (Map (Qualified Ident) NamedDict))
- Language.PureScript.TypeChecker.Monad: lookupTypeVariable :: (e ~ MultipleErrors, MonadState CheckState m, MonadError e m) => ModuleName -> Qualified (ProperName TypeName) -> m Kind
+ Language.PureScript.TypeChecker.Monad: lookupTypeVariable :: (e ~ MultipleErrors, MonadState CheckState m, MonadError e m) => ModuleName -> Qualified (ProperName 'TypeName) -> m Kind
- Language.PureScript.TypeChecker.Synonyms: type SynonymMap = Map (Qualified (ProperName TypeName)) ([(Text, Maybe Kind)], Type)
+ Language.PureScript.TypeChecker.Synonyms: type SynonymMap = Map (Qualified (ProperName 'TypeName)) ([(Text, Maybe Kind)], Type)
- Language.PureScript.TypeClassDictionaries: TypeClassDictionaryInScope :: v -> [(Qualified (ProperName ClassName), Integer)] -> Qualified (ProperName ClassName) -> [Type] -> Maybe [Constraint] -> TypeClassDictionaryInScope v
+ Language.PureScript.TypeClassDictionaries: TypeClassDictionaryInScope :: [Qualified Ident] -> Integer -> v -> [(Qualified (ProperName 'ClassName), Integer)] -> Qualified (ProperName 'ClassName) -> [Type] -> Maybe [Constraint] -> TypeClassDictionaryInScope v
- Language.PureScript.TypeClassDictionaries: [tcdClassName] :: TypeClassDictionaryInScope v -> Qualified (ProperName ClassName)
+ Language.PureScript.TypeClassDictionaries: [tcdClassName] :: TypeClassDictionaryInScope v -> Qualified (ProperName 'ClassName)
- Language.PureScript.TypeClassDictionaries: [tcdPath] :: TypeClassDictionaryInScope v -> [(Qualified (ProperName ClassName), Integer)]
+ Language.PureScript.TypeClassDictionaries: [tcdPath] :: TypeClassDictionaryInScope v -> [(Qualified (ProperName 'ClassName), Integer)]
- Language.PureScript.TypeClassDictionaries: superclassName :: Qualified (ProperName ClassName) -> Integer -> Text
+ Language.PureScript.TypeClassDictionaries: superclassName :: Qualified (ProperName 'ClassName) -> Integer -> Text
- Language.PureScript.Types: Constraint :: Qualified (ProperName ClassName) -> [Type] -> Maybe ConstraintData -> Constraint
+ Language.PureScript.Types: Constraint :: Qualified (ProperName 'ClassName) -> [Type] -> Maybe ConstraintData -> Constraint
- Language.PureScript.Types: TypeConstructor :: (Qualified (ProperName TypeName)) -> Type
+ Language.PureScript.Types: TypeConstructor :: (Qualified (ProperName 'TypeName)) -> Type
- Language.PureScript.Types: TypeOp :: (Qualified (OpName TypeOpName)) -> Type
+ Language.PureScript.Types: TypeOp :: (Qualified (OpName 'TypeOpName)) -> Type
- Language.PureScript.Types: [constraintClass] :: Constraint -> Qualified (ProperName ClassName)
+ Language.PureScript.Types: [constraintClass] :: Constraint -> Qualified (ProperName 'ClassName)

This diff is very large; some files are shown as “too large to diff”. Download the raw patch for the complete diff.

Files

CONTRIBUTING.md view
@@ -8,7 +8,7 @@  Please follow the following guidelines: -- Add at least a test to `examples/passing/` and possibly to `examples/failing/`.+- Add at least a test to `tests/purs/passing/` and possibly to `tests/purs/failing/`. - Build the binaries and libs with `stack build` - Make sure that all test suites are passing. Run the test suites with `stack test`. - Build the core libraries by running the script in `core-tests`.@@ -17,15 +17,15 @@  Run all test suites with `stack test`. You will need `npm`, `bower` and `node` on your PATH to run the tests. -To build and run a specific test in `examples/passing/` or `examples/failing/`, execute the following commands.+You can run individual test suites using `stack test --test-arguments="-p+PATTERN"` where `PATTERN` is one of `compiler`, `repl`, `ide`, `docs`, `corefn`,+or `hierarchy`. -``` bash-# Build-stack exec purs -- compile 'tests/support/bower_components/purescript-*/src/**/*.purs' examples/blah/Blah.purs+To build and run a specific test in `tests/purs/passing/` or `tests/purs/failing/`, add test arguments like so: -# Run-node -e "require('./output/Main/').main()"-```+`stack test --fast --test-arguments="-p compiler/**1110.purs*"`++This will run whatever test uses the example file `1110.purs`.  ## Code Review
CONTRIBUTORS.md view
@@ -26,11 +26,13 @@ | [@balajirrao](https://github.com/balajirrao) | Balaji Rao | MIT license | | [@bbqbaron](https://github.com/bbqbaron) | Eric Loren | [MIT license](http://opensource.org/licenses/MIT) | | [@bergmark](https://github.com/bergmark) | Adam Bergmark | MIT license |+| [@bitemyapp](https://github.com/bitemyapp) | Chris Allen | [MIT license](http://opensource.org/licenses/MIT) | | [@bmjames](https://github.com/bmjames) | Ben James | [MIT license](http://opensource.org/licenses/MIT) | | [@Bogdanp](https://github.com/Bogdanp) | Bogdan Paul Popa | [MIT license](http://opensource.org/licenses/MIT) | | [@brandonhamilton](https://github.com/brandonhamilton) | Brandon Hamilton | [MIT license](http://opensource.org/licenses/MIT) | | [@bsermons](https://github.com/bsermons) | Brian Sermons | [MIT license](http://opensource.org/licenses/MIT) | | [@cdepillabout](https://github.com/cdepillabout) | Dennis Gosnell | [MIT license](http://opensource.org/licenses/MIT) |+| [@chexxor](https://github.com/chexxor) | Alex Berg | [MIT license](http://opensource.org/licenses/MIT) | | [@chrisdone](https://github.com/chrisdone) | Chris Done | MIT license | | [@cmdv](https://github.com/cmdv) | Vincent Orr | MIT license | | [@codedmart](https://github.com/codedmart) | Brandon Martin | [MIT license](http://opensource.org/licenses/MIT) |@@ -44,6 +46,7 @@ | [@erdeszt](https://github.com/erdeszt) | Tibor Erdesz | [MIT license](http://opensource.org/licenses/MIT) | | [@etrepum](https://github.com/etrepum) | Bob Ippolito | [MIT license](http://opensource.org/licenses/MIT) | | [@faineance](https://github.com/faineance) | faineance | [MIT license](http://opensource.org/licenses/MIT) |+| [@fehrenbach](https://github.com/fehrenbach) | Stefan Fehrenbach | [MIT license](http://opensource.org/licenses/MIT) | | [@felixSchl](https://github.com/felixSchl) | Felix Schlitter | [MIT license](http://opensource.org/licenses/MIT) | | [@FrigoEU](https://github.com/FrigoEU) | Simon Van Casteren | [MIT license](http://opensource.org/licenses/MIT) | | [@garyb](https://github.com/garyb) | Gary Burgess | [MIT license](http://opensource.org/licenses/MIT) |@@ -65,6 +68,7 @@ | [@lukerandall](https://github.com/lukerandall) | Luke Randall | [MIT license](http://opensource.org/licenses/MIT) | | [@matthewleon](https://github.com/matthewleon) | Matthew Leon | [MIT license](http://opensource.org/licenses/MIT) | | [@mcoffin](https://github.com/mcoffin) | Matt Coffin | [MIT license](http://opensource.org/licenses/MIT) |+| [@MiracleBlue](https://github.com/MiracleBlue) | Nicholas Kircher | [MIT license](http://opensource.org/licenses/MIT) | | [@mrkgnao](https://github.com/mrkgnao) | Soham Chowdhury | [MIT license](http://opensource.org/licenses/MIT) | | [@mgmeier](https://github.com/mgmeier) | Michael Gilliland | [MIT license](http://opensource.org/licenses/MIT) | | [@michaelficarra](https://github.com/michaelficarra) | Michael Ficarra | [MIT license](http://opensource.org/licenses/MIT) |@@ -79,6 +83,7 @@ | [@nwolverson](https://github.com/nwolverson) | Nicholas Wolverson | [MIT license](http://opensource.org/licenses/MIT) | | [@osa1](https://github.com/osa1) | Ömer Sinan Ağacan | MIT license | | [@paf31](https://github.com/paf31) | Phil Freeman | [MIT license](http://opensource.org/licenses/MIT) |+| [@parsonsmatt](https://github.com/parsonsmatt) | Matt Parsons | [MIT license](http://opensource.org/licenses/MIT) | | [@passy](https://github.com/passy) | Pascal Hartig | [MIT license](http://opensource.org/licenses/MIT) | | [@paulyoung](https://github.com/paulyoung) | Paul Young | [MIT license](http://opensource.org/licenses/MIT) | | [@pelotom](https://github.com/pelotom) | Thomas Crockett | [MIT license](http://opensource.org/licenses/MIT) |@@ -86,7 +91,9 @@ | [@phiggins](https://github.com/phiggins) | Pete Higgins | [MIT license](http://opensource.org/licenses/MIT) | | [@philopon](https://github.com/philopon) | Hirotomo Moriwaki | [MIT license](http://opensource.org/licenses/MIT) | | [@pseudonom](https://github.com/pseudonom) | Eric Easley | [MIT license](http://opensource.org/licenses/MIT) |+| [@quesebifurcan](https://github.com/quesebifurcan) | Fredrik Wallberg | [MIT license](http://opensource.org/licenses/MIT) | | [@rightfold](https://github.com/rightfold) | rightfold | [MIT license](https://opensource.org/licenses/MIT) |+| [@rndnoise](https://github.com/rndnoise) | rndnoise | [MIT license](http://opensource.org/licenses/MIT) | | [@robdaemon](https://github.com/robdaemon) | Robert Roland | [MIT license](http://opensource.org/licenses/MIT) | | [@RossMeikleham](https://github.com/RossMeikleham) | Ross Meikleham | [MIT license](http://opensource.org/licenses/MIT) | | [@Rufflewind](https://github.com/Rufflewind) | Phil Ruffwind | [MIT license](https://opensource.org/licenses/MIT) |@@ -109,11 +116,16 @@ | [@trofi](https://github.com/trofi) | Sergei Trofimovich | [MIT license](http://opensource.org/licenses/MIT) | | [@utkarshkukreti](https://github.com/utkarshkukreti) | Utkarsh Kukreti | [MIT license](http://opensource.org/licenses/MIT) | | [@vkorablin](https://github.com/vkorablin) | Vladimir Korablin | MIT license |+| [@vladciobanu](https://github.com/vladciobanu) | Vladimir Ciobanu | [MIT license](http://opensource.org/licenses/MIT) | | [@zudov](https://github.com/zudov) | Konstantin Zudov | [MIT license](http://opensource.org/licenses/MIT) | | [@b123400](https://github.com/b123400) | b123400 | [MIT license](https://opensource.org/licenses/MIT) |+| [@kcsongor](https://github.com/kcsongor) | Csongor Kiss | [MIT license](http://opensource.org/licenses/MIT) | | [@drets](https://github.com/drets) | Dmytro Rets | [MIT license](http://opensource.org/licenses/MIT) | | [@bjornmelgaaard](https://github.com/BjornMelgaard) | Sergey Homa | [MIT license](http://opensource.org/licenses/MIT) | | [@thimoteus](https://github.com/Thimoteus) | thimoteus | [MIT license](http://opensource.org/licenses/MIT) |+| [@sloosch](https://github.com/sloosch) | Simon Looschen | [MIT license](http://opensource.org/licenses/MIT) |+| [@rgrinberg](https://github.com/rgrinberg) | Rudi Grinberg | [MIT license](http://opensource.org/licenses/MIT) |+| [@gabejohnson](https://github.com/gabejohnson) | Gabe Johnson | [MIT license](http://opensource.org/licenses/MIT) |  ### Contributors using Modified Terms
INSTALL.md view
@@ -1,24 +1,33 @@ # Installation information  If you are having difficulty installing the PureScript compiler, feel free to-ask for help! A good place is the #purescript IRC channel on Freenode, or+ask for help! A good place is the #purescript IRC channel on Freenode, the #purescript channel on [FPChat Slack](https://fpchat-invite.herokuapp.com/), or alternatively Stack Overflow.  ## Using prebuilt binaries -The prebuilt binaries are compiled with GHC 8.0.2 and therefore they should-run on any operating system supported by GHC 8.0.2, such as:+The prebuilt binaries are compiled with GHC 8.2.2 and therefore they should+run on any operating system supported by GHC 8.2.2, such as:  * Windows Vista or later, * OS X 10.7 or later,-* Linux ??? (we're not sure what the minimum version is).+* Linux ??? (we're not sure what the minimum version is) -This list is not exhaustive. If your OS is too old or not listed, or if the-binaries fail to run, you may be able to install the compiler by building it-from source; see below.+This list is not exhaustive. If your OS is too old or not listed, or if the binaries fail to run, you may be able to install the compiler by building it from source; see below. See also <https://www.haskell.org/ghc/download_ghc_8_2_2.html> for more details about the operating systems which GHC 8.2.2 supports.  Other prebuilt distributions (eg, Homebrew, AUR, npm) will probably have the same requirements.++## Installing a pre-built distribution++There are several options available for aquiring a pre-built binary of the PureScript compiler.  This is by no means an exhaustive list, and is presented in no particular order. Each example is expected to install the latest available compiler version at the time of running the command. Many of these are provided and maintained by the community, and may not be immediately up to date.++* NPM: `npm install -g purescript`+* Homebrew (for OS X): `brew install purescript`+* [PSVM](https://github.com/ThomasCrevoisier/psvm-js) (PS Version Manager): +  1) `psvm install-latest` will install the latest version available+  2) `psvm latest` will print the latest version number available+  3) `psvm use <latest version number>` will enable the version we just installed. For example, if the version is `v0.11.7`, you'd run `psvm use v0.11.7`  ## Compiling from source
README.md view
@@ -20,6 +20,7 @@ ## Help!  - [#purescript @ FP Slack](https://functionalprogramming.slack.com/)+- [PureScript Language Forum](https://purescript-users.ml/) - [PureScript on StackOverflow](http://stackoverflow.com/questions/tagged/purescript) - [Google Group](https://groups.google.com/forum/#!forum/purescript) - [Gitter Channel](https://gitter.im/purescript/purescript?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
app/Command/Compile.hs view
@@ -13,8 +13,12 @@ import           Data.Bool (bool) import qualified Data.ByteString.Lazy as B import qualified Data.ByteString.UTF8 as BU8+import           Data.List (intercalate) import qualified Data.Map as M+import qualified Data.Set as S import           Data.Text (Text)+import qualified Data.Text as T+import           Data.Traversable (for) import qualified Language.PureScript as P import           Language.PureScript.Errors.JSON import           Language.PureScript.Make@@ -89,7 +93,7 @@ inputFile :: Opts.Parser FilePath inputFile = Opts.strArgument $      Opts.metavar "FILE"-  <> Opts.help "The input .purs file(s)"+  <> Opts.help "The input .purs file(s)."  outputDirectory :: Opts.Parser FilePath outputDirectory = Opts.strOption $@@ -122,21 +126,46 @@      Opts.long "json-errors"   <> Opts.help "Print errors to stderr as JSON" -sourceMaps :: Opts.Parser Bool-sourceMaps = Opts.switch $-     Opts.long "source-maps"-  <> Opts.help "Generate source maps"+codegenTargets :: Opts.Parser [P.CodegenTarget]+codegenTargets = Opts.option targetParser $+     Opts.short 'g'+  <> Opts.long "codegen"+  <> Opts.value [P.JS]+  <> Opts.help+      ( "Specifies comma-separated codegen targets to include. "+      <> targetsMessage+      <> " The default target is 'js', but if this option is used only the targets specified will be used."+      ) -dumpCoreFn :: Opts.Parser Bool-dumpCoreFn = Opts.switch $-     Opts.long "dump-corefn"-  <> Opts.help "Dump the (functional) core representation of the compiled code at output/*/corefn.json"+targets :: M.Map String P.CodegenTarget+targets = M.fromList+  [ ("js", P.JS)+  , ("sourcemaps", P.JSSourceMap)+  , ("corefn", P.CoreFn)+  ] +targetsMessage :: String+targetsMessage = "Accepted codegen targets are '" <> intercalate "', '" (M.keys targets) <> "'."++targetParser :: Opts.ReadM [P.CodegenTarget]+targetParser =+  Opts.str >>= \s ->+    for (T.split (== ',') s)+      $ maybe (Opts.readerError targetsMessage) pure+      . flip M.lookup targets+      . T.unpack+      . T.strip+ options :: Opts.Parser P.Options-options = P.Options <$> verboseErrors-                    <*> (not <$> comments)-                    <*> sourceMaps-                    <*> dumpCoreFn+options =+  P.Options+    <$> verboseErrors+    <*> (not <$> comments)+    <*> (handleTargets <$> codegenTargets)+  where+    -- Ensure that the JS target is included if sourcemaps are+    handleTargets :: [P.CodegenTarget] -> S.Set P.CodegenTarget+    handleTargets ts = S.fromList (if elem P.JSSourceMap ts then P.JS : ts else ts)  pscMakeOptions :: Opts.Parser PSCMakeOptions pscMakeOptions = PSCMakeOptions <$> many inputFile
app/Command/Docs.hs view
@@ -2,34 +2,29 @@  module Command.Docs (command, infoModList) where -import           Protolude (ordNub)--import           Command.Docs.Etags-import           Command.Docs.Ctags import           Command.Docs.Html import           Control.Applicative import           Control.Arrow (first, second) import           Control.Category ((>>>)) import           Control.Monad.Writer import           Control.Monad.Trans.Except (runExceptT)-import           Data.Text (Text) import qualified Data.Text as T import qualified Data.Text.IO as T import           Data.Function (on) import           Data.List-import           Data.Maybe (fromMaybe) import           Data.Tuple (swap) import qualified Language.PureScript as P import qualified Language.PureScript.Docs as D import qualified Language.PureScript.Docs.AsMarkdown as D+import           Language.PureScript.Docs.Tags (dumpCtags, dumpEtags) import qualified Options.Applicative as Opts import qualified Text.PrettyPrint.ANSI.Leijen as PP import           System.Directory (createDirectoryIfMissing) import           System.Exit (exitFailure) import           System.FilePath (takeDirectory) import           System.FilePath.Glob (glob)-import           System.IO (hPutStrLn, hPrint, stderr)-import           System.IO.UTF8 (readUTF8FileT, writeUTF8FileT)+import           System.IO (hPutStrLn, stderr)+import           System.IO.UTF8 (writeUTF8FileT)  -- | Available output formats data Format@@ -60,19 +55,18 @@     hPutStrLn stderr "purs docs: no input files."     exitFailure +  fileMs <- parseAndConvert input+  let ms = map snd fileMs   case fmt of-    Etags -> dumpTags input dumpEtags-    Ctags -> dumpTags input dumpCtags+    Etags -> mapM_ putStrLn $ dumpEtags fileMs+    Ctags -> mapM_ putStrLn $ dumpCtags fileMs     Html -> do       let outputDir = "./generated-docs" -- TODO: make this configurable-      ms <- parseAndConvert input-      let msHtml = map asHtml (D.primDocsModule : ms)+      let msHtml = map asHtml (D.primModules ++ ms)       createDirectoryIfMissing False outputDir       writeHtmlModules outputDir msHtml -    Markdown -> do-      ms <- parseAndConvert input-+    Markdown ->       case output of         EverythingToStdOut ->           T.putStrLn (D.runDocs (D.modulesAsMarkdown ms))@@ -115,7 +109,7 @@    parseAndConvert input =     runExceptT (D.parseFilesInPackages input []-               >>= uncurry D.convertModulesInPackage)+                >>= uncurry D.convertTaggedModulesInPackage)     >>= successOrExit  -- |@@ -138,26 +132,6 @@     case find ((== name) . getModuleName) modules of       Just m  -> ((m, x) : ms, missing)       Nothing -> (ms, name : missing)--dumpTags :: [FilePath] -> ([(String, P.Module)] -> [String]) -> IO ()-dumpTags input renderTags = do-  e <- P.parseModulesFromFiles (fromMaybe "") <$> mapM (fmap (first Just) . parseFile) (ordNub input)-  case e of-    Left err -> do-      hPrint stderr err-      exitFailure-    Right ms ->-      ldump (renderTags (pairs ms))--  where-  pairs :: [(Maybe String, m)] -> [(String, m)]-  pairs = map (first (fromMaybe ""))--  ldump :: [String] -> IO ()-  ldump = mapM_ putStrLn--parseFile :: FilePath -> IO (FilePath, Text)-parseFile input = (,) input <$> readUTF8FileT input  inputFile :: Opts.Parser FilePath inputFile = Opts.strArgument $
− app/Command/Docs/Ctags.hs 
@@ -1,13 +0,0 @@-module Command.Docs.Ctags (dumpCtags) where--import           Command.Docs.Tags-import           Data.List (sort)-import qualified Language.PureScript as P--dumpCtags :: [(String, P.Module)] -> [String]-dumpCtags = sort . concatMap renderModCtags--renderModCtags :: (String, P.Module) -> [String]-renderModCtags (path, mdl) = sort tagLines-  where tagLines = map tagLine $ tags mdl-        tagLine (name, line) = name ++ "\t" ++ path ++ "\t" ++ show line
− app/Command/Docs/Etags.hs 
@@ -1,13 +0,0 @@-module Command.Docs.Etags (dumpEtags) where--import           Command.Docs.Tags-import qualified Language.PureScript as P--dumpEtags :: [(String, P.Module)] -> [String]-dumpEtags = concatMap renderModEtags--renderModEtags :: (String, P.Module) -> [String]-renderModEtags (path, mdl) = ["\x0c", path ++ "," ++ show tagsLen] ++ tagLines-  where tagsLen = sum $ map length tagLines-        tagLines = map tagLine $ tags mdl-        tagLine (name, line) = "\x7f" ++ name ++ "\x01" ++ show line ++ ","
− app/Command/Docs/Tags.hs 
@@ -1,21 +0,0 @@-module Command.Docs.Tags where--import           Control.Arrow (first)-import qualified Data.Text as T-import qualified Language.PureScript as P--tags :: P.Module -> [(String, Int)]-tags = map (first T.unpack) . concatMap dtags . P.exportedDeclarations-  where-    dtags :: P.Declaration -> [(P.Text, Int)]-    dtags (P.DataDeclaration (ss, _) _ name _ dcons) = (P.runProperName name, pos ss) : consNames-      where consNames = map (\(cname, _) -> (P.runProperName cname, pos ss)) dcons-    dtags (P.TypeDeclaration (P.TypeDeclarationData (ss, _) ident _)) = [(P.showIdent ident, pos ss)]-    dtags (P.ExternDeclaration (ss, _) ident _) = [(P.showIdent ident, pos ss)]-    dtags (P.TypeSynonymDeclaration (ss, _) name _ _) = [(P.runProperName name, pos ss)]-    dtags (P.TypeClassDeclaration (ss, _) name _ _ _ _) = [(P.runProperName name, pos ss)]-    dtags (P.TypeInstanceDeclaration (ss, _) name _ _ _ _) = [(P.showIdent name, pos ss)]-    dtags (P.ExternKindDeclaration (ss, _) name) = [(P.runProperName name, pos ss)]-    dtags _ = []-    pos :: P.SourceSpan -> Int-    pos = P.sourcePosLine . P.spanStart
app/Command/REPL.hs view
@@ -330,7 +330,7 @@               Right (modules, externs, env) -> do                 historyFilename <- getHistoryFilename                 let settings = defaultSettings { historyFile = Just historyFilename }-                    initialState = PSCiState [] [] (zip (map snd modules) externs)+                    initialState = updateLoadedExterns (const (zip (map snd modules) externs)) initialPSCiState                     config = PSCiConfig psciInputGlob env                     runner = flip runReaderT config                              . flip evalStateT initialState@@ -360,13 +360,10 @@                       configFile <- (</> ".purs-repl") <$> liftIO getCurrentDirectory                       exists <- liftIO $ doesFileExist configFile                       when exists $ do-                        ls <- lines <$> liftIO (readUTF8File configFile)-                        for_ ls $ \l -> do-                          liftIO (putStrLn l)-                          case parseCommand l of-                            Left err -> liftIO (putStrLn err >> exitFailure)-                            Right cmd@Import{} -> handleCommand' state cmd-                            Right _ -> liftIO (putStrLn "The .purs-repl file only supports import declarations")+                        cf <- liftIO (readUTF8File configFile)+                        case parseDotFile configFile cf of+                          Left err -> liftIO (putStrLn err >> exitFailure)+                          Right cmds -> liftIO (putStrLn cf) >> for_ cmds (handleCommand' state)                      handleCommandWithInterrupts                       :: state
app/Main.hs view
@@ -19,6 +19,7 @@ import qualified Options.Applicative as Opts import           System.Environment (getArgs) import qualified System.IO as IO+import qualified Text.PrettyPrint.ANSI.Leijen as Doc import           Version (versionString)  @@ -32,8 +33,21 @@     opts        = Opts.info (versionInfo <*> Opts.helper <*> commands) infoModList     infoModList = Opts.fullDesc <> headerInfo <> footerInfo     headerInfo  = Opts.progDesc "The PureScript compiler and tools"-    footerInfo  = Opts.footer $ "purs " ++ versionString+    footerInfo  = Opts.footerDoc (Just footer) +    footer =+      mconcat+        [ para $+            "For help using each individual command, run `purs COMMAND --help`. " +++            "For example, `purs compile --help` displays options specific to the `compile` command."+        , Doc.hardline+        , Doc.hardline+        , Doc.text $ "purs " ++ versionString+        ]++    para :: String -> Doc.Doc+    para = foldr (Doc.</>) Doc.empty . map Doc.text . words+     -- | Displays full command help when invoked with no arguments.     execParserPure :: Opts.ParserInfo a -> [String] -> Opts.ParserResult a     execParserPure pinfo [] = Opts.Failure $@@ -55,7 +69,7 @@               (Opts.progDesc "Compile PureScript source files"))         , Opts.command "docs"             (Opts.info Docs.command-              (Opts.progDesc "Generate Markdown documentation from PureScript source files" <> Docs.infoModList))+              (Opts.progDesc "Generate documentation from PureScript source files in a variety of formats, including Markdown and HTML" <> Docs.infoModList))         , Opts.command "hierarchy"             (Opts.info Hierarchy.command               (Opts.progDesc "Generate a GraphViz directed graph of PureScript type classes"))
− examples/docs/bower.json 
@@ -1,21 +0,0 @@-{-  "name": "docs-test-package",-  "version": "1.0.0",-  "moduleType": [-    "node"-  ],-  "repository": {-    "type": "git",-    "url": "git://github.com/not-real/not-a-real-repo.git"-  },-  "ignore": [-    "**/.*",-    "node_modules",-    "bower_components",-    "output"-  ],-  "dependencies": {-    "purescript-prelude": "./bower_components/purescript-prelude"-  },-  "license": "MIT"-}
− examples/docs/bower_components/purescript-prelude/src/Prelude.purs 
@@ -1,8 +0,0 @@-module Prelude where--newtype Unit = Unit {}--unit :: Unit-unit = Unit {}--data Boolean2 = True | False
− examples/docs/resolutions.json 
@@ -1,21 +0,0 @@-{-  "canonicalDir": ".",-  "pkgMeta": {-    "dependencies": {-      "purescript-prelude": "./bower_components/purescript-prelude"-    }-  },-  "dependencies": {-    "purescript-prelude": {-      "canonicalDir": "bower_components/purescript-prelude",-      "pkgMeta": {-        "_resolution": {-          "type": "version",-          "tag": "v2.4.0",-          "commit": "21067a4c782f42d08bc877214f85b92ce6769b21"-        }-      },-      "dependencies": {}-    }-  }-}
− examples/docs/src/ChildDeclOrder.purs 
@@ -1,27 +0,0 @@--- Tests should ensure that, in the docs:---  - First should come before Second---  - foo1 should be listed before foo2---  - the instances should be listed in the same order as this source file-module ChildDeclOrder where--data Two-  = First-  | Second--class Show a where-  show :: a -> String--class Foo a where-  foo1 :: a-  foo2 :: a--instance showTwo :: Show Two where-  show _  = ""--instance fooTwo :: Foo Two where-  foo1 = First-  foo2 = Second--instance fooInt :: Foo Int where-  foo1 = 1-  foo2 = 2
− examples/docs/src/Clash.purs 
@@ -1,4 +0,0 @@-module Clash (module Clash1) where--import Clash1 as Clash1-import Clash2 as Clash2
− examples/docs/src/Clash1.purs 
@@ -1,3 +0,0 @@-module Clash1 (module Clash1a) where--import Clash1a
− examples/docs/src/Clash1a.purs 
@@ -1,9 +0,0 @@-module Clash1a where--value :: Int-value = 0--type Type = Int--class TypeClass a where-  typeClassMember :: a
− examples/docs/src/Clash2.purs 
@@ -1,3 +0,0 @@-module Clash2 (module Clash2a) where--import Clash2a
− examples/docs/src/Clash2a.purs 
@@ -1,9 +0,0 @@-module Clash2a where--value :: String-value = "hello"--type Type = String--class TypeClass a b where-  typeClassMember :: a -> b
− examples/docs/src/ConstrainedArgument.purs 
@@ -1,8 +0,0 @@-module ConstrainedArgument where--class Foo t--type WithoutArgs      = forall a. (Partial => a) -> a-type WithArgs         = forall a. (Foo a => a) -> a-type MultiWithoutArgs = forall a. (Partial => Partial => a) -> a-type MultiWithArgs    = forall a b. (Foo a => Foo b => a) -> a
− examples/docs/src/DeclOrder.purs 
@@ -1,17 +0,0 @@-module DeclOrder-  ( class A-  , x1-  , X2-  , x3-  , X4-  , class B-  ) where--x1 = 0-x3 = 0--data X2-data X4--class A-class B
− examples/docs/src/DeclOrderNoExportList.purs 
@@ -1,10 +0,0 @@-module DeclOrderNoExportList where--x1 = 0-x3 = 0--data X2-data X4--class A-class B
− examples/docs/src/Desugar.purs 
@@ -1,8 +0,0 @@-module Desugar where--data X a b = X a b--test :: forall a b. X (a -> b) a -> b-test x =-  let X a b = x-  in a b
− examples/docs/src/DocComments.purs 
@@ -1,11 +0,0 @@-module DocComments where---- | This declaration has a code block:--- |--- |     example == 0--- |--- | Here we are really testing that the leading whitespace is not stripped, as--- | this ensures that we don't accidentally change code blocks into normal--- | paragraphs.-example :: Int-example = 0
− examples/docs/src/DuplicateNames.purs 
@@ -1,9 +0,0 @@-module DuplicateNames-  ( module DuplicateNames-  , module Prelude-  ) where--import Prelude (Unit)--unit :: Int-unit = 0
− examples/docs/src/Example.purs 
@@ -1,7 +0,0 @@-module Example-  ( module Prelude-  , module Example2-  ) where--import Prelude (Unit())-import Example2 (one)
− examples/docs/src/Example2.purs 
@@ -1,7 +0,0 @@-module Example2 where--one :: Int-one = 1--two :: Int-two = 2
− examples/docs/src/ExplicitTypeSignatures.purs 
@@ -1,16 +0,0 @@--module ExplicitTypeSignatures where---- This should use the explicit type signature so that the type variable name--- is preserved.-explicit :: forall something. something -> something-explicit x-  | true = x-  | false = x---- This should use the inferred type.-anInt :: _-anInt = 0---- This should infer a type.-aNumber = 1.0
− examples/docs/src/ImportedTwice.purs 
@@ -1,13 +0,0 @@--- See also an example in the wild: purescript-transformers v0.8.4.--- Control.Monad.RWS.Trans re-exports `lift` from both Control.Monad.Trans--- (where it is originally defined) and Control.Monad.RWS.Class (which--- re-exports it from Control.Monad.Trans).--module ImportedTwice-  ( module ImportedTwiceA-  , module ImportedTwiceB-  )-  where--import ImportedTwiceA-import ImportedTwiceB
− examples/docs/src/ImportedTwiceA.purs 
@@ -1,8 +0,0 @@-module ImportedTwiceA-  ( module ImportedTwiceB )-  where--import ImportedTwiceB--bar :: Int-bar = 1
− examples/docs/src/ImportedTwiceB.purs 
@@ -1,4 +0,0 @@-module ImportedTwiceB where--foo :: Int-foo = 0
− examples/docs/src/MultiVirtual.purs 
@@ -1,6 +0,0 @@-module MultiVirtual-  ( module X )-  where--import MultiVirtual1 as X-import MultiVirtual2 as X
− examples/docs/src/MultiVirtual1.purs 
@@ -1,4 +0,0 @@-module MultiVirtual1 where--foo :: Int-foo = 1
− examples/docs/src/MultiVirtual2.purs 
@@ -1,9 +0,0 @@-module MultiVirtual2-  ( module MultiVirtual2-  , module MultiVirtual3-  ) where--import MultiVirtual3--bar :: Int-bar = 2
− examples/docs/src/MultiVirtual3.purs 
@@ -1,4 +0,0 @@-module MultiVirtual3 where--baz :: Int-baz = 3
− examples/docs/src/NewOperators.purs 
@@ -1,5 +0,0 @@-module NewOperators-  ( module NewOperators2 )-  where--import NewOperators2
− examples/docs/src/NewOperators2.purs 
@@ -1,6 +0,0 @@-module NewOperators2 where--infixl 8 _compose as >>>--_compose :: forall a b c. (b -> c) -> (a -> b) -> (a -> c)-_compose f g x = f (g x)
− examples/docs/src/NotAllCtors.purs 
@@ -1,5 +0,0 @@-module NotAllCtors-  ( module Prelude )-  where--import Prelude (Boolean2(True))
− examples/docs/src/ReExportedTypeClass.purs 
@@ -1,5 +0,0 @@-module ReExportedTypeClass-  ( module SomeTypeClass )-  where--import SomeTypeClass
− examples/docs/src/SolitaryTypeClassMember.purs 
@@ -1,6 +0,0 @@-module SolitaryTypeClassMember-  ( module SomeTypeClass )-  where--import SomeTypeClass (member)-
− examples/docs/src/SomeTypeClass.purs 
@@ -1,5 +0,0 @@--module SomeTypeClass where--class SomeClass a where-  member :: a
− examples/docs/src/Transitive1.purs 
@@ -1,5 +0,0 @@-module Transitive1-  ( module Transitive2 )-  where--import Transitive2
− examples/docs/src/Transitive2.purs 
@@ -1,5 +0,0 @@-module Transitive2-  ( module Transitive3 )-  where--import Transitive3
− examples/docs/src/Transitive3.purs 
@@ -1,4 +0,0 @@-module Transitive3 where--transitive3 :: Int-transitive3 = 0
− examples/docs/src/TypeClassWithFunDeps.purs 
@@ -1,5 +0,0 @@--module TypeClassWithFunDeps where--class TypeClassWithFunDeps a b c d e | a b -> c, c -> d e where-  aMember :: a -> b
− examples/docs/src/TypeClassWithoutMembers.purs 
@@ -1,5 +0,0 @@-module TypeClassWithoutMembers-  ( module TypeClassWithoutMembersIntermediate )-  where--import TypeClassWithoutMembersIntermediate
− examples/docs/src/TypeClassWithoutMembersIntermediate.purs 
@@ -1,5 +0,0 @@-module TypeClassWithoutMembersIntermediate-  ( module SomeTypeClass )-  where--import SomeTypeClass (class SomeClass)
− examples/docs/src/TypeLevelString.purs 
@@ -1,7 +0,0 @@-module TypeLevelString where--data Foo--class Bar a--instance fooBar :: Fail "oops" => Bar Foo
− examples/docs/src/TypeOpAliases.purs 
@@ -1,44 +0,0 @@-module TypeOpAliases where--type AltFn a b = a -> b--infixr 6 type AltFn as ~>--foreign import test1 :: forall a b. a ~> b-foreign import test2 :: forall a b c. a ~> b ~> c-foreign import test3 :: forall a b c d. a ~> (b ~> c) ~> d-foreign import test4 :: forall a b c d. ((a ~> b) ~> c) ~> d--data Tuple a b = Tuple a b--infixl 6 Tuple as ×-infixl 6 type Tuple as ×--data Either a b = Left a | Right b--infixl 5 type Either as ⊕--third ∷ ∀ a b c. a × b × c → c-third (a × b × c) = c--class Show a where-  show :: a -> String--instance showTuple :: Show a => Show (a × b) where-  show (a × _) = show a---- Test that precedence is taken into account while desugaring type operators--class TestL a where-  testL :: a--class TestR a where-  testR :: a---- Note: this type is Either Int (Tuple Int String)-instance testLEither :: TestL (Int ⊕ Int × String) where-  testL = Right (0 × "hi")---- Note: this type is Either (Tuple Int Int) String-instance testREither :: TestR (Int × Int ⊕ String) where-  testR = Left (0 × 1)
− examples/docs/src/UTF8.purs 
@@ -1,7 +0,0 @@-module UTF8 where--import Prelude (Unit, unit)---- | üÜäÄ 😰-thing :: Unit-thing = unit
− examples/docs/src/Virtual.purs 
@@ -1,5 +0,0 @@-module Virtual-  ( module VirtualPrelude )-  where--import Prelude as VirtualPrelude
− examples/failing/1071.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith KindsDoNotUnify-module Main where--class Foo a b where-  foo :: a -> b--bar :: forall a. Foo a => a -> a-bar a = a
− examples/failing/1169.purs 
@@ -1,12 +0,0 @@--- @shouldFailWith IncorrectConstructorArity -module Test where--data Outer a = Outer a-            -data Inner a b = Inner a b--test1 :: forall a b. Outer (Inner a b) -> Boolean-test1 (Outer (Inner _)) = true--test2 :: forall a b. Inner a b -> Boolean-test2 (Inner _) = true
− examples/failing/1175.purs 
@@ -1,11 +0,0 @@--- @shouldFailWith TypesDoNotUnify-module X where--class Foo where-  foo :: String--instance f :: Foo where-  foo = "a"-    where-    bar :: String-    bar = 1
− examples/failing/1310.purs 
@@ -1,18 +0,0 @@--- @shouldFailWith NoInstanceFound--module Issue1310 where--import Prelude-import Control.Monad.Eff-import Control.Monad.Eff.Console--class Inject f g where-  inj :: forall a. f a -> g a--instance inject :: Inject f f where-  inj x = x--foreign import data Oops :: Effect--main :: forall eff. Eff (oops :: Oops | eff) Unit-main = inj (log "Oops")
− examples/failing/1570.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith ExpectedType-module M where--data F a = F a--test = \(x :: F) -> x
− examples/failing/1733.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith UnknownName-module Main where--import Thingy as Thing--main = Thing.doesntExist "hi"
− examples/failing/1733/Thingy.purs 
@@ -1,4 +0,0 @@-module Thingy where--foo :: Int-foo = 1
− examples/failing/1825.purs 
@@ -1,9 +0,0 @@--- @shouldFailWith UnknownName--module Main where--data W = X | Y | Z--bad X a = a-bad Y _ = a-bad Z a = a
− examples/failing/1881.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith ErrorParsingModule-module Main where--foo =-bar :: Int-bar = 3
− examples/failing/2128-class.purs 
@@ -1,5 +0,0 @@--- @shouldFailWith ErrorParsingModule-module Main where--class Foo a where-  foo :: a -> !!!
− examples/failing/2128-instance.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith ErrorParsingModule-module Main where--class Foo a where-  foo :: a--instance fooInt :: Foo Int where-  foo = !!!
− examples/failing/2197-shouldFail.purs 
@@ -1,10 +0,0 @@--- @shouldFailWith ScopeConflict-module Main where--import Prim as P-import Prim (Number)--type Number = P.Number--z :: Number-z = 0.0
− examples/failing/2197-shouldFail2.purs 
@@ -1,7 +0,0 @@--- @shouldFailWith UnknownName-module Main where--import Prim (Boolean)--z :: Number-z = 0.0
− examples/failing/2378.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith OrphanInstance-module Main where--import Lib--instance fooX :: Foo "x"
− examples/failing/2378/Lib.purs 
@@ -1,3 +0,0 @@-module Lib (class Foo) where--class Foo (a :: Symbol)
− examples/failing/2379.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith UnknownClass-module Main where--import Lib--test = x [1, 2, 3]
− examples/failing/2379/Lib.purs 
@@ -1,9 +0,0 @@-module Lib (class X, x) where--class X a where-  x :: a -> String--class Y a--instance xArray :: Y a => X (Array a) where-  x _ = "[]"
− examples/failing/2434.purs 
@@ -1,5 +0,0 @@--- @shouldFailWith ErrorParsingModule-module Main where--x :: Char-x = '\x10000'
− examples/failing/2534.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith InfiniteType-module Main where--foo :: Array Int -> Int-foo xs = go xs where-  go :: Array _ -> Int-  go [] = 0-  go xs = go [xs]
− examples/failing/2542.purs 
@@ -1,9 +0,0 @@--- @shouldFailWith UndefinedTypeVariable-module Main where--type T = forall a. Array a--foo :: T-foo = bar where-  bar :: Array a-  bar = []
− examples/failing/2567.purs 
@@ -1,5 +0,0 @@--- @shouldFailWith NoInstanceFound-module Main where--foo :: Int-foo = (0 :: Fail "This constraint should be checked" => Int)
− examples/failing/2601.purs 
@@ -1,7 +0,0 @@--- @shouldFailWith KindsDoNotUnify-module Main where--type Syn (a :: Type -> Type) = String--val :: Syn Int-val = "bad"
− examples/failing/2616.purs 
@@ -1,9 +0,0 @@--- @shouldFailWith NoInstanceFound-module Main where-	-import Prelude--newtype Foo r = Foo { | r }--derive instance eqFoo :: Eq (Foo r)-derive instance ordFoo :: Ord (Foo r)
− examples/failing/2806.purs 
@@ -1,7 +0,0 @@--- @shouldFailWith NoInstanceFound-module X where--data E a b = L a | R b--g :: forall a b . E a b -> a-g e | L x <- e = x
− examples/failing/2874-forall.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith ErrorParsingModule-module Main where--class T a b | a -> b-instance tT :: (T Int (forall a. a)) => T Int String--ddd :: Int-ddd = 0 :: forall t. T Int t => Int
− examples/failing/2874-forall2.purs 
@@ -1,10 +0,0 @@--- @shouldFailWith ErrorParsingModule-module Main where--class X a b | a -> b-class X a (forall t. t) <= Y a b | a -> b-instance tX :: X Int String-instance tY :: Y Int Boolean--ggg :: Int-ggg = 0 :: forall t. Y Int t => Int
− examples/failing/2874-wildcard.purs 
@@ -1,11 +0,0 @@--- @shouldFailWith ErrorParsingModule-module Main where--class Foo a where-  foo :: a--class Baz b where-  baz :: b--instance bazFoo :: (Baz _) => Foo b where-  foo = baz
− examples/failing/365.purs 
@@ -1,14 +0,0 @@--- @shouldFailWith CycleInDeclaration-module Main where--import Prelude--class C a where-  f :: a -> a-  g :: a -> a--instance cS :: C String where-  f s = s-  g = f--main = g "Done"
− examples/failing/438.purs 
@@ -1,15 +0,0 @@--- @shouldFailWith PossiblyInfiniteInstance---- See issue 438 for details: this test is mainly here to test that code like--- this doesn't cause the compiler to loop.--module Main where--import Prelude--data Fix f = In (f (Fix f))--instance eqFix :: (Eq (f (Fix f))) => Eq (Fix f) where-  eq (In f) (In g) = f == g--example = In [] == In []
− examples/failing/881.purs 
@@ -1,13 +0,0 @@--- @shouldFailWith DuplicateValueDeclaration-module Main where--data X = X | Y--class Foo a where-  foo :: a -> a-  bar :: a--instance fooX :: Foo X where-  foo X = X-  bar = X-  foo Y = Y
− examples/failing/AnonArgument1.purs 
@@ -1,5 +0,0 @@--- @shouldFailWith IncorrectAnonymousArgument-module Main where--test :: Int -> Int-test = _
− examples/failing/AnonArgument2.purs 
@@ -1,7 +0,0 @@--- @shouldFailWith IncorrectAnonymousArgument-module Main where--import Prelude--test :: Int -> Int-test = 1 + 2 * _
− examples/failing/AnonArgument3.purs 
@@ -1,5 +0,0 @@--- @shouldFailWith IncorrectAnonymousArgument-module Main where--test :: Int -> Int-test = 1 + _
− examples/failing/ArgLengthMismatch.purs 
@@ -1,7 +0,0 @@--- @shouldFailWith ArgListLengthsDiffer
-module ArgLengthMismatch where
-
-import Prelude
-
-f x y = true
-f = false
− examples/failing/ArrayType.purs 
@@ -1,14 +0,0 @@--- @shouldFailWith TypesDoNotUnify--module Main where--import Prelude-import Control.Monad.Eff.Console--bar :: Number -> Number -> Number-bar n m = n + m--foo = x `bar` y-  where-  x = 1-  y = []
− examples/failing/Arrays.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith TypesDoNotUnify-module Main where--foreign import ix :: forall a. Array a -> Int -> a--test = \arr -> arr `ix` (0 `ix` 0)
− examples/failing/BindInDo-2.purs 
@@ -1,9 +0,0 @@--- @shouldFailWith CannotUseBindWithDo-module Main where--import Prelude--foo = do-  let bind = 42-  x <- [4, 5, 6]-  pure x
− examples/failing/BindInDo.purs 
@@ -1,9 +0,0 @@--- @shouldFailWith CannotUseBindWithDo-module Main where--import Prelude--foo = do-  bind <- [1,2,3]-  x <- [4, 5, 6]-  pure x
− examples/failing/CannotDeriveNewtypeForData.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith CannotDeriveNewtypeForData-module CannotDeriveNewtypeForData where--import Data.Newtype--data Test = Test String--derive instance newtypeTest :: Newtype Test _
− examples/failing/CaseBinderLengthsDiffer.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith CaseBinderLengthDiffers-module Main where--test = case 1, 2 of-  1, 2, 3 -> 42-  _, _    -> 43
− examples/failing/CaseDoesNotMatchAllConstructorArgs.purs 
@@ -1,15 +0,0 @@--- @shouldFailWith IncorrectConstructorArity-module Main where--import Prelude--data Person = Person String Int--data TwoPeople = Two Person Person--getName p = case p of-  (Two (Person n) (Person n2 a2)) -> n-  _ -> "Unknown"---name = getName (Two (Person "Jimmy" 20) (Person "" 1))
− examples/failing/ConflictingExports.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith ScopeConflict--- Fails here because re-exporting forces any scope conflicts to be resolved-module Main (module A, module B) where--  import A-  import B
− examples/failing/ConflictingExports/A.purs 
@@ -1,4 +0,0 @@-module A where--thing :: Int-thing = 1
− examples/failing/ConflictingExports/B.purs 
@@ -1,4 +0,0 @@-module B where--thing :: Int-thing = 2
− examples/failing/ConflictingImports.purs 
@@ -1,9 +0,0 @@--- @shouldFailWith ScopeConflict-module Main where--import A-import B---- Error due to referencing `thing` which is in scope as A.thing and B.thing-what :: Int-what = thing
− examples/failing/ConflictingImports/A.purs 
@@ -1,4 +0,0 @@-module A where--thing :: Int-thing = 1
− examples/failing/ConflictingImports/B.purs 
@@ -1,4 +0,0 @@-module B where--thing :: Int-thing = 2
− examples/failing/ConflictingImports2.purs 
@@ -1,10 +0,0 @@--- @shouldFailWith ScopeConflict-module Main where--import A (thing)-import B (thing)---- Error due to referencing `thing` which is explicitly in scope as A.thing--- and B.thing-what :: Int-what = thing
− examples/failing/ConflictingImports2/A.purs 
@@ -1,4 +0,0 @@-module A where--thing :: Int-thing = 1
− examples/failing/ConflictingImports2/B.purs 
@@ -1,4 +0,0 @@-module B where--thing :: Int-thing = 2
− examples/failing/ConflictingQualifiedImports.purs 
@@ -1,7 +0,0 @@--- @shouldFailWith ScopeConflict-module Main where--import A as X-import B as X--foo = X.thing
− examples/failing/ConflictingQualifiedImports/A.purs 
@@ -1,4 +0,0 @@-module A where--thing :: Int-thing = 1
− examples/failing/ConflictingQualifiedImports/B.purs 
@@ -1,4 +0,0 @@-module B where--thing :: Int-thing = 2
− examples/failing/ConflictingQualifiedImports2.purs 
@@ -1,5 +0,0 @@--- @shouldFailWith ScopeConflict-module Main (module X) where--import A as X-import B as X
− examples/failing/ConflictingQualifiedImports2/A.purs 
@@ -1,4 +0,0 @@-module A where--thing :: Int-thing = 1
− examples/failing/ConflictingQualifiedImports2/B.purs 
@@ -1,4 +0,0 @@-module B where--thing :: Int-thing = 2
− examples/failing/ConstraintFailure.purs 
@@ -1,13 +0,0 @@--- @shouldFailWith NoInstanceFound--module Main where--import Prelude--data Foo = Bar-       -spin :: forall a. a -> Foo-spin x = Bar--main = show <<< spin-
− examples/failing/ConstraintInference.purs 
@@ -1,10 +0,0 @@--- @shouldFailWith AmbiguousTypeVariables--module Main where--import Prelude--spin :: forall a b. a -> b-spin x = spin x--test = show <<< spin
− examples/failing/DctorOperatorAliasExport.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith TransitiveDctorExportError-module Data.List (List, (:)) where--  data List a = Cons a (List a) | Nil--  infixr 6 Cons as :
− examples/failing/DeclConflictClassCtor.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith DeclConflict-module Main where--data T = Fail--class Fail
− examples/failing/DeclConflictClassSynonym.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith DeclConflict-module Main where--import Prelude--type Fail = Unit--class Fail
− examples/failing/DeclConflictClassType.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith DeclConflict-module Main where--class Fail--data Fail
− examples/failing/DeclConflictCtorClass.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith DeclConflict-module Main where--class Fail--data T = Fail
− examples/failing/DeclConflictCtorCtor.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith DeclConflict-module Main where--data T1 = Fail--data T2 = Fail
− examples/failing/DeclConflictDuplicateCtor.purs 
@@ -1,5 +0,0 @@--- @shouldFailWith DeclConflict-module Main where--data T = Fail | Fail-
− examples/failing/DeclConflictSynonymClass.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith DeclConflict-module Main where--import Prelude--class Fail--type Fail = Unit
− examples/failing/DeclConflictSynonymType.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith DeclConflict-module Main where--import Prelude--data Fail--type Fail = Unit
− examples/failing/DeclConflictTypeClass.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith DeclConflict-module Main where--class Fail--data Fail
− examples/failing/DeclConflictTypeSynonym.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith DeclConflict-module Main where--import Prelude--type Fail = Unit--data Fail
− examples/failing/DeclConflictTypeType.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith DeclConflict-module Main where--data Fail--data Fail
− examples/failing/DiffKindsSameName.purs 
@@ -1,15 +0,0 @@--- @shouldFailWith KindsDoNotUnify-module DiffKindsSameName where--import DiffKindsSameName.LibA as LibA-import DiffKindsSameName.LibB as LibB---- both `LibA` and `LibB` define a kind locally called `DemoKind`--- `LibB` defines `DemoData :: LibB.DemoKind`--- if we try to use `DemoData` in a place where `LibA.DemoKind` is expected, it should fail with `KindsDoNotUnify`--data AProxy (m :: LibA.DemoKind) = AProxy--bProxy :: AProxy LibB.DemoData-bProxy = AProxy-
− examples/failing/DiffKindsSameName/LibA.purs 
@@ -1,4 +0,0 @@-module DiffKindsSameName.LibA where--foreign import kind DemoKind-
− examples/failing/DiffKindsSameName/LibB.purs 
@@ -1,6 +0,0 @@-module DiffKindsSameName.LibB where--foreign import kind DemoKind--foreign import data DemoData :: DemoKind-
− examples/failing/Do.purs 
@@ -1,12 +0,0 @@--- @shouldFailWith InvalidDoBind--- @shouldFailWith InvalidDoLet-module Main where--import Prelude--test1 = do let x = 1--test2 y = do x <- y--test3 = do pure 1-           pure 2
− examples/failing/DoNotSuggestComposition.purs 
@@ -1,13 +0,0 @@--- @shouldFailWith TypesDoNotUnify--- TODO: Check that this does not produce a "function composition is (<<<)"--- suggestion.-module DoNotSuggestComposition where--import Prelude--x = { y: 3 }--foo :: String -> String-foo y = y--bar = foo x
− examples/failing/DoNotSuggestComposition2.purs 
@@ -1,7 +0,0 @@--- @shouldFailWith TypesDoNotUnify--- TODO: Check that this does not produce a "function composition is (<<<)"--- suggestion.--module DoNotSuggestComposition2 where--foo = let x = { y: 3 } in x 2
− examples/failing/DuplicateDeclarationsInLet.purs 
@@ -1,12 +0,0 @@--- @shouldFailWith OverlappingNamesInLet-module Main where--import Prelude--foo = a-  where-  a :: Number-  a = 1--  a :: Number-  a = 2
− examples/failing/DuplicateInstance.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith DuplicateInstance-module Main where-class X-class Y-instance i :: X-instance i :: Y
− examples/failing/DuplicateModule.purs 
@@ -1,2 +0,0 @@--- @shouldFailWith DuplicateModule-module M1 where
− examples/failing/DuplicateModule/M1.purs 
@@ -1,1 +0,0 @@-module M1 where
− examples/failing/DuplicateProperties.purs 
@@ -1,12 +0,0 @@--- @shouldFailWith TypesDoNotUnify-module DuplicateProperties where--import Prelude--foreign import data Test :: # Type -> Type--foreign import subtractX :: forall r. Test (x :: Unit | r) -> Test r--foreign import hasX :: Test (x :: Unit, y :: Unit)--baz = subtractX (subtractX hasX)
− examples/failing/DuplicateTypeClass.purs 
@@ -1,4 +0,0 @@--- @shouldFailWith DuplicateTypeClass-module Main where-class C-class C
− examples/failing/DuplicateTypeVars.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith DuplicateTypeArgument-module Main where--import Prelude--type Foo a a = a
− examples/failing/Eff.purs 
@@ -1,13 +0,0 @@--- @shouldFailWith TypesDoNotUnify-module Main where--import Prelude-import Control.Monad.Eff-import Control.Monad.ST-import Control.Monad.Eff.Console--test = pureST (do-         ref <- newSTRef 0-         log "ST"-         modifySTRef ref $ \n -> n + 1-         readSTRef ref)
− examples/failing/EmptyCase.purs 
@@ -1,4 +0,0 @@--- @shouldFailWith ErrorParsingModule-module Main where--error err = case err of \_ -> 1
− examples/failing/EmptyClass.purs 
@@ -1,7 +0,0 @@--- @shouldFailWith ErrorParsingModule-module Main where--class Foo x where--bar :: String-bar = "hello"
− examples/failing/EmptyDo.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith ErrorParsingModule--module Main where--main = do-
− examples/failing/ExportConflictClass.purs 
@@ -1,5 +0,0 @@--- @shouldFailWith ExportConflict-module C (module A, module B) where--import A as A-import B as B
− examples/failing/ExportConflictClass/A.purs 
@@ -1,3 +0,0 @@-module A where--class X
− examples/failing/ExportConflictClass/B.purs 
@@ -1,3 +0,0 @@-module B where--class X
− examples/failing/ExportConflictCtor.purs 
@@ -1,5 +0,0 @@--- @shouldFailWith ExportConflict-module C (module A, module B) where--import A as A-import B as B
− examples/failing/ExportConflictCtor/A.purs 
@@ -1,3 +0,0 @@-module A where--data T1 = X
− examples/failing/ExportConflictCtor/B.purs 
@@ -1,3 +0,0 @@-module B where--data T2 = X
− examples/failing/ExportConflictType.purs 
@@ -1,5 +0,0 @@--- @shouldFailWith ExportConflict-module C (module A, module B) where--import A as A-import B as B
− examples/failing/ExportConflictType/A.purs 
@@ -1,3 +0,0 @@-module A where--data T
− examples/failing/ExportConflictType/B.purs 
@@ -1,3 +0,0 @@-module B where--data T
− examples/failing/ExportConflictTypeOp.purs 
@@ -1,5 +0,0 @@--- @shouldFailWith ExportConflict-module C (module A, module B) where--import A as A-import B as B
− examples/failing/ExportConflictTypeOp/A.purs 
@@ -1,5 +0,0 @@-module A where--type T1 a b = a -> b--infixr 4 type T1 as ??
− examples/failing/ExportConflictTypeOp/B.purs 
@@ -1,5 +0,0 @@-module B where--type T2 a b = a -> b--infixr 4 type T2 as ??
− examples/failing/ExportConflictValue.purs 
@@ -1,5 +0,0 @@--- @shouldFailWith ExportConflict-module C (module A, module B) where--import A as A-import B as B
− examples/failing/ExportConflictValue/A.purs 
@@ -1,4 +0,0 @@-module A where--x :: Boolean-x = true
− examples/failing/ExportConflictValue/B.purs 
@@ -1,4 +0,0 @@-module B where--x :: Boolean-x = false
− examples/failing/ExportConflictValueOp.purs 
@@ -1,5 +0,0 @@--- @shouldFailWith ExportConflict-module C (module A, module B) where--import A as A-import B as B
− examples/failing/ExportConflictValueOp/A.purs 
@@ -1,6 +0,0 @@-module A where--f1 :: forall a b. a -> b -> a-f1 x _ = x--infix 0 f1 as !!
− examples/failing/ExportConflictValueOp/B.purs 
@@ -1,6 +0,0 @@-module B where--f2 :: forall a b. a -> b -> a-f2 x _ = x--infix 0 f2 as !!
− examples/failing/ExportExplicit.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith UnknownExport
--- should fail as z does not exist in the module
-module M1 (x, y, z) where
-
-import Prelude
-
-x = 1
-y = 2
− examples/failing/ExportExplicit1.purs 
@@ -1,12 +0,0 @@--- @shouldFailWith UnknownName
-module Main where
-
-import M1
-import Control.Monad.Eff.Console (log)
-
-testX = X
-
--- should fail as Y constructor is not exported from M1
-testY = Y
-
-main = log "Done"
− examples/failing/ExportExplicit1/M1.purs 
@@ -1,3 +0,0 @@-module M1 (X(X)) where
-
-data X = X | Y
− examples/failing/ExportExplicit2.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith UnknownExportDataConstructor
--- should fail as Y is not a data constructor for X
-module M1 (X(Y)) where
-
-import Prelude
-
-data X = X
-data Y = Y
− examples/failing/ExportExplicit3.purs 
@@ -1,10 +0,0 @@--- @shouldFailWith UnknownName
-module Main where
-
-import M1 as M
-import Control.Monad.Eff.Console (log)
-
--- should fail as Z is not exported from M1
-testZ = M.Z
-
-main = log "Done"
− examples/failing/ExportExplicit3/M1.purs 
@@ -1,4 +0,0 @@-module M1 (X(..)) where
-
-data X = X | Y
-data Z = Z
− examples/failing/ExtraRecordField.purs 
@@ -1,9 +0,0 @@--- @shouldFailWith AdditionalProperty-module ExtraRecordField where--import Prelude ((<>))--full :: { first :: String, last :: String } -> String-full p = p.first <> " " <> p.last--oops = full { first: "Jane", last: "Smith", age: 29 }
− examples/failing/Foldable.purs 
@@ -1,17 +0,0 @@--- @shouldFailWith CycleInDeclaration-module Main where--import Prelude--class Foldable f where-  fold :: forall a b. (a -> b -> b) -> b -> f a -> b-  size :: forall a. f a -> Number--data L a = C a (L a) | N--instance foldableL :: Foldable L where-  fold _ z N = z-  fold f z (C x xs) = x `f` (fold f z xs)-  size = fold (const ((+) 1.0)) 0.0--x = size (C 1 (C 2 (C 3 N)))
− examples/failing/Generalization1.purs 
@@ -1,11 +0,0 @@--- @shouldFailWith CannotGeneralizeRecursiveFunction-module Main where--import Prelude--foo 0 x _ = x-foo n x y = x <> bar (n - 1) x y--bar 0 x _ = x-bar n x y = y <> foo (n - 1) x y-
− examples/failing/Generalization2.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith CannotGeneralizeRecursiveFunction-module Main where--import Prelude--test n m | n <= 1 = m-         | otherwise = test (n - 1) (m <> m)-
− examples/failing/ImportExplicit.purs 
@@ -1,4 +0,0 @@--- @shouldFailWith UnknownImport
-module Main where
-
-import M1 (X(..))
− examples/failing/ImportExplicit/M1.purs 
@@ -1,3 +0,0 @@-module M1 where
-
-foo = "foo"
− examples/failing/ImportExplicit2.purs 
@@ -1,4 +0,0 @@--- @shouldFailWith UnknownImportDataConstructor
-module Main where
-
-import M1 (X(Z, Q))
− examples/failing/ImportExplicit2/M1.purs 
@@ -1,3 +0,0 @@-module M1 where
-
-data X = Y
− examples/failing/ImportHidingModule.purs 
@@ -1,4 +0,0 @@--- @shouldFailWith ImportHidingModule
-module Main where
-
-import B hiding (module A)
− examples/failing/ImportHidingModule/A.purs 
@@ -1,2 +0,0 @@-module A where
-x = 1
− examples/failing/ImportHidingModule/B.purs 
@@ -1,3 +0,0 @@-module B (module B, module A) where
-import A
-y = 1
− examples/failing/ImportModule.purs 
@@ -1,4 +0,0 @@--- @shouldFailWith ModuleNotFound
-module Main where
-
-import M1
− examples/failing/ImportModule/M2.purs 
@@ -1,3 +0,0 @@-module M2 where
-
-data X = X
− examples/failing/InfiniteKind.purs 
@@ -1,5 +0,0 @@--- @shouldFailWith InfiniteKind --module Main where--data F a = F (a a)
− examples/failing/InfiniteKind2.purs 
@@ -1,5 +0,0 @@--- @shouldFailWith InfiniteKind--module InfiniteKind2 where--data Tree m a = Tree a (m (Tree a))
− examples/failing/InfiniteType.purs 
@@ -1,5 +0,0 @@--- @shouldFailWith InfiniteType --module Main where--f a = a a
− examples/failing/InstanceExport.purs 
@@ -1,7 +0,0 @@--- @shouldFailWith TransitiveExportError
-module Test where
-
-import InstanceExport
-import Prelude
-
-test = f $ S "Test"
− examples/failing/InstanceExport/InstanceExport.purs 
@@ -1,11 +0,0 @@-module InstanceExport (S(..), f) where
-
-import Prelude
-
-newtype S = S String
-
-class F a where
-  f :: a -> String
-
-instance fs :: F S where
-  f (S s) = s
− examples/failing/InstanceSigsBodyIncorrect.purs 
@@ -1,10 +0,0 @@--- @shouldFailWith TypesDoNotUnify--module Main where--class Foo a where-  foo :: a--instance fooNumber :: Foo Number where-  foo :: Number-  foo = true
− examples/failing/InstanceSigsDifferentTypes.purs 
@@ -1,10 +0,0 @@--- @shouldFailWith TypesDoNotUnify--module Main where--class Foo a where-  foo :: a--instance fooNumber :: Foo Number where-  foo :: Int-  foo = 0.0
− examples/failing/InstanceSigsIncorrectType.purs 
@@ -1,10 +0,0 @@--- @shouldFailWith TypesDoNotUnify--module Main where--class Foo a where-  foo :: a--instance fooNumber :: Foo Number where-  foo :: Boolean-  foo = true
− examples/failing/InstanceSigsOrphanTypeDeclaration.purs 
@@ -1,10 +0,0 @@--- @shouldFailWith OrphanTypeDeclaration--module Main where--class Foo a where-  foo :: a--instance fooNumber :: Foo Number where-  bar :: Int-  foo = 0.0
− examples/failing/IntOutOfRange.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith IntOutOfRange--module Main where--n :: Int-n = 2147483648
− examples/failing/InvalidDerivedInstance.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith InvalidDerivedInstance-module Main where--import Prelude--data X = X--derive instance eqX :: Eq X X
− examples/failing/InvalidDerivedInstance2.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith ExpectedTypeConstructor-module Main where--import Prelude--derive instance eqRecord :: Eq {}
− examples/failing/InvalidOperatorInBinder.purs 
@@ -1,12 +0,0 @@--- @shouldFailWith InvalidOperatorInBinder-module Main where--data List a = Cons a (List a) | Nil--cons ∷ ∀ a. a → List a → List a-cons = Cons--infixl 6 cons as :--get ∷ ∀ a. List a → a-get (_ : x : _) = x
− examples/failing/KindError.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith KindsDoNotUnify-module Main where--import Prelude--data KindError f a = One f | Two (f a)
− examples/failing/KindStar.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith ExpectedType--module X where--data List a = Nil | Cons a (List a)--test :: List-test = Nil
− examples/failing/LeadingZeros1.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith ErrorParsingModule-module Main where--import Prelude--x = 01
− examples/failing/LeadingZeros2.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith ErrorParsingModule-module Main where--import Prelude--x = 00.1
− examples/failing/Let.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith CycleInDeclaration-module Main where--import Prelude--test = let x = x in x
− examples/failing/LetPatterns1.purs 
@@ -1,10 +0,0 @@--- @shouldFailWith ErrorParsingModule-module Main where--import Prelude---- wrong binders for function, the first one should be VarBinder-x =-  let (X a b) x y = hoge-  in-   a
− examples/failing/LetPatterns2.purs 
@@ -1,14 +0,0 @@--- @shouldFailWith UnknownName-module Main where--import Prelude--data X a = X a---- wrong dependency order-x =-  let-    b = a-    X a = X 10-  in-   b
− examples/failing/LetPatterns3.purs 
@@ -1,13 +0,0 @@--- @shouldFailWith IncorrectConstructorArity-module Main where--import Prelude--data X a = X a---- a parameter binder should be with nullary constructor, or with parens-x =-  let-    a X b = b-  in-   a $ X 10
− examples/failing/LetPatterns4.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith ErrorParsingModule-module Main where--data X a = X a--X a = a
− examples/failing/MPTCs.purs 
@@ -1,10 +0,0 @@--- @shouldFailWith ClassInstanceArityMismatch-module Main where--import Prelude--class Foo a where-  f :: a -> a--instance fooStringString :: Foo String String where-  f a = a
− examples/failing/MissingClassExport.purs 
@@ -1,7 +0,0 @@--- @shouldFailWith TransitiveExportError-module Test (bar) where--import Prelude--class Foo a where-  bar :: a -> a
− examples/failing/MissingClassMemberExport.purs 
@@ -1,7 +0,0 @@--- @shouldFailWith TransitiveExportError-module Test (class Foo) where--import Prelude--class Foo a where-  bar :: a -> a
− examples/failing/MissingRecordField.purs 
@@ -1,10 +0,0 @@--- @shouldFailWith PropertyIsMissing-module MissingRecordField where--import Prelude ((>))--john = { first: "John", last: "Smith" }--isOver50 p = p.age > 50.0--result = isOver50 john
− examples/failing/MultipleErrors.purs 
@@ -1,13 +0,0 @@--- @shouldFailWith TypesDoNotUnify--- @shouldFailWith TypesDoNotUnify-module MultipleErrors where--import Prelude--foo :: Int -> Int-foo 0 = "Test"-foo n = bar (n - 1)--bar :: Int -> Int-bar 0 = "Test"-bar n = foo (n - 1)
− examples/failing/MultipleErrors2.purs 
@@ -1,9 +0,0 @@--- @shouldFailWith UnknownName--- @shouldFailWith UnknownName-module MultipleErrors2 where--import Prelude--foo = itDoesntExist--bar = neitherDoesThis
− examples/failing/MultipleTypeOpFixities.purs 
@@ -1,9 +0,0 @@--- @shouldFailWith MultipleTypeOpFixities
-module MultipleTypeOpFixities where
-
-import Prelude
-
-type Op x y = Op x y
-
-infix 2 type Op as !?
-infix 2 type Op as !?
− examples/failing/MultipleValueOpFixities.purs 
@@ -1,9 +0,0 @@--- @shouldFailWith MultipleValueOpFixities
-module MultipleValueOpFixities where
-
-import Prelude
-
-add x y = x + y
-
-infix 2 add as !?
-infix 2 add as !?
− examples/failing/MutRec.purs 
@@ -1,9 +0,0 @@--- @shouldFailWith CycleInDeclaration--- @shouldFailWith CycleInDeclaration-module MutRec where--import Prelude--x = y--y = x
− examples/failing/MutRec2.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith CycleInDeclaration-module Main where--import Prelude--x = x
− examples/failing/NewtypeInstance.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith InvalidNewtypeInstance-module Main where--import Prelude--data X = X--derive newtype instance showX :: Show X
− examples/failing/NewtypeInstance2.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith InvalidNewtypeInstance-module Main where--import Prelude--data X a = X a a--derive newtype instance showX :: Show a => Show (X a)
− examples/failing/NewtypeInstance3.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith InvalidNewtypeInstance-module Main where--import Prelude--class Nullary--derive newtype instance nullary :: Nullary
− examples/failing/NewtypeInstance4.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith InvalidNewtypeInstance-module Main where--import Prelude--data X = X | Y--derive newtype instance showX :: Show X
− examples/failing/NewtypeInstance5.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith InvalidNewtypeInstance-module Main where--import Prelude--newtype X a = X a--derive newtype instance functorX :: Functor X
− examples/failing/NewtypeInstance6.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith InvalidNewtypeInstance-module Main where--import Prelude--newtype X a b = X (Array b)--derive newtype instance functorX :: Functor X
− examples/failing/NewtypeMultiArgs.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith InvalidNewtype-module Main where--import Prelude--newtype Thing = Thing String Boolean
− examples/failing/NewtypeMultiCtor.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith InvalidNewtype-module Main where--import Prelude--newtype Thing = Thing String | Other
− examples/failing/NonExhaustivePatGuard.purs 
@@ -1,5 +0,0 @@--- @shouldFailWith NoInstanceFound-module Main where--f :: Int -> Int-f x | 1 <- x = x
− examples/failing/NonWildcardNewtypeInstance.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith ExpectedWildcard-module NonWildcardNewtypeInstance where--import Data.Newtype--data Test = Test String--derive instance newtypeTest :: Newtype Test String
− examples/failing/NullaryAbs.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith ErrorParsingModule-module Main where--import Prelude--func = \ -> "no"
− examples/failing/Object.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith PropertyIsMissing-module Main where--import Prelude--test o = o.foo--test1 = test {}
− examples/failing/OperatorAliasNoExport.purs 
@@ -1,7 +0,0 @@--- @shouldFailWith TransitiveExportError-module Test ((?!)) where--infixl 4 what as ?!--what :: forall a b. a -> b -> a-what a _ = a
− examples/failing/OperatorSections.purs 
@@ -1,7 +0,0 @@--- @shouldFailWith TypesDoNotUnify-module Main where--import Prelude--main = do-  (true `not` _)
− examples/failing/OrphanInstance.purs 
@@ -1,7 +0,0 @@--- @shouldFailWith OrphanInstance
-module Test where
-
-import Class
-
-instance cBoolean :: C Boolean where
-  op a = a
− examples/failing/OrphanInstance/Class.purs 
@@ -1,4 +0,0 @@-module Class where
-
-class C a where
-  op :: a -> a
− examples/failing/OrphanInstanceFunDepCycle.purs 
@@ -1,5 +0,0 @@--- @shouldFailWith OrphanInstance-module Main where-import Lib-data L-instance clr :: C L R
− examples/failing/OrphanInstanceFunDepCycle/Lib.purs 
@@ -1,4 +0,0 @@-module Lib where--- covering sets: {{l}, {r}}-class C l r | l -> r, r -> l-data R
− examples/failing/OrphanInstanceNullary.purs 
@@ -1,4 +0,0 @@--- @shouldFailWith OrphanInstance
-module Test where
-import Lib
-instance c :: C
− examples/failing/OrphanInstanceNullary/Lib.purs 
@@ -1,2 +0,0 @@-module Lib where
-class C
− examples/failing/OrphanInstanceWithDetermined.purs 
@@ -1,5 +0,0 @@--- @shouldFailWith OrphanInstance-module Main where-import Lib-data R-instance cflr :: C F L R
− examples/failing/OrphanInstanceWithDetermined/Lib.purs 
@@ -1,5 +0,0 @@-module Lib where--- covering sets: {{f, l}}-class C f l r | l -> r-data F-data L
− examples/failing/OrphanTypeDecl.purs 
@@ -1,4 +0,0 @@--- @shouldFailWith OrphanTypeDeclaration
-module OrphanTypeDecl where
-
-fn :: Number -> Boolean
− examples/failing/OverlappingArguments.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith OverlappingArgNames-module OverlappingArguments where--import Prelude--f x x = x
− examples/failing/OverlappingBinders.purs 
@@ -1,9 +0,0 @@--- @shouldFailWith OverlappingArgNames-module OverlappingBinders where--import Prelude--data S a = S a (S a)--f x = case x of-  (S y (S y@(S z zs))) -> y
− examples/failing/OverlappingVars.purs 
@@ -1,14 +0,0 @@--- @shouldFailWith NoInstanceFound-module Main where--import Prelude--class OverlappingVars a where-  f :: a -> a--data Foo a b = Foo a b--instance overlappingVarsFoo :: OverlappingVars (Foo a a) where-  f a = a--test = f (Foo "" 0)
− examples/failing/ProgrammableTypeErrors.purs 
@@ -1,16 +0,0 @@--- @shouldFailWith NoInstanceFound--module Main where--import Prelude-import Control.Monad.Eff (Eff)-import Control.Monad.Eff.Console (log)--class MyShow a where-  myShow :: a -> String--instance cannotShowFunctions :: Fail "Cannot show functions" => MyShow (a -> b) where-  myShow _ = "unreachable"--main :: Eff _ _-main = log (myShow (_ + 1))
− examples/failing/ProgrammableTypeErrorsTypeString.purs 
@@ -1,18 +0,0 @@--- @shouldFailWith NoInstanceFound--module Main where--import Prelude-import Control.Monad.Eff (Eff)-import Control.Monad.Eff.Console (log)--newtype MyType a = MyType a--instance cannotShowFunctions :: Fail ("Don't want to show " <> TypeString (MyType a) <> " because.") => Show (MyType a) where-  show _ = "unreachable"--infixl 6 type TypeConcat as <>--main :: Eff _ _-main = do-  log $ show (MyType 2)
− examples/failing/Rank2Types.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith TypesDoNotUnify-module Main where--import Prelude--foreign import test :: (forall a. a -> a) -> Number--test1 = test (\n -> n + 1)
− examples/failing/RequiredHiddenType.purs 
@@ -1,9 +0,0 @@--- @shouldFailWith TransitiveExportError
--- exporting `a` should fail as `A` is hidden
-module Foo (B(..), a, b) where
-
-data A = A
-data B = B
-
-a = A
-b = B
− examples/failing/Reserved.purs 
@@ -1,7 +0,0 @@--- @shouldFailWith ErrorParsingModule-module Main where--import Prelude--(<) :: Number -> Number -> Number-(<) a b = !(a >= b)
− examples/failing/RowConstructors1.purs 
@@ -1,9 +0,0 @@--- @shouldFailWith KindsDoNotUnify-module Main where--import Control.Monad.Eff.Console (log)--data Foo = Bar-type Baz = { | Foo }--main = log "Done"
− examples/failing/RowConstructors2.purs 
@@ -1,9 +0,0 @@--- @shouldFailWith KindsDoNotUnify-module Main where--import Control.Monad.Eff.Console (log)--type Foo r = (x :: Number | r)-type Bar = { | Foo }--main = log "Done"
− examples/failing/RowConstructors3.purs 
@@ -1,9 +0,0 @@--- @shouldFailWith KindsDoNotUnify-module Main where--import Control.Monad.Eff.Console (log)--type Foo = { x :: Number }-type Bar = { | Foo }--main = log "Done"
− examples/failing/RowInInstanceNotDetermined0.purs 
@@ -1,9 +0,0 @@--- @shouldFailWith InvalidInstanceHead-module Main where--import Prelude---- no fundeps-class C a b-instance c :: C Unit {}-
− examples/failing/RowInInstanceNotDetermined1.purs 
@@ -1,9 +0,0 @@--- @shouldFailWith InvalidInstanceHead-module Main where--import Prelude---- `c` not mentioned in any fundeps-class C a b c | a -> b-instance c :: C Unit Unit {}-
− examples/failing/RowInInstanceNotDetermined2.purs 
@@ -1,9 +0,0 @@--- @shouldFailWith InvalidInstanceHead-module Main where--import Prelude---- `b` isn't determined by anything that `b` doesn't determine-class C a b | a -> b, b -> a-instance c :: C Unit {}-
− examples/failing/SkolemEscape.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith EscapedSkolem-module Main where--import Prelude--foreign import foo :: (forall a. a -> a) -> Number--test = \x -> foo x
− examples/failing/SkolemEscape2.purs 
@@ -1,10 +0,0 @@--- @shouldFailWith EscapedSkolem-module Main where--import Prelude-import Control.Monad.Eff-import Control.Monad.ST--test _ = do-  r <- runST (newSTRef 0)-  pure 0
− examples/failing/SuggestComposition.purs 
@@ -1,7 +0,0 @@--- @shouldFailWith TypesDoNotUnify--- TODO: Ensure the correct suggestion is produced.-module SuggestComposition where--import Prelude--f = g . g where g = (_ + 1)
− examples/failing/Superclasses1.purs 
@@ -1,14 +0,0 @@--- @shouldFailWith NoInstanceFound-module Main where--import Prelude--class Su a where-  su :: a -> a--class (Su a) <= Cl a where-  cl :: a -> a -> a--instance clNumber :: Cl Number where-  cl n m = n + m-
− examples/failing/Superclasses2.purs 
@@ -1,13 +0,0 @@--- @shouldFailWith CycleInTypeSynonym--- TODO: Should this have its own error, perhaps CycleInTypeClassDeclaration?-module CycleInSuperclasses where--import Prelude--class (Foo a) <= Bar a--class (Bar a) <= Foo a--instance barString :: Bar String--instance fooString :: Foo String
− examples/failing/Superclasses3.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith UndefinedTypeVariable-module UnknownSuperclassTypeVar where--import Prelude--class Foo a--class (Foo b) <= Bar a
− examples/failing/Superclasses5.purs 
@@ -1,26 +0,0 @@--- @shouldFailWith NoInstanceFound--module Main where--import Prelude-import Control.Monad.Eff.Console (logShow)--class Su a where-  su :: a -> a--class Su (Array a) <= Cl a where-  cl :: a -> a -> a--instance suNumber :: Su Number where-  su n = n + 1.0--instance suArray :: Su a => Su (Array a) where-  su [x] = [su x]--instance clNumber :: Cl Number where-  cl n m = n + m--test :: forall a. Cl a => a -> Array a-test x = su [cl x x]--main = logShow $ test 10.0
− examples/failing/TooFewClassInstanceArgs.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith ClassInstanceArityMismatch-module Main where--import Prelude--class Foo a b--instance fooString :: Foo String
− examples/failing/TopLevelCaseNoArgs.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith DuplicateValueDeclaration-module Main where--import Prelude--foo :: Number-foo = 1-foo = 2
− examples/failing/TransitiveDctorExport.purs 
@@ -1,5 +0,0 @@--- @shouldFailWith TransitiveExportError-module Main (Y(..)) where--type X = Int-data Y = Y X
− examples/failing/TransitiveSynonymExport.purs 
@@ -1,5 +0,0 @@--- @shouldFailWith TransitiveExportError-module Main (Y()) where--type X = Int-type Y = X
− examples/failing/TypeClassInstances.purs 
@@ -1,11 +0,0 @@--- @shouldFailWith MissingClassMember-module Main where--import Prelude--class A a where-  a :: a -> String-  b :: a -> Number--instance aString :: A String where-  a s = s
− examples/failing/TypeClasses2.purs 
@@ -1,9 +0,0 @@--- @shouldFailWith NoInstanceFound-module Main where--import Prelude ()--class Show a where-  show :: a -> String--test = show "testing"
− examples/failing/TypeError.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith TypesDoNotUnify-module Main where--import Prelude--test = 1 <> "A"
− examples/failing/TypeOperatorAliasNoExport.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith TransitiveExportError-module Test (type (×)) where--data Tuple a b = Tuple a b--infixl 6 type Tuple as ×
− examples/failing/TypeSynonyms.purs 
@@ -1,8 +0,0 @@--- @shouldFailWith CycleInTypeSynonym-module Main where--import Prelude--type T1 = Array T2--type T2 = T1
− examples/failing/TypeSynonyms2.purs 
@@ -1,12 +0,0 @@--- @shouldFailWith TypeSynonymInstance-module Main where--import Prelude--class Foo a where-  foo :: a -> String--type Bar = String--instance fooBar :: Foo Bar where-  foo s = s
− examples/failing/TypeSynonyms3.purs 
@@ -1,12 +0,0 @@--- @shouldFailWith TypeSynonymInstance-module Main where--import Prelude--class Foo a where-  foo :: a -> String--type Bar = String--instance fooBar :: Foo Bar where-  foo s = s
− examples/failing/TypeSynonyms4.purs 
@@ -1,11 +0,0 @@--- @shouldFailWith PartiallyAppliedSynonym-module TypeSynonyms4 where--import Prelude--type F x y = x -> y--type G x = F x--f :: G String String -> String-f k = k "Done"
− examples/failing/TypeSynonyms5.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith CycleInTypeSynonym-module Main where--import Prelude--type T = T
− examples/failing/TypeWildcards1.purs 
@@ -1,7 +0,0 @@--- @shouldFailWith ErrorParsingModule-module TypeWildcards where--import Prelude--type Test = _-
− examples/failing/TypeWildcards2.purs 
@@ -1,7 +0,0 @@--- @shouldFailWith ErrorParsingModule-module TypeWildcards where--import Prelude--data Test = Test _-
− examples/failing/TypeWildcards3.purs 
@@ -1,9 +0,0 @@--- @shouldFailWith InvalidInstanceHead-module TypeWildcards where--import Prelude--data Foo a = Foo--instance showFoo :: Show (Foo _) where-  show Foo = "Foo"
− examples/failing/TypedBinders.purs 
@@ -1,10 +0,0 @@--- @shouldFailWith ErrorParsingModule-module Main where--import Control.Monad.Eff.Console (log)--test = (\f :: Int -> Int -> f 10) id--main = do-  let t1 = test-  log "Done"
− examples/failing/TypedBinders2.purs 
@@ -1,9 +0,0 @@--- @shouldFailWith TypesDoNotUnify-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--main = do-  s :: String <- log "Foo"-  log "Done"
− examples/failing/TypedBinders3.purs 
@@ -1,13 +0,0 @@--- @shouldFailWith TypesDoNotUnify-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--test = case 1 of-  (0 :: String) -> true-  _ -> false--main = do-  let t = test-  log "Done"
− examples/failing/TypedHole.purs 
@@ -1,9 +0,0 @@--- @shouldFailWith HoleInferredType-module Main where--import Prelude-import Control.Monad.Eff (Eff)-import Control.Monad.Eff.Console (CONSOLE, log)--main :: forall e. Eff (console :: CONSOLE | e) Unit-main = ?ummm
− examples/failing/UnderscoreModuleName.purs 
@@ -1,6 +0,0 @@--- @shouldFailWith ErrorParsingModule-module Bad_Module where--import Control.Monad.Eff.Console (log)--main = log "Done"
− examples/failing/UnknownType.purs 
@@ -1,7 +0,0 @@--- @shouldFailWith UnknownName-module Main where--import Prelude--test :: Number -> Something-test = {}
− examples/failing/UnusableTypeClassMethod.purs 
@@ -1,7 +0,0 @@--- @shouldFailWith UnusableDeclaration-module Main where--class C a b where-  -- type doesn't contain `a`, which is also required to determine an instance-  c :: b-
− examples/failing/UnusableTypeClassMethodConflictingIdent.purs 
@@ -1,7 +0,0 @@--- @shouldFailWith UnusableDeclaration-module Main where--class C a where-  -- type doesn't contain the type class var `a`-  c :: forall a. a-
− examples/failing/UnusableTypeClassMethodSynonym.purs 
@@ -1,9 +0,0 @@--- @shouldFailWith UnusableDeclaration-module Main where--type M x = forall a. a--class C a where-  -- after synonym expansion, the type doesn't actually contain an `a`-  c :: M a-
− examples/passing/1110.purs 
@@ -1,26 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--data X a = X--x :: forall a. X a-x = X-	 -type Y = { x :: X Int }--test :: forall m. Monad m => m Y-test = pure { x: x }--type Z t = forall x. t x -> (forall a. t a) -> t x--class C t where c :: Z t--instance cA :: C Array where-  c x _ = x--test2 :: forall m. Monad m => m { ccc :: Z Array }-test2 = pure { ccc: (c :: Z Array) }--main = log "Done"
− examples/passing/1185.purs 
@@ -1,15 +0,0 @@-module Main where--import Control.Monad.Eff.Console (log)--data Person = Person String Boolean--getName :: Person -> String-getName p = case p of-              Person name true -> name-              _ -> "Unknown"--name :: String-name = getName (Person "John Smith" true)--main = log "Done"
− examples/passing/1335.purs 
@@ -1,14 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--x :: forall a. a -> String-x a = y "Test"-  where-  y :: forall a. Show a => a -> String-  y a = show (a :: a)--main = do-  log (x 0)-  log "Done"
− examples/passing/1570.purs 
@@ -1,8 +0,0 @@-module Main where--import Control.Monad.Eff.Console (log)--test :: forall a. a -> a-test = \(x :: a) -> x--main = log "Done"
− examples/passing/1664.purs 
@@ -1,16 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff-import Control.Monad.Eff.Console--data Identity a = Identity a--newtype IdentityEff e a = IdentityEff (Eff e (Identity a))--test :: forall e a. IdentityEff e a -> IdentityEff e Unit-test (IdentityEff action) = IdentityEff $ do-  (Identity x :: Identity _) <- action-  pure $ Identity unit--main = log "Done"
− examples/passing/1697.purs 
@@ -1,25 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--_2 :: forall a. a -> a-_2 a = a--x :: forall m. Monad m => m Unit-x = do-  _ <- pure unit-  pure unit--y :: forall m. Monad m => m Unit-y = do-  _ <- pure unit-  pure unit--wtf :: forall m. Monad m => m Unit-wtf = do-  _ <- pure unit-  let tmp = _2 1-  pure unit--main = log "Done"
− examples/passing/1807.purs 
@@ -1,14 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--fn = _.b.c.d-a = {b:{c:{d:2}}}--d :: Int-d = fn a + a.b.c.d--main = if fn a + a.b.c.d == 4-  then log "Done"-  else log "Fail"
− examples/passing/1881.purs 
@@ -1,19 +0,0 @@-module Main where--import Control.Monad.Eff.Console (log)--foo =- 1--bar- = 2--baz- =- 3--qux-  =- 3--main = log "Done"
− examples/passing/1991.purs 
@@ -1,22 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--singleton :: forall a. a -> Array a-singleton x = [x]--empty :: forall a. Array a-empty = []--foldMap :: forall a m. Semigroup m => (a -> m) -> Array a -> m-foldMap f [a, b, c, d, e] = f a <> f b <> f c <> f d <> f e-foldMap f xs = foldMap f xs -- spin, not used--regression :: Array Int-regression =-  let as = [1,2,3,4,5]-      as' = foldMap (\x -> if 1 < x && x < 4 then singleton x else empty) as-  in as'--main = log "Done"
− examples/passing/2018.purs 
@@ -1,12 +0,0 @@-module Main where--import Prelude-import A (foo)-import B (Foo(..))-import Control.Monad.Eff (Eff)-import Control.Monad.Eff.Console (CONSOLE, log)--main :: forall e. Eff (console :: CONSOLE | e) Unit-main = do-  let tmp = foo X-  log "Done"
− examples/passing/2018/A.purs 
@@ -1,7 +0,0 @@-module A where--import B as Main---- Prior to the 2018 fix this would be detected as a cycle between A and Main.-foo ∷ Main.Foo → Main.Foo-foo x = x
− examples/passing/2018/B.purs 
@@ -1,3 +0,0 @@-module B where--data Foo = X | Y
− examples/passing/2049.purs 
@@ -1,14 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--data List a = Cons a (List a) | Nil--infixr 6 Cons as :--f :: List { x :: Int, y :: Int } -> Int-f ( r@{ x } : _) = x + r.y-f _ = 0--main = log "Done"
− examples/passing/2136.purs 
@@ -1,9 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--main = -  if (negate (bottom :: Int) > top)-    then log "Fail"-    else log "Done"
− examples/passing/2138.purs 
@@ -1,7 +0,0 @@-module Main where--import Control.Monad.Eff.Console (log)--import Lib (A(B,C))--main = log "Done"
− examples/passing/2138/Lib.purs 
@@ -1,3 +0,0 @@-module Lib (A(..), A) where--data A = B | C
− examples/passing/2172.js 
@@ -1,5 +0,0 @@-exports['a\''] = 0;-exports["\x62\x27"] = 1;-// NOTE: I wanted to use "\c'" here, but langauge-javascript doesn't support it...-exports["c'"] = 2;-exports["\u0064\u0027"] = 3;
− examples/passing/2172.purs 
@@ -1,10 +0,0 @@-module Main where--import Control.Monad.Eff.Console (log)--foreign import a' :: Number-foreign import b' :: Number-foreign import c' :: Number-foreign import d' :: Number--main = log "Done"
− examples/passing/2197-1.purs 
@@ -1,12 +0,0 @@-module Main where--import Control.Monad.Eff.Console-import Prim as P--type Number = P.Number-type Test = {}--z :: Number-z = 0.0--main = log "Done"
− examples/passing/2197-2.purs 
@@ -1,11 +0,0 @@-module Main where--import Control.Monad.Eff.Console-import Prim (Int)--type Number = Int--z :: Number-z = 0--main = log "Done"
− examples/passing/2252.purs 
@@ -1,15 +0,0 @@-module Main where-	-import Control.Monad.Eff.Console (log)--data T a = T-	 -ti :: T Int-ti = T--t :: forall a. T a-t = T--xs = [ti, t, t]--main = log "Done"
− examples/passing/2288.purs 
@@ -1,19 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff-import Control.Monad.Eff.Console-import Data.Array-import Data.Array.Partial as P-import Partial.Unsafe--length :: forall a. Array a -> Int-length = go 0 where-  go acc arr =-    if null arr-    then acc-    else go (acc + 1) (unsafePartial P.tail arr)--main = do-  logShow (length (1 .. 10000))-  log "Done"
− examples/passing/2378.purs 
@@ -1,9 +0,0 @@-module Main where--import Control.Monad.Eff.Console (log)--class Foo (a :: Symbol)--instance fooX :: Foo "x"--main = log "Done"
− examples/passing/2438.purs 
@@ -1,8 +0,0 @@-module Main where--import Control.Monad.Eff.Console (log)--done :: String-done = {"𝌆": "Done"}."𝌆"--main = log done
− examples/passing/2609.purs 
@@ -1,12 +0,0 @@-module Main where--import Prelude-import Eg (Foo'(Bar'), (:->))-import Control.Monad.Eff (Eff)-import Control.Monad.Eff.Console (CONSOLE, log)--bar' :: Foo'-bar' = 4 :-> 5--main :: forall e. Eff (console :: CONSOLE | e) Unit-main = case bar' of Bar' l r -> log "Done"
− examples/passing/2609/Eg.purs 
@@ -1,6 +0,0 @@-module Eg (Foo'(Bar'), (:->)) where--data Foo' = Bar' Int Int--infix 4 Bar' as :->-
− examples/passing/2616.purs 
@@ -1,13 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--newtype F r a = F { x :: a | r }--unF :: forall r a. F r a -> { x :: a | r }-unF (F x) = x--derive instance functorF :: Functor (F r)--main = log (unF (map id (F { x: "Done", y: 42 }))).x
− examples/passing/2626.purs 
@@ -1,13 +0,0 @@-module Main where--import Control.Monad.Eff.Console (log)--f = \(x :: forall a. a -> a) -> x x--test1 = (f \x -> x) 1--g = \(x :: (forall a. a -> a) -> Int) -> x (\y -> y)--test2 = g \f -> if f true then f 0 else f 1--main = log "Done"
− examples/passing/2663.purs 
@@ -1,9 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--foo :: forall t. Warn "Example" => t -> t-foo x = x--main = when (foo 42 == 42) $ log "Done"
− examples/passing/2689.purs 
@@ -1,36 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console-import Data.Array.Partial-import Partial.Unsafe--sumTCObug = go id where -  go f 0 = f -  go f n =-    let-      f' a = n + a-    in-      go f' 0--sumTCObug' = go id where -  go f 0 = f-  go f n = go (\a -> n + a) 0--count :: forall a. (a -> Boolean) -> Array a -> Int-count p = count' 0 where-  count' acc [] = acc-  count' acc xs =-    let h = unsafePartial head xs-    in count' (acc + if p h then 1 else 0) (unsafePartial tail xs)--main = do-  let x = sumTCObug 7 3-      y = sumTCObug' 7 3-      z = count (_ > 0) [-1, 0, 1]-  logShow x-  logShow y -  logShow z-  if x == 10 && y == 10 && z == 1-    then log "Done"-    else log "Fail"
− examples/passing/2695.purs 
@@ -1,13 +0,0 @@-module Main where--import Prelude-import Data.Generic-import Control.Monad.Eff.Console (log)--type Foo = { foo :: Int }--newtype Foo' = Foo' Foo--derive instance genericFoo :: Generic Foo'--main = log "Done"
− examples/passing/2756.purs 
@@ -1,20 +0,0 @@-module Main where--import Control.Monad.Eff (Eff)-import Control.Monad.Eff.Console (log)-import Prelude--pu :: forall eff. Eff eff Unit-pu = pure unit--type C eff = { pu :: Eff eff Unit }--sampleC :: C ()-sampleC = { pu: pu }--newtype Identity a = Id a--sampleIdC :: Identity (C ())-sampleIdC = Id { pu : pu }--main = log "Done"
− examples/passing/2787.purs 
@@ -1,8 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console--main-  | between 0 1 2 = log "Fail"-  | otherwise = log "Done"
− examples/passing/2795.purs 
@@ -1,14 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--data X = X Int | Y--x :: X -> Int-x = case _ of-      Y -> 0-      X n | 1 <- n -> 1-          | otherwise -> 2--main = log "Done"
− examples/passing/2806.purs 
@@ -1,14 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--data Stream a = Cons a (Stream a)--step :: forall a. Stream a -> Stream a-step (Cons _ xs) = xs--head :: forall a. Stream a -> a-head xs | Cons x _ <- step xs = x--main = log "Done"
− examples/passing/2958.purs 
@@ -1,14 +0,0 @@-module Main where--import Control.Monad.Eff.Console--data Nil-data Snoc xs x--infixl 1 type Snoc as :>--type One = Nil :> Int-type Two = Nil :> Int :> Int-type Three = Nil :> Int :> Int :> Int--main = log "Done"
− examples/passing/2972.purs 
@@ -1,13 +0,0 @@-module Main where--import Control.Monad.Eff.Console (log)-import Prelude (class Show, show)--type I t = t--newtype Id t = Id t--instance foo :: Show (I t) => Show (Id t) where-  show (Id t) = "Done"--main = log (show (Id "other"))
− examples/passing/3125.purs 
@@ -1,16 +0,0 @@-module Main where--import Prelude-import Data.Monoid (class Monoid, mempty)-import Control.Monad.Eff.Console (log, logShow)--data B a = B a a--memptyB :: forall a b. Monoid b => B (a -> b)-memptyB = B l r where-  l _ = mempty-  r _ = mempty--main = do-  logShow $ case (memptyB :: B (Int -> Array Unit)) of B l r -> l 0 == r 0-  log "Done"
− examples/passing/652.purs 
@@ -1,18 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--class Foo a b--class Bar a c--class (Foo a b, Bar a c) <= Baz a b c--instance foo :: Foo (a -> b) a--instance bar :: Bar (a -> b) b--instance baz :: (Eq a) => Baz (a -> b) a b--main = log "Done"
− examples/passing/810.purs 
@@ -1,14 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--data Maybe a = Nothing | Just a--test :: forall a. Maybe a -> Maybe a-test m = o.x-  where-    o = case m of Nothing -> { x : Nothing }-                  Just a  -> { x : Just a }--main = log "Done"
− examples/passing/862.purs 
@@ -1,8 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console--id' = (\x -> x) <$> \y -> y--main = log (id' "Done")
− examples/passing/922.purs 
@@ -1,20 +0,0 @@-module Main where--import Prelude--import Control.Monad.Eff.Console--class Default a where-  def :: a--instance defaultString :: Default String where-  def = "Done"--data I a = I a--instance defaultI :: (Default a) => Default (I a) where-  def = I def--main = do-  case def of-    I s -> log s
− examples/passing/Applicative.purs 
@@ -1,16 +0,0 @@-module Main where--import Control.Monad.Eff.Console (log)--class Applicative f where-  pure :: forall a. a -> f a-  apply :: forall a b. f (a -> b) -> f a -> f b--data Maybe a = Nothing | Just a--instance applicativeMaybe :: Applicative Maybe where-  pure = Just-  apply (Just f) (Just a) = Just (f a)-  apply _ _ = Nothing--main = log "Done"
− examples/passing/ArrayType.purs 
@@ -1,12 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--class Pointed p where-  point :: forall a. a -> p a--instance pointedArray :: Pointed Array where-  point a = [a]--main = log "Done"
− examples/passing/Auto.purs 
@@ -1,16 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--data Auto s i o = Auto { state :: s, step :: s -> i -> o }--type SomeAuto i o = forall r. (forall s. Auto s i o -> r) -> r--exists :: forall s i o. s -> (s -> i -> o) -> SomeAuto i o-exists = \state step f -> f (Auto { state: state, step: step })--run :: forall i o. SomeAuto i o -> i -> o-run = \s i -> s (\a -> case a of Auto a -> a.step a.state i)--main = log "Done"
− examples/passing/AutoPrelude.purs 
@@ -1,11 +0,0 @@-module Main where
-
-import Prelude
-import Control.Monad.Eff.Console (log)
-
-f x = x * 10.0
-g y = y - 10.0
-
-main = do
-  log $ show $ (f <<< g) 100.0
-  log "Done"
− examples/passing/AutoPrelude2.purs 
@@ -1,10 +0,0 @@-module Main where--import Prelude-import Prelude as P-import Control.Monad.Eff.Console--f :: forall a. a -> a-f = P.id--main = P.($) log ((f P.<<< f) "Done")
− examples/passing/BindersInFunctions.purs 
@@ -1,16 +0,0 @@-module Main where--import Prelude-import Partial.Unsafe (unsafePartial)-import Test.Assert (assert')-import Control.Monad.Eff (Eff)-import Control.Monad.Eff.Console (log)--snd :: forall a. Partial => Array a -> a-snd = \[_, y] -> y--main :: Eff _ _-main = do-  let ts = unsafePartial (snd [1.0, 2.0])-  assert' "Incorrect result from 'snd'." (ts == 2.0)-  log "Done"
− examples/passing/BindingGroups.purs 
@@ -1,11 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--foo = bar-  where bar r = r + 1.0--r = foo 2.0--main = log "Done"
− examples/passing/BlockString.purs 
@@ -1,9 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--foo :: String-foo = """foo"""--main = log "Done"
− examples/passing/CaseInDo.purs 
@@ -1,21 +0,0 @@-module Main where--import Prelude-import Partial.Unsafe (unsafeCrashWith)-import Control.Monad.Eff.Console-import Control.Monad.Eff--doIt :: forall eff. Eff eff Boolean-doIt = pure true--set = do-  log "Testing..."-  case 0 of-    0 -> doIt-    _ -> pure false--main = do-  b <- set-  case b of-    true -> log "Done"-    false -> unsafeCrashWith "Failed"
− examples/passing/CaseInputWildcard.purs 
@@ -1,18 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff (Eff)-import Control.Monad.Eff.Console (log, CONSOLE)--data Foo = X | Y--what ∷ Foo → Int → Boolean → Foo-what x = case _, x, _ of-  0, X, true → X-  0, Y, true → X-  _, _, _ → Y--main :: forall e. Eff (console :: CONSOLE | e) Unit-main = do-  let tmp = what Y 0 true-  log "Done"
− examples/passing/CaseMultipleExpressions.purs 
@@ -1,21 +0,0 @@-module Main where--import Prelude-import Partial.Unsafe (unsafeCrashWith)-import Control.Monad.Eff.Console-import Control.Monad.Eff--doIt :: forall eff. Eff eff Boolean-doIt = pure true--set = do-  log "Testing..."-  case 42, 10 of-    42, 10 -> doIt-    _ , _  -> pure false--main = do-  b <- set-  case b of-    true -> log "Done"-    false -> unsafeCrashWith "Failed"
− examples/passing/CaseStatement.purs 
@@ -1,22 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--data A = A | B | C--f a _ A = a-f _ a B = a-f _ _ C = "Done"--g a _ A = a-g _ b B = b-g _ _ C = C--data M a = N | J a--h f N a = a-h f a N = a-h f (J a) (J b) = J (f a b)--main = log $ f "Done" "Failed" A
− examples/passing/CheckFunction.purs 
@@ -1,8 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--test = ((\x -> x+1.0) >>> (\x -> x*2.0)) 4.0--main = log "Done"
− examples/passing/CheckSynonymBug.purs 
@@ -1,13 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--length :: forall a. Array a -> Int-length _ = 0--type Foo a = Array a--foo _ = length ([] :: Foo Number)--main = log "Done"
− examples/passing/CheckTypeClass.purs 
@@ -1,18 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--data Bar a = Bar-data Baz--class Foo a where-  foo :: Bar a -> Baz--foo_ :: forall a. Foo a => a -> Baz-foo_ x = foo ((mkBar :: forall a. Foo a => a -> Bar a) x)--mkBar :: forall a. a -> Bar a-mkBar _ = Bar--main = log "Done"
− examples/passing/Church.purs 
@@ -1,18 +0,0 @@-module Main where--import Control.Monad.Eff.Console (log)--type List a = forall r. r -> (a -> r -> r) -> r--empty :: forall a. List a-empty = \r f -> r--cons :: forall a. a -> List a -> List a-cons = \a l r f -> f a (l r f)--append :: forall a. List a -> List a -> List a-append = \l1 l2 r f -> l2 (l1 r f) f--test = append (cons 1 empty) (cons 2 empty)--main = log "Done"
− examples/passing/ClassRefSyntax.purs 
@@ -1,9 +0,0 @@-module Main where--import Lib (class X, go)-import Control.Monad.Eff.Console (log)--go' :: forall a. X a => a -> a-go' = go--main = log "Done"
− examples/passing/ClassRefSyntax/Lib.purs 
@@ -1,4 +0,0 @@-module Lib (class X, go) where--class X a where-  go :: a -> a
− examples/passing/Collatz.purs 
@@ -1,21 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff-import Control.Monad.ST-import Control.Monad.Eff.Console (log, logShow)--collatz :: Int -> Int-collatz n = runPure (runST (do-  r <- newSTRef n-  count <- newSTRef 0-  untilE $ do-    _ <- modifySTRef count $ (+) 1-    m <- readSTRef r-    _ <- writeSTRef r $ if m `mod` 2 == 0 then m / 2 else 3 * m + 1-    pure $ m == 1-  readSTRef count))--main = do-  logShow $ collatz 1000-  log "Done"
− examples/passing/Comparisons.purs 
@@ -1,15 +0,0 @@-module Main where
-
-import Prelude
-import Control.Monad.Eff
-import Control.Monad.Eff.Console
-import Test.Assert
-
-main = do
-  assert (1.0 < 2.0)
-  assert (2.0 == 2.0)
-  assert (3.0 > 1.0)
-  assert ("a" < "b")
-  assert ("a" == "a")
-  assert ("z" > "a")
-  log "Done"
− examples/passing/Conditional.purs 
@@ -1,9 +0,0 @@-module Main where--import Control.Monad.Eff.Console (log)--fns = \f -> if f true then f else \x -> x--not = \x -> if x then false else true--main = log "Done"
− examples/passing/Console.purs 
@@ -1,15 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff-import Control.Monad.Eff.Console--replicateM_ :: forall m a. Monad m => Number -> m a -> m Unit-replicateM_ 0.0 _ = pure unit-replicateM_ n act = do-  _ <- act-  replicateM_ (n - 1.0) act--main = do-  replicateM_ 10.0 (log "Hello World!")-  log "Done"
− examples/passing/ConstraintInference.purs 
@@ -1,10 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--shout = log <<< (_ <> "!") <<< show--main = do-  shout "Test"-  log "Done"
− examples/passing/ConstraintParens.purs 
@@ -1,12 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--class Foo a where-  foo ∷ a → a--test ∷ ∀ a. (Foo a) ⇒ a → a-test = foo--main = log "Done"
− examples/passing/ConstraintParsingIssue.purs 
@@ -1,9 +0,0 @@-module Main where--import Control.Monad.Eff.Console--class X a--instance x :: X (Array (Array a)) => X (Array a)--main = log "Done"
− examples/passing/ContextSimplification.purs 
@@ -1,15 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console--shout = log <<< (_ <> "!") <<< show---- Here, we should simplify the context so that only one Show--- constraint is added.-usesShowTwice true = shout-usesShowTwice false = logShow--main = do-  usesShowTwice true "Test"-  log "Done"
− examples/passing/DataAndType.purs 
@@ -1,10 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--data A = A B--type B = A--main = log "Done"
− examples/passing/DctorName.purs 
@@ -1,33 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--newtype Bar' = Bar' Int--data Foo' = Foo' Bar'--data Baz'' = Baz'' | Baz'--f ∷ Foo' → Boolean-f a = case a of Foo' b → true--f' ∷ Boolean-f' = f $ Foo' $ Bar' 0--g ∷ Baz'' → Int-g Baz'' = 0-g Baz' = 1--g' ∷ Int-g' = g Baz''--h ∷ Bar' → Int-h (Bar' x)- | x <= 10 = x * 2 - | otherwise = 10--h' ∷ Int-h' = h $ Bar' 4--main = log "Done"
− examples/passing/DctorOperatorAlias.purs 
@@ -1,34 +0,0 @@-module Main where--  import Prelude (Unit, bind, discard, (==))-  import Control.Monad.Eff (Eff)-  import Control.Monad.Eff.Console (CONSOLE, log)-  import Test.Assert (ASSERT, assert')-  import List (List(..), (:))-  import List as L--  -- unqualified-  infixl 6 Cons as !--  -- qualified-  infixl 6 L.Cons as !!--  get1 ∷ ∀ a. a → List a → a-  get1 y xs = case xs of-    _ : x : _ → x-    _ → y--  get2 ∷ ∀ a. a → List a → a-  get2 _ (_ : x : _) = x-  get2 y _ = y--  get3 ∷ ∀ a. a → List a → a-  get3 _ (_ ! (x ! _)) = x-  get3 y _ = y--  main ∷ Eff (assert ∷ ASSERT, console ∷ CONSOLE) Unit-  main = do-    assert' "Incorrect result!" (get1 0 (1 : 2 : 3 : Nil) == 2)-    assert' "Incorrect result!" (get2 0 (1 ! (2 ! (3 ! Nil))) == 2)-    assert' "Incorrect result!" (get3 0.0 (1.0 : 2.0 : (3.0 ! Nil)) == 2.0)-    log "Done"
− examples/passing/DctorOperatorAlias/List.purs 
@@ -1,5 +0,0 @@-module List where--data List a = Cons a (List a) | Nil--infixr 6 Cons as :
− examples/passing/DeepArrayBinder.purs 
@@ -1,17 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff-import Control.Monad.Eff.Console (log)-import Test.Assert--data List a = Cons a (List a) | Nil--match2 :: List Number -> Number-match2 (Cons x (Cons y xs)) = x * y + match2 xs-match2 _ = 0.0--main = do-  let result = match2 (Cons 1.0 (Cons 2.0 (Cons 3.0 (Cons 4.0 (Cons 5.0 (Cons 6.0 (Cons 7.0 (Cons 8.0 (Cons 9.0 Nil)))))))))-  assert' "Incorrect result!" (result == 100.0)-  log "Done"
− examples/passing/DeepCase.purs 
@@ -1,15 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log, logShow)--f x y =-  let-    g = case y of-	  0.0 -> x-          x -> 1.0 + x * x-  in g + x + y--main = do-  logShow $ f 1.0 10.0-  log "Done"
− examples/passing/DeriveNewtype.purs 
@@ -1,29 +0,0 @@-module Main where--import Control.Monad.Eff.Console (log)--import Data.Newtype--type MyString = String--newtype Test = Test MyString--derive instance newtypeTest :: Newtype Test _--t :: Test-t = wrap "hello"--a :: String-a = unwrap t--newtype First a = First a--derive instance newtypeFirst :: Newtype (First b) _--f :: First Int-f = wrap 1--i :: Int-i = unwrap f--main = log "Done"
− examples/passing/DeriveWithNestedSynonyms.purs 
@@ -1,29 +0,0 @@-module Main where-	-import Prelude-import Control.Monad.Eff.Console (log)--type L = {}-data X = X L-derive instance eqX :: Eq X--type M = {}-data Y = Y {foo :: M}-derive instance eqY :: Eq Y--type N = {}-data Z = Z N-derive instance eqZ :: Eq Z--type Foo = String--type Bar = { foo :: Foo }--type Baz = { baz :: Bar }--newtype T = T Baz--derive instance eqT :: Eq T-derive instance ordT :: Ord T--main = log "Done"
− examples/passing/Deriving.purs 
@@ -1,36 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)-import Test.Assert--data V--derive instance eqV :: Eq V--derive instance ordV :: Ord V--type MyString = String--data X = X Int | Y MyString--derive instance eqX :: Eq X--derive instance ordX :: Ord X--newtype Z = Z { left :: X, right :: X }--derive instance eqZ :: Eq Z--main = do-  assert $ X 0 == X 0-  assert $ X 0 /= X 1-  assert $ Y "Foo" == Y "Foo"-  assert $ Y "Foo" /= Y "Bar"-  assert $ X 0 < X 1-  assert $ X 0 < Y "Foo"-  assert $ Y "Bar" < Y "Baz"-  assert $ z == z-  log "Done"-  where-  z = Z { left: X 0, right: Y "Foo" }
− examples/passing/DerivingFunctor.purs 
@@ -1,28 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)-import Test.Assert--type MyRecord a = { myField :: a }--data M f a-  = M0 a (Array a)-  | M1 Int-  | M2 (f a)-  | M3 { foo :: Int, bar :: a, baz :: f a }-  | M4 (MyRecord a)--derive instance eqM :: (Eq (f a), Eq a) => Eq (M f a)--derive instance functorM :: Functor f => Functor (M f)--type MA = M Array--main = do-  assert $ map show (M0 0 [1, 2] :: MA Int) == M0 "0" ["1", "2"]-  assert $ map show (M1 0 :: MA Int) == M1 0-  assert $ map show (M2 [0, 1] :: MA Int) == M2 ["0", "1"]-  assert $ map show (M3 {foo: 0, bar: 1, baz: [2, 3]} :: MA Int) == M3 {foo: 0, bar: "1", baz: ["2", "3"]}-  assert $ map show (M4 { myField: 42 }) == M4 { myField: "42" } :: MA String -  log "Done"
− examples/passing/Do.purs 
@@ -1,68 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--data Maybe a = Nothing | Just a--instance functorMaybe :: Functor Maybe where-  map f Nothing = Nothing-  map f (Just x) = Just (f x)--instance applyMaybe :: Apply Maybe where-  apply (Just f) (Just x) = Just (f x)-  apply _ _ = Nothing--instance applicativeMaybe :: Applicative Maybe where-  pure = Just--instance bindMaybe :: Bind Maybe where-  bind Nothing _ = Nothing-  bind (Just a) f = f a--instance monadMaybe :: Monad Maybe--test1 = \_ -> do-  Just "abc"--test2 = \_ -> do-  x <- Just 1.0-  y <- Just 2.0-  Just (x + y)--test3 = \_ -> do-  _ <- Just 1.0-  _ <- Nothing :: Maybe Number-  Just 2.0--test4 mx my = do-  x <- mx-  y <- my-  Just (x + y + 1.0)--test5 mx my mz = do-  x <- mx-  y <- my-  let sum = x + y-  z <- mz-  Just (z + sum + 1.0)--test6 mx = \_ -> do-  let-    f :: forall a. Maybe a -> a-    f (Just x) = x-  Just (f mx)--test8 = \_ -> do-  Just (do-    Just 1.0)--test9 = \_ -> (+) <$> Just 1.0 <*> Just 2.0--test10 _ = do-  let-    f x = g x * 3.0-    g x = f x / 2.0-  Just (f 10.0)--main = log "Done"
− examples/passing/Dollar.purs 
@@ -1,16 +0,0 @@-module Main where--import Control.Monad.Eff.Console (log)--applyFn :: forall a b. (a -> b) -> a -> b-applyFn f x = f x--infixr 1000 applyFn as $--id x = x--test1 x = id $ id $ id $ id $ x--test2 x = id id $ id x--main = log "Done"
− examples/passing/DuplicateProperties.purs 
@@ -1,27 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--data RProxy (r :: # Type) = RProxy--data Proxy (a :: Type) = Proxy--subtractX :: forall r a. RProxy (x :: a | r) -> RProxy r-subtractX RProxy = RProxy--extractX :: forall r a. RProxy (x :: a | r) -> Proxy a-extractX RProxy = Proxy--hasX :: forall r a b. RProxy (x :: a, y :: b | r)-hasX = RProxy--test1 = subtractX (subtractX hasX)--test2-  :: forall r a b-   . RProxy (x :: a, x :: b, x :: Int | r)-  -> Proxy Int-test2 x = extractX (subtractX (subtractX x))--main = log "Done"
− examples/passing/Eff.purs 
@@ -1,26 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff-import Control.Monad.ST-import Control.Monad.Eff.Console (log, logShow)--test1 = do-  log "Line 1"-  log "Line 2"--test2 = runPure (runST (do-          ref <- newSTRef 0.0-          _ <- modifySTRef ref $ \n -> n + 1.0-          readSTRef ref))--test3 = pureST (do-          ref <- newSTRef 0.0-          _ <- modifySTRef ref $ \n -> n + 1.0-          readSTRef ref)--main = do-  test1-  logShow test2-  logShow test3-  log "Done"
− examples/passing/EmptyDataDecls.purs 
@@ -1,20 +0,0 @@-module Main where--import Prelude-import Test.Assert-import Control.Monad.Eff.Console (log)--data Z-data S n--data ArrayBox n a = ArrayBox (Array a)--nil :: forall a. ArrayBox Z a-nil = ArrayBox []--cons' :: forall a n. a -> ArrayBox n a -> ArrayBox (S n) a-cons' x (ArrayBox xs) = ArrayBox $ append [x] xs--main = case cons' 1 $ cons' 2 $ cons' 3 nil of-         ArrayBox [1, 2, 3] -> log "Done"-         _ -> assert' "Failed" false
− examples/passing/EmptyRow.purs 
@@ -1,11 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--data Foo r = Foo { | r }--test :: Foo ()-test = Foo {}--main = log "Done"
− examples/passing/EmptyTypeClass.purs 
@@ -1,11 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff-import Control.Monad.Eff.Console--head :: forall a. Partial => Array a -> a-head [x] = x--main :: Eff _ _-main = log "Done"
− examples/passing/EntailsKindedType.purs 
@@ -1,11 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff-import Control.Monad.Eff.Console--test x = show (x :: _ :: Type)--main = do-  when (show (unit :: Unit :: Type) == "unit") (log "Done")-  when (test unit == "unit") (log "Done")
− examples/passing/EqOrd.purs 
@@ -1,18 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log, logShow)--data Pair a b = Pair a b--instance ordPair :: (Ord a, Ord b) => Ord (Pair a b) where-  compare (Pair a1 b1) (Pair a2 b2) = case compare a1 a2 of-    EQ -> compare b1 b2-    r -> r--instance eqPair :: (Eq a, Eq b) => Eq (Pair a b) where-  eq (Pair a1 b1) (Pair a2 b2) = a1 == a2 && b1 == b2--main = do-  logShow $ Pair 1.0 2.0 == Pair 1.0 2.0-  log "Done"
− examples/passing/ExplicitImportReExport.purs 
@@ -1,11 +0,0 @@--- from #1244
-module Main where
-
-import Prelude
-import Control.Monad.Eff.Console (log)
-import Bar (foo)
-
-baz :: Int
-baz = foo
-
-main = log "Done"
− examples/passing/ExplicitImportReExport/Bar.purs 
@@ -1,3 +0,0 @@-module Bar (module Foo) where
-
-import Foo
− examples/passing/ExplicitImportReExport/Foo.purs 
@@ -1,4 +0,0 @@-module Foo where
-
-foo :: Int
-foo = 3
− examples/passing/ExplicitOperatorSections.purs 
@@ -1,15 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--subtractOne :: Int -> Int-subtractOne = (_ - 1)--addOne :: Int -> Int-addOne = (1 + _)--named :: Int -> Int-named = (_ `sub` 1)--main = log "Done"
− examples/passing/ExportExplicit.purs 
@@ -1,10 +0,0 @@-module Main where
-
-import M1
-import Control.Monad.Eff.Console (log)
-
-testX = X
-testZ = Z
-testFoo = foo
-
-main = log "Done"
− examples/passing/ExportExplicit/M1.purs 
@@ -1,10 +0,0 @@-module M1 (X(X), Z(..), foo) where
-
-data X = X | Y
-data Z = Z
-
-foo :: Int
-foo = 0
-
-bar :: Int
-bar = 1
− examples/passing/ExportExplicit2.purs 
@@ -1,8 +0,0 @@-module Main where
-
-import M1
-import Control.Monad.Eff.Console (log)
-
-testBar = bar
-
-main = log "Done"
− examples/passing/ExportExplicit2/M1.purs 
@@ -1,7 +0,0 @@-module M1 (bar) where
-
-foo :: Int
-foo = 0
-
-bar :: Int
-bar = foo
− examples/passing/ExportedInstanceDeclarations.purs 
@@ -1,45 +0,0 @@--- Tests that instances for non-exported classes / types do not appear in the--- result of `exportedDeclarations`.-module Main-  ( Const(..)-  , class Foo-  , foo-  , main-  ) where--import Prelude-import Control.Monad.Eff.Console (log)--data Const a b = Const a--class Foo a where-  foo :: a--data NonexportedType = NonexportedType--class NonexportedClass a where-  notExported :: a---- There are three places that a nonexported type or type class can occur,--- leading an instance to count as non-exported:---  * Constraints---  * The type class itself---  * The instance types---- Case 1: constraints-instance nonExportedFoo :: (NonexportedClass a) => Foo a where-  foo = notExported---- Another instance of case 1:-instance nonExportedFoo2 :: (Foo NonexportedType) => Foo (a -> a) where-  foo = id---- Case 2: type class-instance nonExportedNonexportedType :: NonexportedClass (Const Int a) where-  notExported = Const 0---- Case 3: instance types-instance constFoo :: Foo (Const NonexportedType b) where-  foo = Const NonexportedType--main = log "Done"
− examples/passing/ExtendedInfixOperators.purs 
@@ -1,17 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log, logShow)-import Data.Function (on)--comparing :: forall a b. Ord b => (a -> b) -> a -> a -> Ordering-comparing f = compare `on` f--null [] = true-null _ = false--test = [1.0, 2.0, 3.0] `comparing null` [4.0, 5.0, 6.0]--main = do-  logShow test-  log "Done"
− examples/passing/Fib.purs 
@@ -1,18 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff (whileE)-import Control.Monad.Eff.Console (log, logShow)-import Control.Monad.ST (runST, newSTRef, readSTRef, writeSTRef)--main = do-  runST do-    n1 <- newSTRef 1.0-    n2 <- newSTRef 1.0-    whileE ((>) 1000.0 <$> readSTRef n1) $ do-      n1' <- readSTRef n1-      n2' <- readSTRef n2-      _ <- writeSTRef n2 $ n1' + n2'-      _ <- writeSTRef n1 n2'-      logShow n2'-  log "Done"
− examples/passing/FieldConsPuns.purs 
@@ -1,13 +0,0 @@-module Main where
-
-import Prelude
-import Control.Monad.Eff.Console (log, logShow)
-
-greet { greeting, name } = log $ greeting <> ", " <> name <> "."
-
-main = do
-  greet { greeting, name }
-  log "Done"
-  where
-  greeting = "Hello"
-  name = "World"
− examples/passing/FieldPuns.purs 
@@ -1,10 +0,0 @@-module Main where
-
-import Prelude
-import Control.Monad.Eff.Console
-
-greet { greeting, name } = log $ greeting <> ", " <> name <> "."
-
-main = do
-  greet { greeting: "Hello", name: "World" }
-  log "Done"
− examples/passing/FinalTagless.purs 
@@ -1,25 +0,0 @@-module Main where--import Prelude hiding (add)-import Control.Monad.Eff.Console (log, logShow)--class E e where-  num :: Number -> e Number-  add :: e Number -> e Number -> e Number--type Expr a = forall e. E e => e a--data Id a = Id a--instance exprId :: E Id where-  num = Id-  add (Id n) (Id m) = Id (n + m)--runId (Id a) = a--three :: Expr Number-three = add (num 1.0) (num 2.0)--main = do-  logShow $ runId three-  log "Done"
− examples/passing/ForeignKind.purs 
@@ -1,10 +0,0 @@-module Main where--import Prelude-import ForeignKinds.Lib (kind Nat, Zero, Succ, N3, NatProxy, class AddNat, addNat, proxy1, proxy2)-import Control.Monad.Eff.Console (log)--proxy1Add2Is3 :: NatProxy N3-proxy1Add2Is3 = addNat proxy1 proxy2--main = log "Done"
− examples/passing/ForeignKind/Lib.purs 
@@ -1,60 +0,0 @@-module ForeignKinds.Lib (kind Nat, Kinded, Zero, Succ, N0, N1, N2, N3, NatProxy(..), class AddNat, addNat, proxy1, proxy2) where---- declaration--foreign import kind Nat---- use in foreign data--foreign import data Zero :: Nat-foreign import data Succ :: Nat -> Nat---- use in data--data NatProxy (t :: Nat) = NatProxy---- use in type sig--succProxy :: forall n. NatProxy n -> NatProxy (Succ n)-succProxy _ = NatProxy---- use in alias--type Kinded f = f :: Nat--type KindedZero = Kinded Zero--type N0 = Zero-type N1 = Succ N0-type N2 = Succ N1-type N3 = Succ N2---- use of alias--proxy0 :: NatProxy N0-proxy0 = NatProxy--proxy1 :: NatProxy N1-proxy1 = NatProxy--proxy2 :: NatProxy N2-proxy2 = NatProxy--proxy3 :: NatProxy N3-proxy3 = NatProxy---- use in class--class AddNat (l :: Nat) (r :: Nat) (o :: Nat) | l -> r o--instance addNatZero-  :: AddNat Zero r r--instance addNatSucc-  :: AddNat l r o-  => AddNat (Succ l) r (Succ o)---- use of class--addNat :: forall l r o. AddNat l r o => NatProxy l -> NatProxy r -> NatProxy o-addNat _ _ = NatProxy
− examples/passing/FunWithFunDeps.js 
@@ -1,32 +0,0 @@--//: forall e. FVect Z e-exports.fnil = [];--//: forall n e. e -> FVect n e -> FVect (S n) e-exports.fcons = function (hd) {-  return function (tl) {-    return [hd].concat(tl);-  };-};--exports.fappend = function (dict) {-  return function (left) {-    return function (right) {-      return left.concat(right);-    };-  };-};--exports.fflatten = function (dict) {-  return function (v) {-    var accRef = [];-    for (var indexRef = 0; indexRef < v.length; indexRef += 1) {-      accRef = accRef.concat(v[indexRef]);-    }-    return accRef;-  };-};--exports.ftoArray = function (vect) {-  return vect;-};
− examples/passing/FunWithFunDeps.purs 
@@ -1,41 +0,0 @@--- Taken from https://github.com/LiamGoodacre/purescript-fun-with-fundeps--module Main where--import Control.Monad.Eff.Console (log)---- Nat : Type-data Z-data S n--type S2 n = S (S n)-type S3 n = S (S2 n)-type S4 n = S (S3 n)-type S5 n = S (S4 n)-type S15 n = S5 (S5 (S5 n))--class NatPlus l r o | l r -> o-instance natPlusZ :: NatPlus Z r r-instance natPlusS :: (NatPlus l r o) => NatPlus (S l) r (S o)--class NatMult l r o | l r -> o-instance natMultZ :: NatMult Z n Z-instance natMultS :: (NatMult m n r, NatPlus n r s) => NatMult (S m) n s---- Foreign Vect-foreign import data FVect :: Type -> Type -> Type-foreign import fnil :: forall e. FVect Z e-foreign import fcons :: forall n e. e -> FVect n e -> FVect (S n) e-foreign import fappend :: forall l r o e. NatPlus l r o => FVect l e -> FVect r e -> FVect o e-foreign import fflatten :: forall f s t o. NatMult f s o => FVect f (FVect s t) -> FVect o t-foreign import ftoArray :: forall n e. FVect n e -> Array e---- should be able to figure these out-fsingleton x = fcons x fnil-fexample = fcons 1 (fsingleton 2) `fappend` fsingleton 3 `fappend` fcons 4 (fsingleton 5)-fexample2 = fexample `fappend` fexample `fappend` fexample-fexample3 = fsingleton fexample `fappend` fsingleton fexample `fappend` fsingleton fexample--fexample4 = fflatten fexample3--main = log "Done"
− examples/passing/FunctionScope.purs 
@@ -1,13 +0,0 @@-module Main where--import Prelude-import Test.Assert-import Control.Monad.Eff.Console (log)--mkValue :: Number -> Number-mkValue id = id--main = do-  let value = mkValue 1.0-  assert $ value == 1.0-  log "Done"
− examples/passing/FunctionalDependencies.purs 
@@ -1,21 +0,0 @@-module Main where--import Control.Monad.Eff.Console (log)--data Nil-data Cons x xs--class Append a b c | a b -> c--instance appendNil :: Append Nil b b--instance appendCons :: Append xs b c => Append (Cons x xs) b (Cons x c)--data Proxy a = Proxy--appendProxy :: forall a b c. Append a b c => Proxy a -> Proxy b -> Proxy c-appendProxy Proxy Proxy = Proxy--test = appendProxy (Proxy :: Proxy (Cons Int Nil)) (Proxy :: Proxy (Cons String Nil))--main = log "Done"
− examples/passing/Functions.purs 
@@ -1,12 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--test1 = \_ -> 0.0--test2 = \a b -> a + b + 1.0--test3 = \a -> a--main = log "Done"
− examples/passing/Functions2.purs 
@@ -1,13 +0,0 @@-module Main where--import Prelude-import Test.Assert-import Control.Monad.Eff.Console (log)--test :: forall a b. a -> b -> a-test = \const _ -> const--main = do-  let value = test "Done" {}-  assert' "Not done" $ value == "Done"-  log "Done"
− examples/passing/Generalization1.purs 
@@ -1,11 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (logShow, log)--main = do-  logShow (sum 1.0 2.0)-  logShow (sum 1 2)-  log "Done"--sum x y = x + y
− examples/passing/GenericsRep.purs 
@@ -1,63 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff (Eff)-import Control.Monad.Eff.Console (CONSOLE, log, logShow)-import Data.Generic.Rep (class Generic)-import Data.Generic.Rep.Eq (genericEq)--data X a = X a -	 -derive instance genericX :: Generic (X a) _--instance eqX :: Eq a => Eq (X a) where-  eq xs ys = genericEq xs ys--data Y a = Y | Z a (Y a)--derive instance genericY :: Generic (Y a) _--instance eqY :: Eq a => Eq (Y a) where-  eq xs ys = genericEq xs ys--data Z--derive instance genericZ :: Generic Z _--instance eqZ :: Eq Z where-  eq x y = genericEq x y--type MyString = String--newtype W = W { x :: Int, y :: MyString }--derive instance genericW :: Generic W _--instance eqW :: Eq W where-  eq x y = genericEq x y--data V = V { x :: Int } { x :: Int }- -derive instance genericV :: Generic V _--instance eqV :: Eq V where-  eq x y = genericEq x y--newtype U = U {}--derive instance genericU :: Generic U _--instance eqU :: Eq U where-  eq x y = genericEq x y--main :: Eff (console :: CONSOLE) Unit-main = do-  logShow (X 0 == X 1)-  logShow (X 1 == X 1)-  logShow (Z 1 Y == Z 1 Y)-  logShow (Z 1 Y == Y)-  logShow (Y == Y :: Y Z)-  logShow (W { x: 0, y: "A" } == W { x: 0, y: "A" })-  logShow (V { x: 0 } { x: 0 } == V { x: 0 } { x: 0 })-  logShow (U {} == U {})-  log "Done"
− examples/passing/Guards.purs 
@@ -1,64 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--collatz = \x -> case x of-  y | y `mod` 2.0 == 0.0 -> y / 2.0-  y -> y * 3.0 + 1.0---- Guards have access to current scope-collatz2 = \x y -> case x of-  z | y > 0.0 -> z / 2.0-  z -> z * 3.0 + 1.0--min :: forall a. Ord a => a -> a -> a-min n m | n < m     = n-        | otherwise = m--max :: forall a. Ord a => a -> a -> a-max n m = case unit of-  _ | m < n     -> n-    | otherwise -> m--testIndentation :: Number -> Number -> Number-testIndentation x y | x > 0.0-  = x + y-                    | otherwise-  = y - x---- pattern guard example with two clauses-clunky1 :: Int -> Int -> Int-clunky1 a b | x <- max a b-            , x > 5-            = x-clunky1 a _ = a--clunky2 :: Int -> Int -> Int-clunky2 a b | x <- max a b-            , x > 5-            = x-            | otherwise-            = a + b---- pattern guards on case epxressions-clunky_case1 :: Int -> Int -> Int-clunky_case1 a b =-  case unit of-    unit | x <- max a b-         , x > 5-         -> x-         | otherwise -> a + b---- test indentation-clunky_case2 :: Int -> Int -> Int-clunky_case2 a b =-  case unit of-    unit-      | x <- max a b-      , x > 5-      -> x-      | otherwise-      -> a + b--main = log $ min "Done" "ZZZZ"
− examples/passing/HasOwnProperty.purs 
@@ -1,5 +0,0 @@-module Main where--import Control.Monad.Eff.Console (log)--main = log ({hasOwnProperty: "Hi"} {hasOwnProperty = "Done"}).hasOwnProperty
− examples/passing/HoistError.purs 
@@ -1,12 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff-import Control.Monad.Eff.Console-import Test.Assert--main = do-  let x = 0.0-  assert $ x == 0.0-  let x = 1.0 + 1.0-  log "Done"
− examples/passing/IfThenElseMaybe.purs 
@@ -1,12 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--data Maybe a = Nothing | Just a--test1 = if true then Just 10 else Nothing--test2 = if true then Nothing else Just 10--main = log "Done"
− examples/passing/IfWildcard.purs 
@@ -1,19 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff (Eff)-import Control.Monad.Eff.Console (log, CONSOLE)--data Foo = X | Y--cond ∷ ∀ a. Boolean → a → a → a-cond = if _ then _ else _--what ∷ Boolean → Foo-what = if _ then X else Y--main :: forall e. Eff (console :: CONSOLE | e) Unit-main = do-  let tmp1 = what true-      tmp2 = cond true 0 1-  log "Done"
− examples/passing/ImplicitEmptyImport.purs 
@@ -1,9 +0,0 @@-module Main where--import Prelude-import Control.Monad.Eff.Console (log)--main = do-  log "Hello"-  log "Goodbye"-  log "Done"
− examples/passing/Import.purs 
@@ -1,6 +0,0 @@-module Main where
-
-import M2
-import Control.Monad.Eff.Console (log)
-
-main = log "Done"
− examples/passing/Import/M1.purs 
@@ -1,8 +0,0 @@-module M1 where
-
-import Prelude ()
-
-id :: forall a. a -> a
-id = \x -> x
-
-foo = id
− examples/passing/Import/M2.purs 
@@ -1,6 +0,0 @@-module M2 where
-
-import Prelude ()
-import M1
-
-main = \_ -> foo 42
− examples/passing/ImportExplicit.purs 
@@ -1,10 +0,0 @@-module Main where
-
-import M1 (X(..))
-import Control.Monad.Eff.Console (log)
-
-testX :: X
-testX = X
-testY = Y
-
-main = log "Done"
− examples/passing/ImportExplicit/M1.purs 
@@ -1,4 +0,0 @@-module M1 where
-
-data X = X | Y
-data Z = Z
− examples/passing/ImportHiding.purs 
@@ -1,19 +0,0 @@-module Main where--import Control.Monad.Eff.Console-import Prelude hiding (-  show, -- a value-  class Show, -- a type class-  Unit(..)  -- a constructor-  )--show = 1.0--class Show a where-  noshow :: a -> a--data Unit = X | Y--main = do-  logShow show-  log "Done"
− examples/passing/ImportQualified.purs

file too large to diff

− examples/passing/ImportQualified/M1.purs

file too large to diff

− examples/passing/InferRecFunWithConstrainedArgument.purs

file too large to diff

− examples/passing/InstanceBeforeClass.purs

file too large to diff

− examples/passing/InstanceSigs.purs

file too large to diff

− examples/passing/InstanceSigsGeneral.purs

file too large to diff

− examples/passing/IntAndChar.purs

file too large to diff

− examples/passing/JSReserved.purs

file too large to diff

− examples/passing/KindedType.purs

file too large to diff

− examples/passing/LargeSumType.purs

file too large to diff

− examples/passing/Let.purs

file too large to diff

− examples/passing/Let2.purs

file too large to diff

− examples/passing/LetInInstance.purs

file too large to diff

− examples/passing/LetPattern.purs

file too large to diff

− examples/passing/LiberalTypeSynonyms.purs

file too large to diff

− examples/passing/MPTCs.purs

file too large to diff

− examples/passing/Match.purs

file too large to diff

− examples/passing/Module.purs

file too large to diff

− examples/passing/Module/M1.purs

file too large to diff

− examples/passing/Module/M2.purs

file too large to diff

− examples/passing/ModuleDeps.purs

file too large to diff

− examples/passing/ModuleDeps/M1.purs

file too large to diff

− examples/passing/ModuleDeps/M2.purs

file too large to diff

− examples/passing/ModuleDeps/M3.purs

file too large to diff

− examples/passing/ModuleExport.purs

file too large to diff

− examples/passing/ModuleExport/A.purs

file too large to diff

− examples/passing/ModuleExportDupes.purs

file too large to diff

− examples/passing/ModuleExportDupes/A.purs

file too large to diff

− examples/passing/ModuleExportDupes/B.purs

file too large to diff

− examples/passing/ModuleExportDupes/C.purs

file too large to diff

− examples/passing/ModuleExportExcluded.purs

file too large to diff

− examples/passing/ModuleExportExcluded/A.purs

file too large to diff

− examples/passing/ModuleExportQualified.purs

file too large to diff

− examples/passing/ModuleExportQualified/A.purs

file too large to diff

− examples/passing/ModuleExportSelf.purs

file too large to diff

− examples/passing/ModuleExportSelf/A.purs

file too large to diff

− examples/passing/Monad.purs

file too large to diff

− examples/passing/MonadState.purs

file too large to diff

− examples/passing/MultiArgFunctions.purs

file too large to diff

− examples/passing/MutRec.purs

file too large to diff

− examples/passing/MutRec2.purs

file too large to diff

− examples/passing/MutRec3.purs

file too large to diff

− examples/passing/NakedConstraint.purs

file too large to diff

− examples/passing/NamedPatterns.purs

file too large to diff

− examples/passing/NegativeBinder.purs

file too large to diff

− examples/passing/NegativeIntInRange.purs

file too large to diff

− examples/passing/Nested.purs

file too large to diff

− examples/passing/NestedRecordUpdate.purs

file too large to diff

− examples/passing/NestedRecordUpdateWildcards.purs

file too large to diff

− examples/passing/NestedTypeSynonyms.purs

file too large to diff

− examples/passing/NestedWhere.purs

file too large to diff

− examples/passing/Newtype.purs

file too large to diff

− examples/passing/NewtypeClass.purs

file too large to diff

− examples/passing/NewtypeEff.purs

file too large to diff

− examples/passing/NewtypeInstance.purs

file too large to diff

− examples/passing/NewtypeWithRecordUpdate.purs

file too large to diff

− examples/passing/NonConflictingExports.purs

file too large to diff

− examples/passing/NonConflictingExports/A.purs

file too large to diff

− examples/passing/NonOrphanInstanceFunDepExtra.purs

file too large to diff

− examples/passing/NonOrphanInstanceFunDepExtra/Lib.purs

file too large to diff

− examples/passing/NonOrphanInstanceMulti.purs

file too large to diff

− examples/passing/NonOrphanInstanceMulti/Lib.purs

file too large to diff

− examples/passing/NumberLiterals.purs

file too large to diff

− examples/passing/ObjectGetter.purs

file too large to diff

− examples/passing/ObjectSynonym.purs

file too large to diff

− examples/passing/ObjectUpdate.purs

file too large to diff

− examples/passing/ObjectUpdate2.purs

file too large to diff

− examples/passing/ObjectUpdater.purs

file too large to diff

− examples/passing/ObjectWildcards.purs

file too large to diff

− examples/passing/Objects.purs

file too large to diff

− examples/passing/OneConstructor.purs

file too large to diff

− examples/passing/OperatorAlias.purs

file too large to diff

− examples/passing/OperatorAliasElsewhere.purs

file too large to diff

− examples/passing/OperatorAliasElsewhere/Def.purs

file too large to diff

− examples/passing/OperatorAssociativity.purs

file too large to diff

− examples/passing/OperatorInlining.purs

file too large to diff

− examples/passing/OperatorSections.purs

file too large to diff

− examples/passing/Operators.purs

file too large to diff

− examples/passing/Operators/Other.purs

file too large to diff

− examples/passing/OptimizerBug.purs

file too large to diff

− examples/passing/OptionalQualified.purs

file too large to diff

− examples/passing/OverlappingInstances.purs

file too large to diff

− examples/passing/OverlappingInstances2.purs

file too large to diff

− examples/passing/OverlappingInstances3.purs

file too large to diff

− examples/passing/ParensInType.purs

file too large to diff

− examples/passing/ParensInTypedBinder.purs

file too large to diff

− examples/passing/PartialFunction.purs

file too large to diff

− examples/passing/Patterns.purs

file too large to diff

− examples/passing/PendingConflictingImports.purs

file too large to diff

− examples/passing/PendingConflictingImports/A.purs

file too large to diff

− examples/passing/PendingConflictingImports/B.purs

file too large to diff

− examples/passing/PendingConflictingImports2.purs

file too large to diff

− examples/passing/PendingConflictingImports2/A.purs

file too large to diff

− examples/passing/Person.purs

file too large to diff

− examples/passing/PolyLabels.js

file too large to diff

− examples/passing/PolyLabels.purs

file too large to diff

− examples/passing/PrimedTypeName.purs

file too large to diff

− examples/passing/QualifiedNames.purs

file too large to diff

− examples/passing/QualifiedNames/Either.purs

file too large to diff

− examples/passing/QualifiedQualifiedImports.purs

file too large to diff

− examples/passing/Rank2Data.purs

file too large to diff

− examples/passing/Rank2Object.purs

file too large to diff

− examples/passing/Rank2TypeSynonym.purs

file too large to diff

− examples/passing/Rank2Types.purs

file too large to diff

− examples/passing/ReExportQualified.purs

file too large to diff

− examples/passing/ReExportQualified/A.purs

file too large to diff

− examples/passing/ReExportQualified/B.purs

file too large to diff

− examples/passing/ReExportQualified/C.purs

file too large to diff

− examples/passing/RebindableSyntax.purs

file too large to diff

− examples/passing/Recursion.purs

file too large to diff

− examples/passing/RedefinedFixity.purs

file too large to diff

− examples/passing/RedefinedFixity/M1.purs

file too large to diff

− examples/passing/RedefinedFixity/M2.purs

file too large to diff

− examples/passing/RedefinedFixity/M3.purs

file too large to diff

− examples/passing/ReservedWords.purs

file too large to diff

− examples/passing/ResolvableScopeConflict.purs

file too large to diff

− examples/passing/ResolvableScopeConflict/A.purs

file too large to diff

− examples/passing/ResolvableScopeConflict/B.purs

file too large to diff

− examples/passing/ResolvableScopeConflict2.purs

file too large to diff

− examples/passing/ResolvableScopeConflict2/A.purs

file too large to diff

− examples/passing/ResolvableScopeConflict3.purs

file too large to diff

− examples/passing/ResolvableScopeConflict3/A.purs

file too large to diff

− examples/passing/RowConstructors.purs

file too large to diff

− examples/passing/RowInInstanceHeadDetermined.purs

file too large to diff

− examples/passing/RowPolyInstanceContext.purs

file too large to diff

− examples/passing/RowUnion.js

file too large to diff

− examples/passing/RowUnion.purs

file too large to diff

− examples/passing/RowsInInstanceContext.purs

file too large to diff

− examples/passing/RuntimeScopeIssue.purs

file too large to diff

− examples/passing/ScopedTypeVariables.purs

file too large to diff

− examples/passing/Sequence.purs

file too large to diff

− examples/passing/SequenceDesugared.purs

file too large to diff

− examples/passing/ShadowedModuleName.purs

file too large to diff

− examples/passing/ShadowedModuleName/Test.purs

file too large to diff

− examples/passing/ShadowedName.purs

file too large to diff

− examples/passing/ShadowedRename.purs

file too large to diff

− examples/passing/ShadowedTCO.purs

file too large to diff

− examples/passing/ShadowedTCOLet.purs

file too large to diff

− examples/passing/SignedNumericLiterals.purs

file too large to diff

− examples/passing/SolvingAppendSymbol.purs

file too large to diff

− examples/passing/SolvingCompareSymbol.purs

file too large to diff

− examples/passing/SolvingIsSymbol.purs

file too large to diff

− examples/passing/SolvingIsSymbol/Lib.purs

file too large to diff

− examples/passing/Stream.purs

file too large to diff

− examples/passing/StringEdgeCases.purs

file too large to diff

− examples/passing/StringEdgeCases/Records.purs

file too large to diff

− examples/passing/StringEdgeCases/Symbols.purs

file too large to diff

− examples/passing/StringEscapes.purs

file too large to diff

− examples/passing/Superclasses1.purs

file too large to diff

− examples/passing/Superclasses3.purs

file too large to diff

− examples/passing/TCO.purs

file too large to diff

− examples/passing/TCOCase.purs

file too large to diff

− examples/passing/TailCall.purs

file too large to diff

− examples/passing/Tick.purs

file too large to diff

− examples/passing/TopLevelCase.purs

file too large to diff

− examples/passing/TransitiveImport.purs

file too large to diff

− examples/passing/TransitiveImport/Middle.purs

file too large to diff

− examples/passing/TransitiveImport/Test.purs

file too large to diff

− examples/passing/TypeClassMemberOrderChange.purs

file too large to diff

− examples/passing/TypeClasses.purs

file too large to diff

− examples/passing/TypeClassesInOrder.purs

file too large to diff

− examples/passing/TypeClassesWithOverlappingTypeVariables.purs

file too large to diff

− examples/passing/TypeDecl.purs

file too large to diff

− examples/passing/TypeOperators.purs

file too large to diff

− examples/passing/TypeOperators/A.purs

file too large to diff

− examples/passing/TypeSynonymInData.purs

file too large to diff

− examples/passing/TypeSynonyms.purs

file too large to diff

− examples/passing/TypeWildcards.purs

file too large to diff

− examples/passing/TypeWildcardsRecordExtension.purs

file too large to diff

− examples/passing/TypeWithoutParens.purs

file too large to diff

− examples/passing/TypeWithoutParens/Lib.purs

file too large to diff

− examples/passing/TypedBinders.purs

file too large to diff

− examples/passing/TypedWhere.purs

file too large to diff

− examples/passing/UTF8Sourcefile.purs

file too large to diff

− examples/passing/UnderscoreIdent.purs

file too large to diff

− examples/passing/UnicodeIdentifier.purs

file too large to diff

− examples/passing/UnicodeOperators.purs

file too large to diff

− examples/passing/UnicodeType.purs

file too large to diff

− examples/passing/UnifyInTypeInstanceLookup.purs

file too large to diff

− examples/passing/Unit.purs

file too large to diff

− examples/passing/UnknownInTypeClassLookup.purs

file too large to diff

− examples/passing/UnsafeCoerce.purs

file too large to diff

− examples/passing/UntupledConstraints.purs

file too large to diff

− examples/passing/UsableTypeClassMethods.purs

file too large to diff

− examples/passing/Where.purs

file too large to diff

− examples/passing/WildcardInInstance.purs

file too large to diff

− examples/passing/WildcardType.purs

file too large to diff

− examples/passing/iota.purs

file too large to diff

− examples/passing/s.purs

file too large to diff

− examples/psci/BasicEval.purs

file too large to diff

− examples/psci/Multiline.purs

file too large to diff

− examples/warning/2140.purs

file too large to diff

− examples/warning/2383.purs

file too large to diff

− examples/warning/2411.purs

file too large to diff

− examples/warning/2542.purs

file too large to diff

− examples/warning/CustomWarning.purs

file too large to diff

− examples/warning/CustomWarning2.purs

file too large to diff

− examples/warning/CustomWarning3.purs

file too large to diff

− examples/warning/DuplicateExportRef.purs

file too large to diff

− examples/warning/DuplicateImport.purs

file too large to diff

− examples/warning/DuplicateImportRef.purs

file too large to diff

− examples/warning/DuplicateSelectiveImport.purs

file too large to diff

− examples/warning/HidingImport.purs

file too large to diff

− examples/warning/ImplicitImport.purs

file too large to diff

− examples/warning/ImplicitQualifiedImport.purs

file too large to diff

− examples/warning/MissingTypeDeclaration.purs

file too large to diff

− examples/warning/NewtypeInstance.purs

file too large to diff

− examples/warning/NewtypeInstance2.purs

file too large to diff

− examples/warning/NewtypeInstance3.purs

file too large to diff

− examples/warning/NewtypeInstance4.purs

file too large to diff

− examples/warning/OverlappingInstances.purs

file too large to diff

− examples/warning/OverlappingPattern.purs

file too large to diff

− examples/warning/ScopeShadowing.purs

file too large to diff

− examples/warning/ShadowedBinderPatternGuard.purs

file too large to diff

− examples/warning/ShadowedNameParens.purs

file too large to diff

− examples/warning/ShadowedTypeVar.purs

file too large to diff

− examples/warning/UnnecessaryFFIModule.js

file too large to diff

− examples/warning/UnnecessaryFFIModule.purs

file too large to diff

− examples/warning/UnusedDctorExplicitImport.purs

file too large to diff

− examples/warning/UnusedDctorImportAll.purs

file too large to diff

− examples/warning/UnusedDctorImportExplicit.purs

file too large to diff

− examples/warning/UnusedExplicitImport.purs

file too large to diff

− examples/warning/UnusedExplicitImportTypeOp.purs

file too large to diff

− examples/warning/UnusedExplicitImportTypeOp/Lib.purs

file too large to diff

− examples/warning/UnusedExplicitImportValOp.purs

file too large to diff

− examples/warning/UnusedFFIImplementations.js

file too large to diff

− examples/warning/UnusedFFIImplementations.purs

file too large to diff

− examples/warning/UnusedImport.purs

file too large to diff

− examples/warning/UnusedTypeVar.purs

file too large to diff

− examples/warning/WildcardInferredType.purs

file too large to diff

purescript.cabal view

file too large to diff

src/Language/PureScript/AST/Binders.hs view

file too large to diff

src/Language/PureScript/AST/Declarations.hs view

file too large to diff

src/Language/PureScript/AST/Exported.hs view

file too large to diff

src/Language/PureScript/AST/SourcePos.hs view

file too large to diff

src/Language/PureScript/AST/Traversals.hs view

file too large to diff

src/Language/PureScript/Bundle.hs view

file too large to diff

src/Language/PureScript/CodeGen/JS.hs view

file too large to diff

src/Language/PureScript/CodeGen/JS/Common.hs view

file too large to diff

src/Language/PureScript/Constants.hs view

file too large to diff

src/Language/PureScript/CoreFn.hs view

file too large to diff

src/Language/PureScript/CoreFn/Desugar.hs view

file too large to diff

+ src/Language/PureScript/CoreFn/FromJSON.hs view

file too large to diff

src/Language/PureScript/CoreFn/Meta.hs view

file too large to diff

src/Language/PureScript/CoreFn/Module.hs view

file too large to diff

+ src/Language/PureScript/CoreFn/Optimizer.hs view

file too large to diff

src/Language/PureScript/CoreFn/ToJSON.hs view

file too large to diff

src/Language/PureScript/CoreImp/Optimizer.hs view

file too large to diff

src/Language/PureScript/CoreImp/Optimizer/Inliner.hs view

file too large to diff

src/Language/PureScript/CoreImp/Optimizer/MagicDo.hs view

file too large to diff

src/Language/PureScript/CoreImp/Optimizer/Unused.hs view

file too large to diff

src/Language/PureScript/Docs.hs view

file too large to diff

src/Language/PureScript/Docs/Convert.hs view

file too large to diff

src/Language/PureScript/Docs/Convert/ReExports.hs view

file too large to diff

src/Language/PureScript/Docs/Convert/Single.hs view

file too large to diff

src/Language/PureScript/Docs/ParseInPackage.hs view

file too large to diff

src/Language/PureScript/Docs/Prim.hs view

file too large to diff

src/Language/PureScript/Docs/Render.hs view

file too large to diff

+ src/Language/PureScript/Docs/Tags.hs view

file too large to diff

src/Language/PureScript/Docs/Types.hs view

file too large to diff

src/Language/PureScript/Environment.hs view

file too large to diff

src/Language/PureScript/Errors.hs view

file too large to diff

src/Language/PureScript/Errors/JSON.hs view

file too large to diff

src/Language/PureScript/Externs.hs view

file too large to diff

src/Language/PureScript/Ide.hs view

file too large to diff

src/Language/PureScript/Ide/CaseSplit.hs view

file too large to diff

src/Language/PureScript/Ide/Command.hs view

file too large to diff

src/Language/PureScript/Ide/Imports.hs view

file too large to diff

src/Language/PureScript/Ide/Prim.hs view

file too large to diff

− src/Language/PureScript/Ide/Pursuit.hs

file too large to diff

src/Language/PureScript/Ide/Rebuild.hs view

file too large to diff

src/Language/PureScript/Ide/SourceFile.hs view

file too large to diff

src/Language/PureScript/Ide/State.hs view

file too large to diff

src/Language/PureScript/Ide/Types.hs view

file too large to diff

+ src/Language/PureScript/Ide/Usage.hs view

file too large to diff

src/Language/PureScript/Ide/Util.hs view

file too large to diff

src/Language/PureScript/Interactive.hs view

file too large to diff

src/Language/PureScript/Interactive/Completion.hs view

file too large to diff

src/Language/PureScript/Interactive/Module.hs view

file too large to diff

src/Language/PureScript/Interactive/Parser.hs view

file too large to diff

src/Language/PureScript/Interactive/Types.hs view

file too large to diff

src/Language/PureScript/Kinds.hs view

file too large to diff

src/Language/PureScript/Linter.hs view

file too large to diff

src/Language/PureScript/Linter/Exhaustive.hs view

file too large to diff

src/Language/PureScript/Linter/Imports.hs view

file too large to diff

src/Language/PureScript/Make.hs view

file too large to diff

+ src/Language/PureScript/Make/Actions.hs view

file too large to diff

+ src/Language/PureScript/Make/BuildPlan.hs view

file too large to diff

+ src/Language/PureScript/Make/Monad.hs view

file too large to diff

src/Language/PureScript/ModuleDependencies.hs view

file too large to diff

src/Language/PureScript/Names.hs view

file too large to diff

src/Language/PureScript/Options.hs view

file too large to diff

src/Language/PureScript/Parser/Common.hs view

file too large to diff

src/Language/PureScript/Parser/Declarations.hs view

file too large to diff

src/Language/PureScript/Parser/Lexer.hs view

file too large to diff

src/Language/PureScript/Pretty/Values.hs view

file too large to diff

src/Language/PureScript/Publish.hs view

file too large to diff

src/Language/PureScript/Renamer.hs view

file too large to diff

src/Language/PureScript/Sugar.hs view

file too large to diff

+ src/Language/PureScript/Sugar/AdoNotation.hs view

file too large to diff

src/Language/PureScript/Sugar/BindingGroups.hs view

file too large to diff

src/Language/PureScript/Sugar/CaseDeclarations.hs view

file too large to diff

src/Language/PureScript/Sugar/DoNotation.hs view

file too large to diff

src/Language/PureScript/Sugar/LetPattern.hs view

file too large to diff

src/Language/PureScript/Sugar/Names.hs view

file too large to diff

src/Language/PureScript/Sugar/Names/Env.hs view

file too large to diff

src/Language/PureScript/Sugar/Names/Exports.hs view

file too large to diff

src/Language/PureScript/Sugar/Names/Imports.hs view

file too large to diff

src/Language/PureScript/Sugar/ObjectWildcards.hs view

file too large to diff

src/Language/PureScript/Sugar/Operators.hs view

file too large to diff

src/Language/PureScript/Sugar/Operators/Binders.hs view

file too large to diff

src/Language/PureScript/Sugar/Operators/Common.hs view

file too large to diff

src/Language/PureScript/Sugar/Operators/Expr.hs view

file too large to diff

src/Language/PureScript/Sugar/Operators/Types.hs view

file too large to diff

src/Language/PureScript/Sugar/TypeClasses.hs view

file too large to diff

src/Language/PureScript/Sugar/TypeClasses/Deriving.hs view

file too large to diff

src/Language/PureScript/Sugar/TypeDeclarations.hs view

file too large to diff

src/Language/PureScript/TypeChecker.hs view

file too large to diff

src/Language/PureScript/TypeChecker/Entailment.hs view

file too large to diff

src/Language/PureScript/TypeChecker/Monad.hs view

file too large to diff

src/Language/PureScript/TypeChecker/Skolems.hs view

file too large to diff

src/Language/PureScript/TypeChecker/TypeSearch.hs view

file too large to diff

src/Language/PureScript/TypeChecker/Types.hs view

file too large to diff

src/Language/PureScript/TypeClassDictionaries.hs view

file too large to diff

stack.yaml view

file too large to diff

tests/Language/PureScript/Ide/ImportsSpec.hs view

file too large to diff

tests/Language/PureScript/Ide/StateSpec.hs view

file too large to diff

tests/Language/PureScript/Ide/Test.hs view

file too large to diff

+ tests/Language/PureScript/Ide/UsageSpec.hs view

file too large to diff

tests/Main.hs view

file too large to diff

tests/TestCompiler.hs view

file too large to diff

+ tests/TestCoreFn.hs view

file too large to diff

tests/TestDocs.hs view

file too large to diff

tests/TestHierarchy.hs view

file too large to diff

+ tests/TestIde.hs view

file too large to diff

tests/TestPrimDocs.hs view

file too large to diff

− tests/TestPscIde.hs

file too large to diff

tests/TestPscPublish.hs view

file too large to diff

tests/TestPsci.hs view

file too large to diff

tests/TestPsci/CommandTest.hs view

file too large to diff

tests/TestPsci/CompletionTest.hs view

file too large to diff

tests/TestPsci/EvalTest.hs view

file too large to diff

tests/TestPsci/TestEnv.hs view

file too large to diff

+ tests/purs/docs/bower.json view

file too large to diff

+ tests/purs/docs/bower_components/purescript-prelude/src/Prelude.purs view

file too large to diff

+ tests/purs/docs/output/ConstrainedArgument/externs.json view

file too large to diff

+ tests/purs/docs/output/ConstrainedArgument/index.js view

file too large to diff

+ tests/purs/docs/resolutions.json view

file too large to diff

+ tests/purs/docs/src/ChildDeclOrder.purs view

file too large to diff

+ tests/purs/docs/src/Clash.purs view

file too large to diff

+ tests/purs/docs/src/Clash1.purs view

file too large to diff

+ tests/purs/docs/src/Clash1a.purs view

file too large to diff

+ tests/purs/docs/src/Clash2.purs view

file too large to diff

+ tests/purs/docs/src/Clash2a.purs view

file too large to diff

+ tests/purs/docs/src/ConstrainedArgument.purs view

file too large to diff

+ tests/purs/docs/src/DeclOrder.purs view

file too large to diff

+ tests/purs/docs/src/DeclOrderNoExportList.purs view

file too large to diff

+ tests/purs/docs/src/Desugar.purs view

file too large to diff

+ tests/purs/docs/src/DocComments.purs view

file too large to diff

+ tests/purs/docs/src/DuplicateNames.purs view

file too large to diff

+ tests/purs/docs/src/Example.purs view

file too large to diff

+ tests/purs/docs/src/Example2.purs view

file too large to diff

+ tests/purs/docs/src/ExplicitExport.purs view

file too large to diff

+ tests/purs/docs/src/ExplicitTypeSignatures.purs view

file too large to diff

+ tests/purs/docs/src/ImportedTwice.purs view

file too large to diff

+ tests/purs/docs/src/ImportedTwiceA.purs view

file too large to diff

+ tests/purs/docs/src/ImportedTwiceB.purs view

file too large to diff

+ tests/purs/docs/src/MultiVirtual.purs view

file too large to diff

+ tests/purs/docs/src/MultiVirtual1.purs view

file too large to diff

+ tests/purs/docs/src/MultiVirtual2.purs view

file too large to diff

+ tests/purs/docs/src/MultiVirtual3.purs view

file too large to diff

+ tests/purs/docs/src/NewOperators.purs view

file too large to diff

+ tests/purs/docs/src/NewOperators2.purs view

file too large to diff

+ tests/purs/docs/src/NotAllCtors.purs view

file too large to diff

+ tests/purs/docs/src/PrimSubmodules.purs view

file too large to diff

+ tests/purs/docs/src/ReExportedTypeClass.purs view

file too large to diff

+ tests/purs/docs/src/SolitaryTypeClassMember.purs view

file too large to diff

+ tests/purs/docs/src/SomeTypeClass.purs view

file too large to diff

+ tests/purs/docs/src/Transitive1.purs view

file too large to diff

+ tests/purs/docs/src/Transitive2.purs view

file too large to diff

+ tests/purs/docs/src/Transitive3.purs view

file too large to diff

+ tests/purs/docs/src/TypeClassWithFunDeps.purs view

file too large to diff

+ tests/purs/docs/src/TypeClassWithoutMembers.purs view

file too large to diff

+ tests/purs/docs/src/TypeClassWithoutMembersIntermediate.purs view

file too large to diff

+ tests/purs/docs/src/TypeLevelString.purs view

file too large to diff

+ tests/purs/docs/src/TypeOpAliases.purs view

file too large to diff

+ tests/purs/docs/src/UTF8.purs view

file too large to diff

+ tests/purs/docs/src/Virtual.purs view

file too large to diff

+ tests/purs/failing/1071.purs view

file too large to diff

+ tests/purs/failing/1169.purs view

file too large to diff

+ tests/purs/failing/1175.purs view

file too large to diff

+ tests/purs/failing/1310.purs view

file too large to diff

+ tests/purs/failing/1570.purs view

file too large to diff

+ tests/purs/failing/1733.purs view

file too large to diff

+ tests/purs/failing/1733/Thingy.purs view

file too large to diff

+ tests/purs/failing/1825.purs view

file too large to diff

+ tests/purs/failing/1881.purs view

file too large to diff

+ tests/purs/failing/2128-class.purs view

file too large to diff

+ tests/purs/failing/2128-instance.purs view

file too large to diff

+ tests/purs/failing/2197-shouldFail.purs view

file too large to diff

+ tests/purs/failing/2197-shouldFail2.purs view

file too large to diff

+ tests/purs/failing/2378.purs view

file too large to diff

+ tests/purs/failing/2378/Lib.purs view

file too large to diff

+ tests/purs/failing/2379.purs view

file too large to diff

+ tests/purs/failing/2379/Lib.purs view

file too large to diff

+ tests/purs/failing/2434.purs view

file too large to diff

+ tests/purs/failing/2534.purs view

file too large to diff

+ tests/purs/failing/2542.purs view

file too large to diff

+ tests/purs/failing/2567.purs view

file too large to diff

+ tests/purs/failing/2601.purs view

file too large to diff

+ tests/purs/failing/2616.purs view

file too large to diff

+ tests/purs/failing/2806.purs view

file too large to diff

+ tests/purs/failing/2874-forall.purs view

file too large to diff

+ tests/purs/failing/2874-forall2.purs view

file too large to diff

+ tests/purs/failing/2874-wildcard.purs view

file too large to diff

+ tests/purs/failing/2947.purs view

file too large to diff

+ tests/purs/failing/3132.purs view

file too large to diff

+ tests/purs/failing/3275-BindingGroupErrorPos.purs view

file too large to diff

+ tests/purs/failing/3275-DataBindingGroupErrorPos.purs view

file too large to diff

+ tests/purs/failing/3335-TypeOpAssociativityError.purs view

file too large to diff

+ tests/purs/failing/365.purs view

file too large to diff

+ tests/purs/failing/438.purs view

file too large to diff

+ tests/purs/failing/881.purs view

file too large to diff

+ tests/purs/failing/AnonArgument1.purs view

file too large to diff

+ tests/purs/failing/AnonArgument2.purs view

file too large to diff

+ tests/purs/failing/AnonArgument3.purs view

file too large to diff

+ tests/purs/failing/ArgLengthMismatch.purs view

file too large to diff

+ tests/purs/failing/ArrayType.purs view

file too large to diff

+ tests/purs/failing/Arrays.purs view

file too large to diff

+ tests/purs/failing/BindInDo-2.purs view

file too large to diff

+ tests/purs/failing/BindInDo.purs view

file too large to diff

+ tests/purs/failing/CannotDeriveNewtypeForData.purs view

file too large to diff

+ tests/purs/failing/CaseBinderLengthsDiffer.purs view

file too large to diff

+ tests/purs/failing/CaseDoesNotMatchAllConstructorArgs.purs view

file too large to diff

+ tests/purs/failing/ConflictingExports.purs view

file too large to diff

+ tests/purs/failing/ConflictingExports/A.purs view

file too large to diff

+ tests/purs/failing/ConflictingExports/B.purs view

file too large to diff

+ tests/purs/failing/ConflictingImports.purs view

file too large to diff

+ tests/purs/failing/ConflictingImports/A.purs view

file too large to diff

+ tests/purs/failing/ConflictingImports/B.purs view

file too large to diff

+ tests/purs/failing/ConflictingImports2.purs view

file too large to diff

+ tests/purs/failing/ConflictingImports2/A.purs view

file too large to diff

+ tests/purs/failing/ConflictingImports2/B.purs view

file too large to diff

+ tests/purs/failing/ConflictingQualifiedImports.purs view

file too large to diff

+ tests/purs/failing/ConflictingQualifiedImports/A.purs view

file too large to diff

+ tests/purs/failing/ConflictingQualifiedImports/B.purs view

file too large to diff

+ tests/purs/failing/ConflictingQualifiedImports2.purs view

file too large to diff

+ tests/purs/failing/ConflictingQualifiedImports2/A.purs view

file too large to diff

+ tests/purs/failing/ConflictingQualifiedImports2/B.purs view

file too large to diff

+ tests/purs/failing/ConstraintFailure.purs view

file too large to diff

+ tests/purs/failing/ConstraintInference.purs view

file too large to diff

+ tests/purs/failing/DctorOperatorAliasExport.purs view

file too large to diff

+ tests/purs/failing/DeclConflictClassCtor.purs view

file too large to diff

+ tests/purs/failing/DeclConflictClassSynonym.purs view

file too large to diff

+ tests/purs/failing/DeclConflictClassType.purs view

file too large to diff

+ tests/purs/failing/DeclConflictCtorClass.purs view

file too large to diff

+ tests/purs/failing/DeclConflictCtorCtor.purs view

file too large to diff

+ tests/purs/failing/DeclConflictDuplicateCtor.purs view

file too large to diff

+ tests/purs/failing/DeclConflictSynonymClass.purs view

file too large to diff

+ tests/purs/failing/DeclConflictSynonymType.purs view

file too large to diff

+ tests/purs/failing/DeclConflictTypeClass.purs view

file too large to diff

+ tests/purs/failing/DeclConflictTypeSynonym.purs view

file too large to diff

+ tests/purs/failing/DeclConflictTypeType.purs view

file too large to diff

+ tests/purs/failing/DiffKindsSameName.purs view

file too large to diff

+ tests/purs/failing/DiffKindsSameName/LibA.purs view

file too large to diff

+ tests/purs/failing/DiffKindsSameName/LibB.purs view

file too large to diff

+ tests/purs/failing/Do.purs view

file too large to diff

+ tests/purs/failing/DoNotSuggestComposition.purs view

file too large to diff

+ tests/purs/failing/DoNotSuggestComposition2.purs view

file too large to diff

+ tests/purs/failing/DuplicateDeclarationsInLet.purs view

file too large to diff

+ tests/purs/failing/DuplicateInstance.purs view

file too large to diff

+ tests/purs/failing/DuplicateModule.purs view

file too large to diff

+ tests/purs/failing/DuplicateModule/M1.purs view

file too large to diff

+ tests/purs/failing/DuplicateProperties.purs view

file too large to diff

+ tests/purs/failing/DuplicateTypeClass.purs view

file too large to diff

+ tests/purs/failing/DuplicateTypeVars.purs view

file too large to diff

+ tests/purs/failing/EmptyCase.purs view

file too large to diff

+ tests/purs/failing/EmptyClass.purs view

file too large to diff

+ tests/purs/failing/EmptyDo.purs view

file too large to diff

+ tests/purs/failing/ExpectedWildcard.purs view

file too large to diff

+ tests/purs/failing/ExportConflictClass.purs view

file too large to diff

+ tests/purs/failing/ExportConflictClass/A.purs view

file too large to diff

+ tests/purs/failing/ExportConflictClass/B.purs view

file too large to diff

+ tests/purs/failing/ExportConflictCtor.purs view

file too large to diff

+ tests/purs/failing/ExportConflictCtor/A.purs view

file too large to diff

+ tests/purs/failing/ExportConflictCtor/B.purs view

file too large to diff

+ tests/purs/failing/ExportConflictType.purs view

file too large to diff

+ tests/purs/failing/ExportConflictType/A.purs view

file too large to diff

+ tests/purs/failing/ExportConflictType/B.purs view

file too large to diff

+ tests/purs/failing/ExportConflictTypeOp.purs view

file too large to diff

+ tests/purs/failing/ExportConflictTypeOp/A.purs view

file too large to diff

+ tests/purs/failing/ExportConflictTypeOp/B.purs view

file too large to diff

+ tests/purs/failing/ExportConflictValue.purs view

file too large to diff

+ tests/purs/failing/ExportConflictValue/A.purs view

file too large to diff

+ tests/purs/failing/ExportConflictValue/B.purs view

file too large to diff

+ tests/purs/failing/ExportConflictValueOp.purs view

file too large to diff

+ tests/purs/failing/ExportConflictValueOp/A.purs view

file too large to diff

+ tests/purs/failing/ExportConflictValueOp/B.purs view

file too large to diff

+ tests/purs/failing/ExportExplicit.purs view

file too large to diff

+ tests/purs/failing/ExportExplicit1.purs view

file too large to diff

+ tests/purs/failing/ExportExplicit1/M1.purs view

file too large to diff

+ tests/purs/failing/ExportExplicit2.purs view

file too large to diff

+ tests/purs/failing/ExportExplicit3.purs view

file too large to diff

+ tests/purs/failing/ExportExplicit3/M1.purs view

file too large to diff

+ tests/purs/failing/ExtraRecordField.purs view

file too large to diff

+ tests/purs/failing/ExtraneousClassMember.purs view

file too large to diff

+ tests/purs/failing/Foldable.purs view

file too large to diff

+ tests/purs/failing/Generalization1.purs view

file too large to diff

+ tests/purs/failing/Generalization2.purs view

file too large to diff

+ tests/purs/failing/ImportExplicit.purs view

file too large to diff

+ tests/purs/failing/ImportExplicit/M1.purs view

file too large to diff

+ tests/purs/failing/ImportExplicit2.purs view

file too large to diff

+ tests/purs/failing/ImportExplicit2/M1.purs view

file too large to diff

+ tests/purs/failing/ImportHidingModule.purs view

file too large to diff

+ tests/purs/failing/ImportHidingModule/A.purs view

file too large to diff

+ tests/purs/failing/ImportHidingModule/B.purs view

file too large to diff

+ tests/purs/failing/ImportModule.purs view

file too large to diff

+ tests/purs/failing/ImportModule/M2.purs view

file too large to diff

+ tests/purs/failing/InfiniteKind.purs view

file too large to diff

+ tests/purs/failing/InfiniteKind2.purs view

file too large to diff

+ tests/purs/failing/InfiniteType.purs view

file too large to diff

+ tests/purs/failing/InstanceChainBothUnknownAndMatch.purs view

file too large to diff

+ tests/purs/failing/InstanceChainSkolemUnknownMatch.purs view

file too large to diff

+ tests/purs/failing/InstanceExport.purs view

file too large to diff

+ tests/purs/failing/InstanceExport/InstanceExport.purs view

file too large to diff

+ tests/purs/failing/InstanceSigsBodyIncorrect.purs view

file too large to diff

+ tests/purs/failing/InstanceSigsDifferentTypes.purs view

file too large to diff

+ tests/purs/failing/InstanceSigsIncorrectType.purs view

file too large to diff

+ tests/purs/failing/InstanceSigsOrphanTypeDeclaration.purs view

file too large to diff

+ tests/purs/failing/IntOutOfRange.purs view

file too large to diff

+ tests/purs/failing/InvalidDerivedInstance.purs view

file too large to diff

+ tests/purs/failing/InvalidDerivedInstance2.purs view

file too large to diff

+ tests/purs/failing/InvalidOperatorInBinder.purs view

file too large to diff

+ tests/purs/failing/KindError.purs view

file too large to diff

+ tests/purs/failing/KindStar.purs view

file too large to diff

+ tests/purs/failing/LacksWithSubGoal.purs view

file too large to diff

+ tests/purs/failing/LeadingZeros1.purs view

file too large to diff

+ tests/purs/failing/LeadingZeros2.purs view

file too large to diff

+ tests/purs/failing/Let.purs view

file too large to diff

+ tests/purs/failing/LetPatterns1.purs view

file too large to diff

+ tests/purs/failing/LetPatterns2.purs view

file too large to diff

+ tests/purs/failing/LetPatterns3.purs view

file too large to diff

+ tests/purs/failing/LetPatterns4.purs view

file too large to diff

+ tests/purs/failing/MPTCs.purs view

file too large to diff

+ tests/purs/failing/MissingClassExport.purs view

file too large to diff

+ tests/purs/failing/MissingClassMember.purs view

file too large to diff

+ tests/purs/failing/MissingClassMemberExport.purs view

file too large to diff

+ tests/purs/failing/MissingFFIImplementations.js view

file too large to diff

+ tests/purs/failing/MissingFFIImplementations.purs view

file too large to diff

+ tests/purs/failing/MissingRecordField.purs view

file too large to diff

+ tests/purs/failing/MixedAssociativityError.purs view

file too large to diff

+ tests/purs/failing/MultipleErrors.purs view

file too large to diff

+ tests/purs/failing/MultipleErrors2.purs view

file too large to diff

+ tests/purs/failing/MultipleTypeOpFixities.purs view

file too large to diff

+ tests/purs/failing/MultipleValueOpFixities.purs view

file too large to diff

+ tests/purs/failing/MutRec.purs view

file too large to diff

+ tests/purs/failing/MutRec2.purs view

file too large to diff

+ tests/purs/failing/NewtypeInstance.purs view

file too large to diff

+ tests/purs/failing/NewtypeInstance2.purs view

file too large to diff

+ tests/purs/failing/NewtypeInstance3.purs view

file too large to diff

+ tests/purs/failing/NewtypeInstance4.purs view

file too large to diff

+ tests/purs/failing/NewtypeInstance5.purs view

file too large to diff

+ tests/purs/failing/NewtypeInstance6.purs view

file too large to diff

+ tests/purs/failing/NewtypeMultiArgs.purs view

file too large to diff

+ tests/purs/failing/NewtypeMultiCtor.purs view

file too large to diff

+ tests/purs/failing/NonAssociativeError.purs view

file too large to diff

+ tests/purs/failing/NonExhaustivePatGuard.purs view

file too large to diff

+ tests/purs/failing/NullaryAbs.purs view

file too large to diff

+ tests/purs/failing/Object.purs view

file too large to diff

+ tests/purs/failing/OperatorAliasNoExport.purs view

file too large to diff

+ tests/purs/failing/OperatorSections.purs view

file too large to diff

+ tests/purs/failing/OrphanInstance.purs view

file too large to diff

+ tests/purs/failing/OrphanInstance/Class.purs view

file too large to diff

+ tests/purs/failing/OrphanInstanceFunDepCycle.purs view

file too large to diff

+ tests/purs/failing/OrphanInstanceFunDepCycle/Lib.purs view

file too large to diff

+ tests/purs/failing/OrphanInstanceNullary.purs view

file too large to diff

+ tests/purs/failing/OrphanInstanceNullary/Lib.purs view

file too large to diff

+ tests/purs/failing/OrphanInstanceWithDetermined.purs view

file too large to diff

+ tests/purs/failing/OrphanInstanceWithDetermined/Lib.purs view

file too large to diff

+ tests/purs/failing/OrphanTypeDecl.purs view

file too large to diff

+ tests/purs/failing/OverlapAcrossModules.purs view

file too large to diff

+ tests/purs/failing/OverlapAcrossModules/Class.purs view

file too large to diff

+ tests/purs/failing/OverlapAcrossModules/X.purs view

file too large to diff

+ tests/purs/failing/OverlappingArguments.purs view

file too large to diff

+ tests/purs/failing/OverlappingBinders.purs view

file too large to diff

+ tests/purs/failing/OverlappingInstances.purs view

file too large to diff

+ tests/purs/failing/OverlappingVars.purs view

file too large to diff

+ tests/purs/failing/PrimModuleReserved.purs view

file too large to diff

+ tests/purs/failing/PrimModuleReserved/Prim.purs view

file too large to diff

+ tests/purs/failing/PrimRow.purs view

file too large to diff

+ tests/purs/failing/PrimSubModuleReserved.purs view

file too large to diff

+ tests/purs/failing/PrimSubModuleReserved/Prim_Foobar.purs view

file too large to diff

+ tests/purs/failing/ProgrammableTypeErrors.purs view

file too large to diff

+ tests/purs/failing/ProgrammableTypeErrorsTypeString.purs view

file too large to diff

+ tests/purs/failing/Rank2Types.purs view

file too large to diff

+ tests/purs/failing/RequiredHiddenType.purs view

file too large to diff

+ tests/purs/failing/Reserved.purs view

file too large to diff

+ tests/purs/failing/RowConstructors1.purs view

file too large to diff

+ tests/purs/failing/RowConstructors2.purs view

file too large to diff

+ tests/purs/failing/RowConstructors3.purs view

file too large to diff

+ tests/purs/failing/RowInInstanceNotDetermined0.purs view

file too large to diff

+ tests/purs/failing/RowInInstanceNotDetermined1.purs view

file too large to diff

+ tests/purs/failing/RowInInstanceNotDetermined2.purs view

file too large to diff

+ tests/purs/failing/RowLacks.purs view

file too large to diff

+ tests/purs/failing/SkolemEscape.purs view

file too large to diff

+ tests/purs/failing/SkolemEscape2.purs view

file too large to diff

+ tests/purs/failing/SuggestComposition.purs view

file too large to diff

+ tests/purs/failing/Superclasses1.purs view

file too large to diff

+ tests/purs/failing/Superclasses2.purs view

file too large to diff

+ tests/purs/failing/Superclasses3.purs view

file too large to diff

+ tests/purs/failing/Superclasses5.purs view

file too large to diff

+ tests/purs/failing/TooFewClassInstanceArgs.purs view

file too large to diff

+ tests/purs/failing/TopLevelCaseNoArgs.purs view

file too large to diff

+ tests/purs/failing/TransitiveDctorExport.purs view

file too large to diff

+ tests/purs/failing/TransitiveKindExport.purs view

file too large to diff

+ tests/purs/failing/TransitiveSynonymExport.purs view

file too large to diff

+ tests/purs/failing/TypeClasses2.purs view

file too large to diff

+ tests/purs/failing/TypeError.purs view

file too large to diff

+ tests/purs/failing/TypeOperatorAliasNoExport.purs view

file too large to diff

+ tests/purs/failing/TypeSynonyms.purs view

file too large to diff

+ tests/purs/failing/TypeSynonyms2.purs view

file too large to diff

+ tests/purs/failing/TypeSynonyms3.purs view

file too large to diff

+ tests/purs/failing/TypeSynonyms4.purs view

file too large to diff

+ tests/purs/failing/TypeSynonyms5.purs view

file too large to diff

+ tests/purs/failing/TypeWildcards1.purs view

file too large to diff

+ tests/purs/failing/TypeWildcards2.purs view

file too large to diff

+ tests/purs/failing/TypeWildcards3.purs view

file too large to diff

+ tests/purs/failing/TypedBinders.purs view

file too large to diff

+ tests/purs/failing/TypedBinders2.purs view

file too large to diff

+ tests/purs/failing/TypedBinders3.purs view

file too large to diff

+ tests/purs/failing/TypedHole.purs view

file too large to diff

+ tests/purs/failing/UnderscoreModuleName.purs view

file too large to diff

+ tests/purs/failing/UnknownType.purs view

file too large to diff

+ tests/purs/failing/UnusableTypeClassMethod.purs view

file too large to diff

+ tests/purs/failing/UnusableTypeClassMethodConflictingIdent.purs view

file too large to diff

+ tests/purs/failing/UnusableTypeClassMethodSynonym.purs view

file too large to diff

+ tests/purs/passing/1110.purs view

file too large to diff

+ tests/purs/passing/1185.purs view

file too large to diff

+ tests/purs/passing/1335.purs view

file too large to diff

+ tests/purs/passing/1570.purs view

file too large to diff

+ tests/purs/passing/1664.purs view

file too large to diff

+ tests/purs/passing/1697.purs view

file too large to diff

+ tests/purs/passing/1807.purs view

file too large to diff

+ tests/purs/passing/1881.purs view

file too large to diff

+ tests/purs/passing/1991.purs view

file too large to diff

+ tests/purs/passing/2018.purs view

file too large to diff

+ tests/purs/passing/2018/A.purs view

file too large to diff

+ tests/purs/passing/2018/B.purs view

file too large to diff

+ tests/purs/passing/2049.purs view

file too large to diff

+ tests/purs/passing/2136.purs view

file too large to diff

+ tests/purs/passing/2138.purs view

file too large to diff

+ tests/purs/passing/2138/Lib.purs view

file too large to diff

+ tests/purs/passing/2172.js view

file too large to diff

+ tests/purs/passing/2172.purs view

file too large to diff

+ tests/purs/passing/2197-1.purs view

file too large to diff

+ tests/purs/passing/2197-2.purs view

file too large to diff

+ tests/purs/passing/2252.purs view

file too large to diff

+ tests/purs/passing/2288.purs view

file too large to diff

+ tests/purs/passing/2378.purs view

file too large to diff

+ tests/purs/passing/2438.purs view

file too large to diff

+ tests/purs/passing/2609.purs view

file too large to diff

+ tests/purs/passing/2609/Eg.purs view

file too large to diff

+ tests/purs/passing/2616.purs view

file too large to diff

+ tests/purs/passing/2626.purs view

file too large to diff

+ tests/purs/passing/2663.purs view

file too large to diff

+ tests/purs/passing/2689.purs view

file too large to diff

+ tests/purs/passing/2756.purs view

file too large to diff

+ tests/purs/passing/2787.purs view

file too large to diff

+ tests/purs/passing/2795.purs view

file too large to diff

+ tests/purs/passing/2803.purs view

file too large to diff

+ tests/purs/passing/2806.purs view

file too large to diff

+ tests/purs/passing/2947.purs view

file too large to diff

+ tests/purs/passing/2958.purs view

file too large to diff

+ tests/purs/passing/2972.purs view

file too large to diff

+ tests/purs/passing/3114.purs view

file too large to diff

+ tests/purs/passing/3114/VendoredVariant.purs view

file too large to diff

+ tests/purs/passing/3125.purs view

file too large to diff

+ tests/purs/passing/3187-UnusedNameClash.purs view

file too large to diff

+ tests/purs/passing/652.purs view

file too large to diff

+ tests/purs/passing/810.purs view

file too large to diff

+ tests/purs/passing/862.purs view

file too large to diff

+ tests/purs/passing/922.purs view

file too large to diff

+ tests/purs/passing/Ado.purs view

file too large to diff

+ tests/purs/passing/AppendInReverse.purs view

file too large to diff

+ tests/purs/passing/Applicative.purs view

file too large to diff

+ tests/purs/passing/ArrayType.purs view

file too large to diff

+ tests/purs/passing/Auto.purs view

file too large to diff

+ tests/purs/passing/AutoPrelude.purs view

file too large to diff

+ tests/purs/passing/AutoPrelude2.purs view

file too large to diff

+ tests/purs/passing/BindersInFunctions.purs view

file too large to diff

+ tests/purs/passing/BindingGroups.purs view

file too large to diff

+ tests/purs/passing/BlockString.purs view

file too large to diff

+ tests/purs/passing/CaseInDo.purs view

file too large to diff

+ tests/purs/passing/CaseInputWildcard.purs view

file too large to diff

+ tests/purs/passing/CaseMultipleExpressions.purs view

file too large to diff

+ tests/purs/passing/CaseStatement.purs view

file too large to diff

+ tests/purs/passing/CheckFunction.purs view

file too large to diff

+ tests/purs/passing/CheckSynonymBug.purs view

file too large to diff

+ tests/purs/passing/CheckTypeClass.purs view

file too large to diff

+ tests/purs/passing/Church.purs view

file too large to diff

+ tests/purs/passing/ClassRefSyntax.purs view

file too large to diff

+ tests/purs/passing/ClassRefSyntax/Lib.purs view

file too large to diff

+ tests/purs/passing/Collatz.purs view

file too large to diff

+ tests/purs/passing/Comparisons.purs view

file too large to diff

+ tests/purs/passing/Conditional.purs view

file too large to diff

+ tests/purs/passing/Console.purs view

file too large to diff

+ tests/purs/passing/ConstraintInference.purs view

file too large to diff

+ tests/purs/passing/ConstraintParens.purs view

file too large to diff

+ tests/purs/passing/ConstraintParsingIssue.purs view

file too large to diff

+ tests/purs/passing/ContextSimplification.purs view

file too large to diff

+ tests/purs/passing/DataAndType.purs view

file too large to diff

+ tests/purs/passing/DataConsClassConsOverlapOk.purs view

file too large to diff

+ tests/purs/passing/DctorName.purs view

file too large to diff

+ tests/purs/passing/DctorOperatorAlias.purs view

file too large to diff

+ tests/purs/passing/DctorOperatorAlias/List.purs view

file too large to diff

+ tests/purs/passing/DeepArrayBinder.purs view

file too large to diff

+ tests/purs/passing/DeepCase.purs view

file too large to diff

+ tests/purs/passing/DeriveNewtype.purs view

file too large to diff

+ tests/purs/passing/DeriveWithNestedSynonyms.purs view

file too large to diff

+ tests/purs/passing/Deriving.purs view

file too large to diff

+ tests/purs/passing/DerivingFunctor.purs view

file too large to diff

+ tests/purs/passing/Do.purs view

file too large to diff

+ tests/purs/passing/Dollar.purs view

file too large to diff

+ tests/purs/passing/DuplicateProperties.purs view

file too large to diff

+ tests/purs/passing/EffFn.js view

file too large to diff

+ tests/purs/passing/EffFn.purs view

file too large to diff

+ tests/purs/passing/EmptyDataDecls.purs view

file too large to diff

+ tests/purs/passing/EmptyRow.purs view

file too large to diff

+ tests/purs/passing/EmptyTypeClass.purs view

file too large to diff

+ tests/purs/passing/EntailsKindedType.purs view

file too large to diff

+ tests/purs/passing/Eq1Deriving.purs view

file too large to diff

+ tests/purs/passing/Eq1InEqDeriving.purs view

file too large to diff

+ tests/purs/passing/EqOrd.purs view

file too large to diff

+ tests/purs/passing/ExplicitImportReExport.purs view

file too large to diff

+ tests/purs/passing/ExplicitImportReExport/Bar.purs view

file too large to diff

+ tests/purs/passing/ExplicitImportReExport/Foo.purs view

file too large to diff

+ tests/purs/passing/ExplicitOperatorSections.purs view

file too large to diff

+ tests/purs/passing/ExportExplicit.purs view

file too large to diff

+ tests/purs/passing/ExportExplicit/M1.purs view

file too large to diff

+ tests/purs/passing/ExportExplicit2.purs view

file too large to diff

+ tests/purs/passing/ExportExplicit2/M1.purs view

file too large to diff

+ tests/purs/passing/ExportedInstanceDeclarations.purs view

file too large to diff

+ tests/purs/passing/ExtendedInfixOperators.purs view

file too large to diff

+ tests/purs/passing/Fib.purs view

file too large to diff

+ tests/purs/passing/FieldConsPuns.purs view

file too large to diff

+ tests/purs/passing/FieldPuns.purs view

file too large to diff

+ tests/purs/passing/FinalTagless.purs view

file too large to diff

+ tests/purs/passing/ForeignKind.purs view

file too large to diff

+ tests/purs/passing/ForeignKind/Lib.purs view

file too large to diff

+ tests/purs/passing/FunWithFunDeps.js view

file too large to diff

+ tests/purs/passing/FunWithFunDeps.purs view

file too large to diff

+ tests/purs/passing/FunctionScope.purs view

file too large to diff

+ tests/purs/passing/FunctionalDependencies.purs view

file too large to diff

+ tests/purs/passing/Functions.purs view

file too large to diff

+ tests/purs/passing/Functions2.purs view

file too large to diff

+ tests/purs/passing/Generalization1.purs view

file too large to diff

+ tests/purs/passing/GenericsRep.purs view

file too large to diff

+ tests/purs/passing/Guards.purs view

file too large to diff

+ tests/purs/passing/HasOwnProperty.purs view

file too large to diff

+ tests/purs/passing/HoistError.purs view

file too large to diff

+ tests/purs/passing/IfThenElseMaybe.purs view

file too large to diff

+ tests/purs/passing/IfWildcard.purs view

file too large to diff

+ tests/purs/passing/ImplicitEmptyImport.purs view

file too large to diff

+ tests/purs/passing/Import.purs view

file too large to diff

+ tests/purs/passing/Import/M1.purs view

file too large to diff

+ tests/purs/passing/Import/M2.purs view

file too large to diff

+ tests/purs/passing/ImportExplicit.purs view

file too large to diff

+ tests/purs/passing/ImportExplicit/M1.purs view

file too large to diff

+ tests/purs/passing/ImportHiding.purs view

file too large to diff

+ tests/purs/passing/ImportQualified.purs view

file too large to diff

+ tests/purs/passing/ImportQualified/M1.purs view

file too large to diff

+ tests/purs/passing/InferRecFunWithConstrainedArgument.purs view

file too large to diff

+ tests/purs/passing/InstanceBeforeClass.purs view

file too large to diff

+ tests/purs/passing/InstanceChain.purs view

file too large to diff

+ tests/purs/passing/InstanceSigs.purs view

file too large to diff

+ tests/purs/passing/InstanceSigsGeneral.purs view

file too large to diff

+ tests/purs/passing/IntAndChar.purs view

file too large to diff

+ tests/purs/passing/JSReserved.purs view

file too large to diff

+ tests/purs/passing/KindedType.purs view

file too large to diff

+ tests/purs/passing/LargeSumType.purs view

file too large to diff

+ tests/purs/passing/Let.purs view

file too large to diff

+ tests/purs/passing/Let2.purs view

file too large to diff

+ tests/purs/passing/LetInInstance.purs view

file too large to diff

+ tests/purs/passing/LetPattern.purs view

file too large to diff

+ tests/purs/passing/LiberalTypeSynonyms.purs view

file too large to diff

+ tests/purs/passing/MPTCs.purs view

file too large to diff

+ tests/purs/passing/Match.purs view

file too large to diff

+ tests/purs/passing/Module.purs view

file too large to diff

+ tests/purs/passing/Module/M1.purs view

file too large to diff

+ tests/purs/passing/Module/M2.purs view

file too large to diff

+ tests/purs/passing/ModuleDeps.purs view

file too large to diff

+ tests/purs/passing/ModuleDeps/M1.purs view

file too large to diff

+ tests/purs/passing/ModuleDeps/M2.purs view

file too large to diff

+ tests/purs/passing/ModuleDeps/M3.purs view

file too large to diff

+ tests/purs/passing/ModuleExport.purs view

file too large to diff

+ tests/purs/passing/ModuleExport/A.purs view

file too large to diff

+ tests/purs/passing/ModuleExportDupes.purs view

file too large to diff

+ tests/purs/passing/ModuleExportDupes/A.purs view

file too large to diff

+ tests/purs/passing/ModuleExportDupes/B.purs view

file too large to diff

+ tests/purs/passing/ModuleExportDupes/C.purs view

file too large to diff

+ tests/purs/passing/ModuleExportExcluded.purs view

file too large to diff

+ tests/purs/passing/ModuleExportExcluded/A.purs view

file too large to diff

+ tests/purs/passing/ModuleExportQualified.purs view

file too large to diff

+ tests/purs/passing/ModuleExportQualified/A.purs view

file too large to diff

+ tests/purs/passing/ModuleExportSelf.purs view

file too large to diff

+ tests/purs/passing/ModuleExportSelf/A.purs view

file too large to diff

+ tests/purs/passing/Monad.purs view

file too large to diff

+ tests/purs/passing/MonadState.purs view

file too large to diff

+ tests/purs/passing/MultiArgFunctions.purs view

file too large to diff

+ tests/purs/passing/MutRec.purs view

file too large to diff

+ tests/purs/passing/MutRec2.purs view

file too large to diff

+ tests/purs/passing/MutRec3.purs view

file too large to diff

+ tests/purs/passing/NakedConstraint.purs view

file too large to diff

+ tests/purs/passing/NamedPatterns.purs view

file too large to diff

+ tests/purs/passing/NegativeBinder.purs view

file too large to diff

+ tests/purs/passing/NegativeIntInRange.purs view

file too large to diff

+ tests/purs/passing/Nested.purs view

file too large to diff

+ tests/purs/passing/NestedRecordUpdate.purs view

file too large to diff

+ tests/purs/passing/NestedRecordUpdateWildcards.purs view

file too large to diff

+ tests/purs/passing/NestedTypeSynonyms.purs view

file too large to diff

+ tests/purs/passing/NestedWhere.purs view

file too large to diff

+ tests/purs/passing/NewConsClass.purs view

file too large to diff

+ tests/purs/passing/Newtype.purs view

file too large to diff

+ tests/purs/passing/NewtypeClass.purs view

file too large to diff

+ tests/purs/passing/NewtypeEff.purs view

file too large to diff

+ tests/purs/passing/NewtypeInstance.purs view

file too large to diff

+ tests/purs/passing/NewtypeWithRecordUpdate.purs view

file too large to diff

+ tests/purs/passing/NonConflictingExports.purs view

file too large to diff

+ tests/purs/passing/NonConflictingExports/A.purs view

file too large to diff

+ tests/purs/passing/NonOrphanInstanceFunDepExtra.purs view

file too large to diff

+ tests/purs/passing/NonOrphanInstanceFunDepExtra/Lib.purs view

file too large to diff

+ tests/purs/passing/NonOrphanInstanceMulti.purs view

file too large to diff

+ tests/purs/passing/NonOrphanInstanceMulti/Lib.purs view

file too large to diff

+ tests/purs/passing/NumberLiterals.purs view

file too large to diff

+ tests/purs/passing/ObjectGetter.purs view

file too large to diff

+ tests/purs/passing/ObjectSynonym.purs view

file too large to diff

+ tests/purs/passing/ObjectUpdate.purs view

file too large to diff

+ tests/purs/passing/ObjectUpdate2.purs view

file too large to diff

+ tests/purs/passing/ObjectUpdater.purs view

file too large to diff

+ tests/purs/passing/ObjectWildcards.purs view

file too large to diff

+ tests/purs/passing/Objects.purs view

file too large to diff

+ tests/purs/passing/OneConstructor.purs view

file too large to diff

+ tests/purs/passing/OperatorAlias.purs view

file too large to diff

+ tests/purs/passing/OperatorAliasElsewhere.purs view

file too large to diff

+ tests/purs/passing/OperatorAliasElsewhere/Def.purs view

file too large to diff

+ tests/purs/passing/OperatorAssociativity.purs view

file too large to diff

+ tests/purs/passing/OperatorInlining.purs view

file too large to diff

+ tests/purs/passing/OperatorSections.purs view

file too large to diff

+ tests/purs/passing/Operators.purs view

file too large to diff

+ tests/purs/passing/Operators/Other.purs view

file too large to diff

+ tests/purs/passing/OptimizerBug.purs view

file too large to diff

+ tests/purs/passing/OptionalQualified.purs view

file too large to diff

+ tests/purs/passing/Ord1Deriving.purs view

file too large to diff

+ tests/purs/passing/Ord1InOrdDeriving.purs view

file too large to diff

+ tests/purs/passing/ParensInType.purs view

file too large to diff

+ tests/purs/passing/ParensInTypedBinder.purs view

file too large to diff

+ tests/purs/passing/PartialFunction.purs view

file too large to diff

+ tests/purs/passing/Patterns.purs view

file too large to diff

+ tests/purs/passing/PendingConflictingImports.purs view

file too large to diff

+ tests/purs/passing/PendingConflictingImports/A.purs view

file too large to diff

+ tests/purs/passing/PendingConflictingImports/B.purs view

file too large to diff

+ tests/purs/passing/PendingConflictingImports2.purs view

file too large to diff

+ tests/purs/passing/PendingConflictingImports2/A.purs view

file too large to diff

+ tests/purs/passing/Person.purs view

file too large to diff

+ tests/purs/passing/PolyLabels.js view

file too large to diff

+ tests/purs/passing/PolyLabels.purs view

file too large to diff

+ tests/purs/passing/PrimedTypeName.purs view

file too large to diff

+ tests/purs/passing/QualifiedNames.purs view

file too large to diff

+ tests/purs/passing/QualifiedNames/Either.purs view

file too large to diff

+ tests/purs/passing/QualifiedQualifiedImports.purs view

file too large to diff

+ tests/purs/passing/Rank2Data.purs view

file too large to diff

+ tests/purs/passing/Rank2Object.purs view

file too large to diff

+ tests/purs/passing/Rank2TypeSynonym.purs view

file too large to diff

+ tests/purs/passing/Rank2Types.purs view

file too large to diff

+ tests/purs/passing/ReExportQualified.purs view

file too large to diff

+ tests/purs/passing/ReExportQualified/A.purs view

file too large to diff

+ tests/purs/passing/ReExportQualified/B.purs view

file too large to diff

+ tests/purs/passing/ReExportQualified/C.purs view

file too large to diff

+ tests/purs/passing/RebindableSyntax.purs view

file too large to diff

+ tests/purs/passing/Recursion.purs view

file too large to diff

+ tests/purs/passing/RedefinedFixity.purs view

file too large to diff

+ tests/purs/passing/RedefinedFixity/M1.purs view

file too large to diff

+ tests/purs/passing/RedefinedFixity/M2.purs view

file too large to diff

+ tests/purs/passing/RedefinedFixity/M3.purs view

file too large to diff

+ tests/purs/passing/ReservedWords.purs view

file too large to diff

+ tests/purs/passing/ResolvableScopeConflict.purs view

file too large to diff

+ tests/purs/passing/ResolvableScopeConflict/A.purs view

file too large to diff

+ tests/purs/passing/ResolvableScopeConflict/B.purs view

file too large to diff

+ tests/purs/passing/ResolvableScopeConflict2.purs view

file too large to diff

+ tests/purs/passing/ResolvableScopeConflict2/A.purs view

file too large to diff

+ tests/purs/passing/ResolvableScopeConflict3.purs view

file too large to diff

+ tests/purs/passing/ResolvableScopeConflict3/A.purs view

file too large to diff

+ tests/purs/passing/RowConstructors.purs view

file too large to diff

+ tests/purs/passing/RowInInstanceHeadDetermined.purs view

file too large to diff

+ tests/purs/passing/RowLacks.purs view

file too large to diff

+ tests/purs/passing/RowNub.purs view

file too large to diff

+ tests/purs/passing/RowPolyInstanceContext.purs view

file too large to diff

+ tests/purs/passing/RowUnion.js view

file too large to diff

+ tests/purs/passing/RowUnion.purs view

file too large to diff

+ tests/purs/passing/RowsInInstanceContext.purs view

file too large to diff

+ tests/purs/passing/RunFnInline.purs view

file too large to diff

+ tests/purs/passing/RuntimeScopeIssue.purs view

file too large to diff

+ tests/purs/passing/ScopedTypeVariables.purs view

file too large to diff

+ tests/purs/passing/Sequence.purs view

file too large to diff

+ tests/purs/passing/SequenceDesugared.purs view

file too large to diff

+ tests/purs/passing/ShadowedModuleName.purs view

file too large to diff

+ tests/purs/passing/ShadowedModuleName/Test.purs view

file too large to diff

+ tests/purs/passing/ShadowedName.purs view

file too large to diff

+ tests/purs/passing/ShadowedRename.purs view

file too large to diff

+ tests/purs/passing/ShadowedTCO.purs view

file too large to diff

+ tests/purs/passing/ShadowedTCOLet.purs view

file too large to diff

+ tests/purs/passing/SignedNumericLiterals.purs view

file too large to diff

+ tests/purs/passing/SolvingAppendSymbol.purs view

file too large to diff

+ tests/purs/passing/SolvingCompareSymbol.purs view

file too large to diff

+ tests/purs/passing/SolvingIsSymbol.purs view

file too large to diff

+ tests/purs/passing/SolvingIsSymbol/Lib.purs view

file too large to diff

+ tests/purs/passing/Stream.purs view

file too large to diff

+ tests/purs/passing/StringEdgeCases.purs view

file too large to diff

+ tests/purs/passing/StringEdgeCases/Records.purs view

file too large to diff

+ tests/purs/passing/StringEdgeCases/Symbols.purs view

file too large to diff

+ tests/purs/passing/StringEscapes.purs view

file too large to diff

+ tests/purs/passing/Superclasses1.purs view

file too large to diff

+ tests/purs/passing/Superclasses3.purs view

file too large to diff

+ tests/purs/passing/TCO.purs view

file too large to diff

+ tests/purs/passing/TCOCase.purs view

file too large to diff

+ tests/purs/passing/TailCall.purs view

file too large to diff

+ tests/purs/passing/Tick.purs view

file too large to diff

+ tests/purs/passing/TopLevelCase.purs view

file too large to diff

+ tests/purs/passing/TransitiveImport.purs view

file too large to diff

+ tests/purs/passing/TransitiveImport/Middle.purs view

file too large to diff

+ tests/purs/passing/TransitiveImport/Test.purs view

file too large to diff

+ tests/purs/passing/TypeClassMemberOrderChange.purs view

file too large to diff

+ tests/purs/passing/TypeClasses.purs view

file too large to diff

+ tests/purs/passing/TypeClassesInOrder.purs view

file too large to diff

+ tests/purs/passing/TypeClassesWithOverlappingTypeVariables.purs view

file too large to diff

+ tests/purs/passing/TypeDecl.purs view

file too large to diff

+ tests/purs/passing/TypeOperators.purs view

file too large to diff

+ tests/purs/passing/TypeOperators/A.purs view

file too large to diff

+ tests/purs/passing/TypeSynonymInData.purs view

file too large to diff

+ tests/purs/passing/TypeSynonyms.purs view

file too large to diff

+ tests/purs/passing/TypeWildcards.purs view

file too large to diff

+ tests/purs/passing/TypeWildcardsRecordExtension.purs view

file too large to diff

+ tests/purs/passing/TypeWithoutParens.purs view

file too large to diff

+ tests/purs/passing/TypeWithoutParens/Lib.purs view

file too large to diff

+ tests/purs/passing/TypedBinders.purs view

file too large to diff

+ tests/purs/passing/TypedWhere.purs view

file too large to diff

+ tests/purs/passing/UTF8Sourcefile.purs view

file too large to diff

+ tests/purs/passing/UnderscoreIdent.purs view

file too large to diff

+ tests/purs/passing/UnicodeIdentifier.purs view

file too large to diff

+ tests/purs/passing/UnicodeOperators.purs view

file too large to diff

+ tests/purs/passing/UnicodeType.purs view

file too large to diff

+ tests/purs/passing/UnifyInTypeInstanceLookup.purs view

file too large to diff

+ tests/purs/passing/Unit.purs view

file too large to diff

+ tests/purs/passing/UnknownInTypeClassLookup.purs view

file too large to diff

+ tests/purs/passing/UnsafeCoerce.purs view

file too large to diff

+ tests/purs/passing/UntupledConstraints.purs view

file too large to diff

+ tests/purs/passing/UsableTypeClassMethods.purs view

file too large to diff

+ tests/purs/passing/Where.purs view

file too large to diff

+ tests/purs/passing/WildcardInInstance.purs view

file too large to diff

+ tests/purs/passing/WildcardType.purs view

file too large to diff

+ tests/purs/passing/iota.purs view

file too large to diff

+ tests/purs/passing/s.purs view

file too large to diff

+ tests/purs/psci/BasicEval.purs view

file too large to diff

+ tests/purs/psci/Multiline.purs view

file too large to diff

+ tests/purs/warning/2140.purs view

file too large to diff

+ tests/purs/warning/2383.purs view

file too large to diff

+ tests/purs/warning/2411.purs view

file too large to diff

+ tests/purs/warning/2542.purs view

file too large to diff

+ tests/purs/warning/CustomWarning.purs view

file too large to diff

+ tests/purs/warning/CustomWarning2.purs view

file too large to diff

+ tests/purs/warning/CustomWarning3.purs view

file too large to diff

+ tests/purs/warning/DuplicateExportRef.purs view

file too large to diff

+ tests/purs/warning/DuplicateImport.purs view

file too large to diff

+ tests/purs/warning/DuplicateImportRef.purs view

file too large to diff

+ tests/purs/warning/DuplicateSelectiveImport.purs view

file too large to diff

+ tests/purs/warning/HidingImport.purs view

file too large to diff

+ tests/purs/warning/ImplicitImport.purs view

file too large to diff

+ tests/purs/warning/ImplicitQualifiedImport.purs view

file too large to diff

+ tests/purs/warning/ImplicitQualifiedImportReExport.purs view

file too large to diff

+ tests/purs/warning/MissingTypeDeclaration.purs view

file too large to diff

+ tests/purs/warning/NewtypeInstance.purs view

file too large to diff

+ tests/purs/warning/NewtypeInstance2.purs view

file too large to diff

+ tests/purs/warning/NewtypeInstance3.purs view

file too large to diff

+ tests/purs/warning/NewtypeInstance4.purs view

file too large to diff

+ tests/purs/warning/OverlappingPattern.purs view

file too large to diff

+ tests/purs/warning/ScopeShadowing.purs view

file too large to diff

+ tests/purs/warning/ScopeShadowing2.purs view

file too large to diff

+ tests/purs/warning/ShadowedBinderPatternGuard.purs view

file too large to diff

+ tests/purs/warning/ShadowedNameParens.purs view

file too large to diff

+ tests/purs/warning/ShadowedTypeVar.purs view

file too large to diff

+ tests/purs/warning/UnnecessaryFFIModule.js view

file too large to diff

+ tests/purs/warning/UnnecessaryFFIModule.purs view

file too large to diff

+ tests/purs/warning/UnusedDctorExplicitImport.purs view

file too large to diff

+ tests/purs/warning/UnusedDctorImportAll.purs view

file too large to diff

+ tests/purs/warning/UnusedDctorImportExplicit.purs view

file too large to diff

+ tests/purs/warning/UnusedExplicitImport.purs view

file too large to diff

+ tests/purs/warning/UnusedExplicitImportTypeOp.purs view

file too large to diff

+ tests/purs/warning/UnusedExplicitImportTypeOp/Lib.purs view

file too large to diff

+ tests/purs/warning/UnusedExplicitImportValOp.purs view

file too large to diff

+ tests/purs/warning/UnusedFFIImplementations.js view

file too large to diff

+ tests/purs/warning/UnusedFFIImplementations.purs view

file too large to diff

+ tests/purs/warning/UnusedImport.purs view

file too large to diff

+ tests/purs/warning/UnusedTypeVar.purs view

file too large to diff

+ tests/purs/warning/WildcardInferredType.purs view

file too large to diff

tests/support/bower.json view

file too large to diff

+ tests/support/package-lock.json view

file too large to diff

+ tests/support/pscide/src/FindUsage.purs view

file too large to diff

+ tests/support/pscide/src/FindUsage/Definition.purs view

file too large to diff

+ tests/support/pscide/src/FindUsage/Recursive.purs view

file too large to diff

+ tests/support/pscide/src/FindUsage/RecursiveShadowed.purs view

file too large to diff

+ tests/support/pscide/src/FindUsage/Reexport.purs view

file too large to diff