diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,30 @@ +Copyright (c)2011, Jean-Marie Gaillourdet + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of Jean-Marie Gaillourdet nor the names of other + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/README b/README new file mode 100644 --- /dev/null +++ b/README @@ -0,0 +1,10 @@ +simpleprelude provides an alternative Prelude module for teaching as +well as wrappers for ghc, and ghci to use them. + +The simplified Prelude omits the type classes Num, Integral, and +Ord. Instead it provides monomorphically typed arithmetic operators on +Integer. + +It also provides two executables: simple-ghc and simple-ghci which are +wrappers around ghc and ghci. They are pre-configured to use the +Prelude module of this library instead of base's Prelude module. diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,2 @@ +import Distribution.Simple +main = defaultMain diff --git a/simpleprelude.cabal b/simpleprelude.cabal new file mode 100644 --- /dev/null +++ b/simpleprelude.cabal @@ -0,0 +1,65 @@ +Name: simpleprelude + +Version: 1.0 + +Synopsis: A simplified Haskell prelude for teaching + +Description: simpleprelude provides an alternative Prelude + module for teaching as well as wrappers for ghc, + and ghci to use them. + . + The simplified Prelude omits the type classes + Num, Integral, and Ord. Instead it provides + monomorphically typed arithmetic operators on + Integer. + . + It also provides two executables: simple-ghc and + simple-ghci which are wrappers around ghc and + ghci. They are pre-configured to use the Prelude + module of this library instead of base's Prelude + module. + +License: BSD3 + +License-file: LICENSE + +Author: Jean-Marie Gaillourdet + +Maintainer: jmg@cs.uni-kl.de + +Category: Teaching + +Build-type: Simple + +Extra-source-files: LICENSE, README + +-- Constraint on the version of Cabal needed to build this package. +Cabal-version: >=1.6 + + +Library + Exposed-modules: Prelude + exposed: False + + Build-depends: base > 3 && <5 + Hs-Source-Dirs: src + + +Executable simple-ghc + Main-Is: SimpleGHC.hs + Build-depends: base, + process >= 1.0 && < 1.2, + ghc-paths >= 0.1 && < 0.2 + Hs-Source-Dirs: src + + +Executable simple-ghci + Main-Is: SimpleGHCi.hs + Build-depends: base, + process >= 1.0 && < 1.2, + ghc-paths >= 0.1 && < 0.2 + Hs-Source-Dirs: src + +Source-Repository head + Type: Mercurial + Location: https://softech.cs.uni-kl.de/hg/public/simpleprelude diff --git a/src/Prelude.hs b/src/Prelude.hs new file mode 100644 --- /dev/null +++ b/src/Prelude.hs @@ -0,0 +1,232 @@ +{-# LANGUAGE PackageImports, NoImplicitPrelude #-} + +module Prelude ( + + -- * Standard types, classes and related functions + + -- ** Basic data types + Bool(False, True), + (&&), (||), not, otherwise, + + Maybe(Nothing, Just), + maybe, + + Either(Left, Right), + either, + + Ordering(LT, EQ, GT), + Char, String, + + -- *** Tuples + fst, snd, curry, uncurry, + + -- ** Basic type classes + -- removed: Eq((==), (/=)), + (==), (/=), + -- removed: Ord(compare, (<), (<=), (>=), (>), max, min), + compare, (<), (<=), (>=), (>), max, min, + Enum(succ, pred, toEnum, fromEnum, enumFrom, enumFromThen, + enumFromTo, enumFromThenTo), + Bounded(minBound, maxBound), + + -- ** Numbers + + -- *** Numeric types + -- removed: Int, Integer, Float, Double, + -- removed: Rational, + Integer, + + -- *** Numeric type classes + -- removed: Num((+), (-), (*), negate, abs, signum, fromInteger), + (+), (-), (*), negate, abs, signum, fromInteger, + + -- removed: Real(toRational), + -- removed: Integral(quot, rem, div, mod, quotRem, divMod, toInteger), + quot, rem, div, mod, quotRem, divMod, toInteger, + + -- removed: Fractional((/), recip, fromRational), + -- removed: Floating(pi, exp, log, sqrt, (**), logBase, sin, cos, tan, + -- removed: asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh), + -- removed: RealFrac(properFraction, truncate, round, ceiling, floor), + -- removed: RealFloat(floatRadix, floatDigits, floatRange, decodeFloat, + -- removed: encodeFloat, exponent, significand, scaleFloat, isNaN, + -- removed: isInfinite, isDenormalized, isIEEE, isNegativeZero, atan2), + + -- *** Numeric functions + subtract, even, odd, gcd, lcm, (^), + fromIntegral, + + -- removed: realToFrac, (^^), + + -- ** Monads and functors + Monad((>>=), (>>), return, fail), + Functor(fmap), + mapM, mapM_, sequence, sequence_, (=<<), + + -- ** Miscellaneous functions + id, const, (.), flip, ($), until, + asTypeOf, error, undefined, + seq, ($!), + + -- * List operations + map, (++), filter, + head, last, tail, init, null, length, (!!), + reverse, + -- ** Reducing lists (folds) + foldl, foldl1, foldr, foldr1, + -- *** Special folds + and, or, any, all, + sum, product, + concat, concatMap, + maximum, minimum, + -- ** Building lists + -- *** Scans + scanl, scanl1, scanr, scanr1, + -- *** Infinite lists + iterate, repeat, replicate, cycle, + -- ** Sublists + take, drop, splitAt, takeWhile, dropWhile, span, break, + -- ** Searching lists + elem, notElem, lookup, + -- ** Zipping and unzipping lists + zip, zip3, zipWith, zipWith3, unzip, unzip3, + -- ** Functions on strings + lines, words, unlines, unwords, + + -- * Converting to and from @String@ + -- ** Converting to @String@ + ShowS, + Show(showsPrec, showList, show), + shows, + showChar, showString, showParen, + -- ** Converting from @String@ + ReadS, + Read(readsPrec, readList), + reads, readParen, read, lex, + + -- * Basic Input and output + IO, + -- ** Simple I\/O operations + -- All I/O functions defined here are character oriented. The + -- treatment of the newline character will vary on different systems. + -- For example, two characters of input, return and linefeed, may + -- read as a single newline character. These functions cannot be + -- used portably for binary I/O. + -- *** Output functions + putChar, + putStr, putStrLn, print, + -- *** Input functions + getChar, + getLine, getContents, interact, + -- *** Files + FilePath, + readFile, writeFile, appendFile, readIO, readLn, + -- ** Exception handling in the I\/O monad + IOError, ioError, userError, catch + + ) +where + +import "base" Prelude hiding ( Num(..), Integral(..), subtract, even + , odd, gcd, lcm, (^) + , length, (!!), sum, product + , take, drop + , Ord(..), Eq(..) + ) +import qualified "base" Prelude as P +import qualified Data.List as L + +-- ------- +-- - Num - +-- ------- + +(+), (-), (*) :: Integer -> Integer -> Integer +(+) = (P.+) +(-) = (P.-) +(*) = (P.*) + + +negate, abs, signum, fromInteger :: Integer -> Integer +negate = P.negate +abs = P.abs +signum = P.signum +fromInteger = P.fromInteger + + +-- ------------ +-- - Integral - +-- ------------ + +quot, rem, div, mod :: Integer -> Integer -> Integer +quot = P.quot +rem = P.rem +div = P.div +mod = P.mod + + +quotRem, divMod :: Integer -> Integer -> (Integer, Integer) +quotRem = P.quotRem +divMod = P.divMod + +toInteger :: Integer -> Integer +toInteger = P.toInteger + +-- --------------------- +-- - numeric functions - +-- --------------------- + +subtract, gcd, lcm, (^) :: Integer -> Integer -> Integer +subtract = P.subtract +gcd = P.gcd +lcm = P.lcm +(^) = (P.^) + +even, odd :: Integer -> Bool +even = P.even +odd = P.odd + + +-- ------------------ +-- - list functions - +-- ------------------ + +length :: [a] -> Integer +length = L.genericLength + +(!!) :: [a] -> Integer -> a +(!!) = L.genericIndex + +sum, product :: [Integer] -> Integer +sum = P.sum +product = P.product + +take, drop :: Integer -> [a] -> [a] +take = L.genericTake +drop = L.genericDrop + + +-- ------- +-- - Ord - +-- ------- + +compare :: Integer -> Integer -> Ordering +compare = P.compare + +(<), (<=), (>=), (>) :: Integer -> Integer -> Bool +(<) = (P.<) +(<=) = (P.<=) +(>=) = (P.>=) +(>) = (P.>) + +max, min :: Integer -> Integer -> Integer +max = P.max +min = P.min + + +-- ------ +-- - Eq - +-- ------ + +(==), (/=) :: Integer -> Integer -> Bool +(==) = (P.==) +(/=) = (P./=) diff --git a/src/SimpleGHC.hs b/src/SimpleGHC.hs new file mode 100644 --- /dev/null +++ b/src/SimpleGHC.hs @@ -0,0 +1,12 @@ + +import Common ( additionalArgs ) +import GHC.Paths ( ghc ) +import System.Environment ( getArgs ) +import System.Exit ( exitWith ) +import System.Process ( rawSystem ) + + +main :: IO () +main = do + args <- getArgs + exitWith =<< rawSystem ghc (additionalArgs ++ args) diff --git a/src/SimpleGHCi.hs b/src/SimpleGHCi.hs new file mode 100644 --- /dev/null +++ b/src/SimpleGHCi.hs @@ -0,0 +1,12 @@ + +import Common ( additionalArgs ) +import GHC.Paths ( ghc ) +import System.Environment ( getArgs ) +import System.Exit ( exitWith ) +import System.Process ( rawSystem ) + + +main :: IO () +main = do + args <- getArgs + exitWith =<< rawSystem ghc (["--interactive"] ++ additionalArgs ++ args)