fix f is the least fixed point of the function f, i.e. the least defined x such that f x = x.

Allow the result of a state transformer computation to be used (lazily) inside the computation. Note that if f is strict, fixST f = _|_.

fix-imports is a small standalone program to manage the import block of a haskell program. It will try to add import lines for qualified names with no corresponding import, remove unused import lines, and sort the import block according to some heuristic you can define. This only works for qualified imports! Unqualified imports are left untouched.
It's most convenient if bound to an editor key.
Recent major changes: * version 1.0.2
* Fix bug where a qualified import with >1 dot wasn't found. And don't mess with Prelude.
* version 1.0.1
* Fix a bunch of bugs: properly recognize unqualified imports as imports, never import the current module, don't pick up modules with the same suffix but a different name.
* version 1.0.0
* Change name from FixImports to fix-imports, which is more unixy.
* Change ghc-pkg parsing from String to Text. It's noticeably faster.
* Add a more flexible system for prioritizing imports. When there are several possibilities for a module name, they are all given to a single function to decide. The config file moved from fix-imports-priority to .fix-imports and can now specify sort orders for packages and modules by prefix.
* Make -i includes for non-existent dirs ignored instead of causing an error.
Version 1.0.2

Simple fix-expression parser
Version 15320.3

Gitit plugin: Turn some Haskell symbols into pretty math symbols.
Version 0.1.0

A fixed length list type that encodes its length in its type in a natural way, and is a member of Applicative, Functor, Foldable, Traversable, and Monad.
Version 0.1.5

This package defines a type for binary fixed-precision arithmetic. The main differences between this and Data.Fixed are that this is binary fixed-point and it's polymorphic in the underlying representation. When is this more appropriate than floating point? You'll mainly want to use this when you need to be able to represent fractional values within a bounded range. Fixed-point numbers have the advantage of uniformity in these cases. On the downside, you lose precision relative to floating point numbers as you approach zero, and you lose the ability to express very large (but imprecise) values that floating point can express. On some architectures, fixed-point arithmetic might be faster than floating-point arithmetic, but this is probably not the case on x86.
Version 0.5.0.1

This package allows you to construct unboxed vectors of binary fixed-point numerals.
Version 0.5.0.1

This package provides instances of VectorSpace, AffineSpace, etc. for the fixed-point package.
Version 0.5.0.1

Numeric instances for MPFR that use the "Implicit Configurations" from http://www.cs.rutgers.edu/~ccshan/prepose/prepose.pdf to choose a Rounding and Precision. For those that do not want to use reflection, explicit instances are provided for common precisions and for the built-in rounding modes.
> sin pi :: Fixed Down Double
> fixed Near 256 (sin pi)
Version 0.4.0

Uses type-level numeric literals to wrap StorableArray in a type that statically fixes its size. The wrapper has a Storable instance, for easy integration with fixed-size native arrays.
Deprecated - use storable-static-array instead.
Version 0.3.1.1

Generic library for vectors with statically known size. Implementation is based on http://unlines.wordpress.com/2010/11/15/generics-for-small-fixed-size-vectors/ Same functions could be used to work with both ADT based vector like
> data Vec3 a = a a a
Tuples are vectors too:
>>> sum (1,2,3) 6
Vectors which are represented internally by arrays are provided by library. Both boxed and unboxed arrays are supported.
Library is structured as follows:
Data.Vector.Fixed: Generic API. It's suitable for both ADT-based vector like Complex and array-based ones. Data.Vector.Fixed.Cont: Continuation based vectors. Internally all functions use them. Data.Vector.Fixed.Mutable: Type classes for array-based implementation and API for working with mutable state. Data.Vector.Fixed.Unboxed: Unboxed vectors. Data.Vector.Fixed.Boxed: Boxed vector which can hold elements of any type. Data.Vector.Fixed.Storable: Unboxed vectors of Storable types. Data.Vector.Fixed.Primitive: Unboxed vectors based on pritimive package. Data.Vector.Fixed.Monomorphic: Wrappers for monomorphic vectors
Version 0.6.0.0

Binary instances for fixed-vector
Version 0.6.0.0

Cereal instances for fixed-vector
Version 0.6.0.0

A reasonably efficient implementation of arbitrary-but-fixed precision real numbers. This is inspired by, and partly based on, Data.Number.Fixed and Data.Number.CReal, but more efficient.
Version 0.2.1.0

Financial Information eXchange (FIX) protocol (co)parser
Version 0.1.4

Uniplate-style generic traversals for fixed-point types, which can be optionally annotated with attributes. We also provide recursion schemes, and a generic zipper. See the module Data.Generics.Fixplate and then the individual modules for more detailed information.
Version 0.1.5

This package allows data types to be seen and manipulated as fixpoints of their underlying functors. It is mostly based on "Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire" by Erik Meijer, Maarten Fokkinga and Ross Paterson (http://citeseer.ist.psu.edu/meijer91functional.html). It makes essential use of associated types and related extensions.
Version 0.1.1

Monadic fixpoints.
For a detailed discussion, see Levent Erkok's thesis, *Value Recursion in Monadic Computations*, Oregon Graduate Institute, 2002.