Haskell 98 - higher order versions of Prelude classes to ease programming with polymorphic recursion and reduce UndecidableInstances
See http://flint.cs.yale.edu/trifonov/papers/sqcc.pdf for further discussion of the approach taken here.
. This is a prelude file with some additional functions and more generalize of some functions, including list operation, monad operation, numbers, bitwise, and a few more compositions. It also imports some other modules.
> import Prelude ()
> import Prelude.Plus
> -- then some useful modules and couple of generic functions
> -- are available in your code
A redefinition of the Prelude's Enum class in order to render it safe. That is, the Haskell Language Report defines pred, succ, fromEnum, and toEnum to be partial functions when the type is Bounded, but this is unacceptable. We define a new type-class hierarchy for enumeration which is safe and also generalizes to cover types which can only be enumerated in one direction.
The premise of basic-prelude is that there are a lot of very commonly desired features missing from the standard Prelude, such as commonly used operators (<$> and >=>, for instance) and imports for common datatypes (e.g., ByteString and Vector). At the same time, there are lots of other components which are more debatable, such as providing polymorphic versions of common functions.
So basic-prelude is intended to give a common foundation for a number of alternate preludes. The package provides two modules: CorePrelude provides the common ground for other preludes to build on top of, while BasicPrelude exports CorePrelude together with commonly used list functions to provide a drop-in replacement for the standard Prelude.
Users wishing to have an improved Prelude can use BasicPrelude. Developers wishing to create a new prelude should use CorePrelude.
0.3: Moved a number of exports from BasicPrelude to CorePrelude and vice-versa. 0.2: Renamed BasicPrelude to CorePrelude and added a new BasicPrelude module provided a full-featured Prelude alternative. Also added a number of new exports. 0.1: Initial version, code taken from classy-prelude with a few minor tweaks.
Focuses on using common typeclasses when possible, and creating new ones to avoid name clashing. Exposes many recommended datastructures (Map, ByteString, etc) directly without requiring long import lists and qualified modules.
conduit instances for classy-prelude
This is an extension of classy-prelude-conduit, adding in commonly used functions and data types from Yesod.
ClassyPrelude is a Prelude for people who know Haskell well. It re-exports some commonly imported modules, replaces Prelude functions with their type-class equivalents where reasonable, and removes some Prelude functions that in my opinion don't belong there. These modules are likely to be incomplete. Suggestions are greatly appreciated.
An enhanced prelude, serving as a foundation for my projects
This Prelude prefers more general and performance-oriented types, such as Category, Foldable, Traversable, Data.Text and Control.Lens.
Functional programming environment, Version 2.30 Standard prelude for use of overloaded values using type classes. Based on the Haskell standard prelude version 1.2.
Revisiting the Numeric Classes
The Prelude for Haskell 98 offers a well-considered set of numeric classes which covers the standard numeric types (Integer, Int, Rational, Float, Double, Complex) quite well. But they offer limited extensibility and have a few other flaws. In this proposal we will revisit these classes, addressing the following concerns:
1: The current Prelude defines no semantics for the fundamental operations. For instance, presumably addition should be associative (or come as close as feasible), but this is not mentioned anywhere. 2: There are some superfluous superclasses. For instance, Eq and Show are superclasses of Num. Consider the data type data IntegerFunction a = IF (a -> Integer) One can reasonably define all the methods of Algebra.Ring.C for IntegerFunction a (satisfying good semantics), but it is impossible to define non-bottom instances of Eq and Show. In general, superclass relationship should indicate some semantic connection between the two classes. 3: In a few cases, there is a mix of semantic operations and representation-specific operations. toInteger, toRational, and the various operations in RealFloating (decodeFloat, ...) are the main examples. 4: In some cases, the hierarchy is not finely-grained enough: Operations that are often defined independently are lumped together. For instance, in a financial application one might want a type "Dollar", or in a graphics application one might want a type "Vector". It is reasonable to add two Vectors or Dollars, but not, in general, reasonable to multiply them. But the programmer is currently forced to define a method for '(*)' when she defines a method for '(+)'.
In specifying the semantics of type classes, I will state laws as follows:
> (a + b) + c === a + (b + c)
The intended meaning is extensional equality: The rest of the program should behave in the same way if one side is replaced with the other. Unfortunately, the laws are frequently violated by standard instances; the law above, for instance, fails for Float:
> (1e20 + (-1e20)) + 1.0 = 1.0
> 1e20 + ((-1e20) + 1.0) = 0.0
For inexact number types like floating point types, thus these laws should be interpreted as guidelines rather than absolute rules. In particular, the compiler is not allowed to use them for optimization. Unless stated otherwise, default definitions should also be taken as laws.
Thanks to Brian Boutel, Joe English, William Lee Irwin II, Marcin Kowalczyk, Ketil Malde, Tom Schrijvers, Ken Shan, and Henning Thielemann for helpful comments.
Write modules in the following style:
> [-# LANGUAGE NoImplicitPrelude #-]
> module MyModule where
> ... various specific imports ...
> import NumericPrelude
Importing NumericPrelude is almost the same as
> import NumericPrelude.Numeric
> import NumericPrelude.Base .
Instead of the NoImplicitPrelude pragma you could also write import Prelude () but this will yield problems with numeric literals.
There are two wrapper types that allow types to be used with both Haskell98 and NumericPrelude type classes that are initially implemented for only one of them.
Scope & Limitations/TODO:
* It might be desireable to split Ord up into Poset and Ord (a total ordering). This is not addressed here.
* In some cases, this hierarchy may not yet be fine-grained enough. For instance, time spans ("5 minutes") can be added to times ("12:34"), but two times are not addable. ("12:34 + 8:23") As it stands, users have to use a different operator for adding time spans to times than for adding two time spans. Similar issues arise for vector space et al. This is a consciously-made tradeoff, but might be changed. This becomes most serious when dealing with quantities with units like length/distance^2, for which (*) as defined here is useless. (One way to see the issue: should f x y = iterate (x *) y have principal type (Ring.C a) => a -> a -> [a] or something like (Ring.C a, Module a b) => a -> b -> [b] ?)
* I stuck with the Haskell 98 names. In some cases I find them lacking. Neglecting backwards compatibility, we have renamed classes as follows: Num --> Additive, Ring, Absolute Integral --> ToInteger, IntegralDomain, RealIntegral Fractional --> Field Floating --> Algebraic, Transcendental Real --> ToRational RealFrac --> RealRing, RealField RealFloat --> RealTranscendental
Additional standard libraries might include Enum, IEEEFloat (including the bulk of the functions in Haskell 98's RealFloat class), VectorSpace, Ratio, and Lattice.
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.
* 22.214.171.124: Bugfix concerning conditional expressions - 126.96.36.199: Fixing missing operator precedences - 188.8.131.52: Add a Haskell pre-processor to restore the feel of an implicityly imported Prelude although we use -XNoImplicitPrelude.
This module contains functions from the prelude implemented at the type level as both type classes and type families. It comes with an Integer kind.
This package adds unicode notation for some definitions in Prelude.
Show more results