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.
Simple fix-expression parser
Gitit plugin: Turn some Haskell symbols into pretty math symbols.
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.
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.
This package allows you to construct unboxed vectors of binary fixed-point numerals.
This package provides instances of VectorSpace, AffineSpace, etc. for the fixed-point package.
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)
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
Changes in 0.4.4.0
* Functor and Applicative instances are added to Id.
Changes in 0.4.3.0
* Typeable instance for S and Z added.
Changes in 0.4.2.0
* 1-tuple Only added.
* fromList' and fromListM added.
* apply functions from Arity type class generalized.
Changes in 0.4.1.0
* cons function added.
* Getter to Fun data type added.
Changes in 0.4.0.0
* Wrapper for monomorphics vectors is added.
* VecList is reimplemented as GADT and constructors are exported.
* Constructor of ContVecT is exported
* Empty ContVecT is implemented as empty.
* Typeable, Foldable and Traversable instances are added where appropriate
Changes in 0.3.0.0
* Wrappers for monomorphic types added.
Changes in 0.3.0.0
* Vector type class definition is moved to the D.V.F.Cont module.
* Indexing function restored.
* unfoldr added.
Changes in 0.2.0.0
* Continuation-based vector added.
* Right fold added.
* tailWith, convertContinuation, and ! from Data.Vector.Fixed removed.
* Vector instance for tuples added.
Changes in 0.1.2
* imap, imapM, ifoldl, ifoldM, zipWithM, izipWithM functions are added.
* VectorN type class added.
Changes in 0.1.1
* foldM and tailWith added. Type synonyms for numbers up to 6 are added. Fun is reexported from Data.Vector.Fixed.
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.
Financial Information eXchange (FIX) protocol (co)parser
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.
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.
For a detailed discussion, see Levent Erkok's thesis, Value Recursion in Monadic Computations, Oregon Graduate Institute, 2002.
This module defines a "Fixed" type for fixed-precision arithmetic. The parameter to Fixed is any type that's an instance of HasResolution. HasResolution has a single method that gives the resolution of the Fixed type.
This module also contains generalisations of div, mod, and divmod to work with any Real instance.
Fixity of constructors
Show more results