Hoogle Search

Within LTS Haskell 24.3 (ghc-9.10.2)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

package vty-crossplatform

Cross-platform support for Vty This package provides a generic interface for multiple Vty platforms in one package so you don't have to conditionally depend on them in your cabal file.
package wl-pprint-text

A Wadler/Leijen Pretty Printer for Text values A clone of wl-pprint for use with the text library.
package yaya

Total recursion schemes. Recursion schemes allow you to separate recursion from your business logic – making your own operations simpler, more modular, and less error-prone. This library also provides tools for combining your operations in ways that reduce the number of passes over your data and is designed to encourage total (i.e., successfully terminating) functions.
package yesod-persistent

Some helpers for using Persistent from Yesod. API docs and the README are available at http://www.stackage.org/package/yesod-persistent
package ChasingBottoms

For testing partial and infinite values. Do you ever feel the need to test code involving bottoms (e.g. calls to the error function), or code involving infinite values? Then this library could be useful for you. It is usually easy to get a grip on bottoms by showing a value and waiting to see how much gets printed before the first exception is encountered. However, that quickly gets tiresome and is hard to automate using e.g. QuickCheck (http://www.cse.chalmers.se/~rjmh/QuickCheck/). With this library you can do the tests as simply as the following examples show. Testing explicitly for bottoms:
```
> isBottom (head [])
True
```
```
> isBottom bottom
True
```
```
> isBottom (\_ -> bottom)
False
```
```
> isBottom (bottom, bottom)
False
```
Comparing finite, partial values:
```
> ((bottom, 3) :: (Bool, Int)) ==! (bottom, 2+5-4)
True
```
```
> ((bottom, bottom) :: (Bool, Int)) <! (bottom, 8)
True
```
Showing partial and infinite values (\/! is join and /\! is meet):
```
> approxShow 4 $ (True, bottom) \/! (bottom, 'b')
"Just (True, 'b')"
```
```
> approxShow 4 $ (True, bottom) /\! (bottom, 'b')
"(_|_, _|_)"
```
```
> approxShow 4 $ ([1..] :: [Int])
"[1, 2, 3, _"
```
```
> approxShow 4 $ (cycle [bottom] :: [Bool])
"[_|_, _|_, _|_, _"
```
Approximately comparing infinite, partial values:
```
> approx 100 [2,4..] ==! approx 100 (filter even [1..] :: [Int])
True
```
```
> approx 100 [2,4..] /=! approx 100 (filter even [bottom..] :: [Int])
True
```
The code above relies on the fact that bottom, just as error "...", undefined and pattern match failures, yield exceptions. Sometimes we are dealing with properly non-terminating computations, such as the following example, and then it can be nice to be able to apply a time-out:
```
> timeOut' 1 (reverse [1..5])
Value [5,4,3,2,1]
```
```
> timeOut' 1 (reverse [1..])
NonTermination
```
The time-out functionality can be used to treat "slow" computations as bottoms:
```
> let tweak = Tweak { approxDepth = Just 5, timeOutLimit = Just 2 }
> semanticEq tweak (reverse [1..], [1..]) (bottom :: [Int], [1..] :: [Int])
True
```
```
> let tweak = noTweak { timeOutLimit = Just 2 }
> semanticJoin tweak (reverse [1..], True) ([] :: [Int], bottom)
Just ([],True)
```
This can of course be dangerous:
```
> let tweak = noTweak { timeOutLimit = Just 0 }
> semanticEq tweak (reverse [1..100000000]) (bottom :: [Integer])
True
```
Timeouts can also be applied to IO computations:
```
> let primes () = unfoldr (\(x:xs) -> Just (x, filter ((/= 0) . (`mod` x)) xs)) [2..]
> timeOutMicro 100 (print $ primes ())
[2,NonTermination
> timeOutMicro 10000 (print $ take 10 $ primes ())
[2,3,5,7,11,13,17,19,23,29]
Value ()
```
For the underlying theory and a larger example involving use of QuickCheck, see the article "Chasing Bottoms, A Case Study in Program Verification in the Presence of Partial and Infinite Values" (http://www.cse.chalmers.se/~nad/publications/danielsson-jansson-mpc2004.html). The code has been tested using GHC. Most parts can probably be ported to other Haskell compilers, but this would require some work. The TimeOut functions require preemptive scheduling, and most of the rest requires Data.Generics; isBottom only requires exceptions, though.
package GLFW-b

Bindings to GLFW OpenGL library Bindings to GLFW (http://www.glfw.org/), an open source, multi-platform library for creating windows with OpenGL contexts and managing input and events. GLFW-b depends on bindings-GLFW (http://hackage.haskell.org/package/bindings-GLFW), which, as of the time of this writing, binds to GLFW 3.3.9, released 2023-12-13 (http://www.glfw.org/Version-3.3.0-released.html http://www.glfw.org/changelog.html). If you've used GLFW < 3 before, you should read the transition guide (http://www.glfw.org/docs/3.0/moving.html).
package GLUT

A binding for the OpenGL Utility Toolkit A Haskell binding for the OpenGL Utility Toolkit, a window system independent toolkit for writing OpenGL programs. For more information about the C library on which this binding is based, please see: http://www.opengl.org/resources/libraries/glut/.
package HDBC

Haskell Database Connectivity HDBC provides an abstraction layer between Haskell programs and SQL relational databases. This lets you write database code once, in Haskell, and have it work with any number of backend SQL databases (MySQL, Oracle, PostgreSQL, ODBC-compliant databases, etc.)
package HsYAML-aeson

JSON to YAML Adapter The YAML 1.2 format provides a much richer data-model and feature-set than the JavaScript Object Notation (JSON) format. However, sometimes it's desirable to ignore the extra capabilities and treat YAML as if it was merely a more convenient markup format for humans to write JSON data. To this end this module provides a compatibility layer atop HsYAML which allows decoding YAML documents in the more limited JSON data-model while also providing convenience by reusing aeson's FromJSON instances for decoding the YAML data into native Haskell data types.
package MemoTrie

Trie-based memo functions MemoTrie provides a basis for memoized functions over some domains, using tries. It's based on ideas from Ralf Hinze and code from Spencer Janssen. Generic support thanks to Sam Boosalis. Project wiki page: http://haskell.org/haskellwiki/MemoTrie Ç 2008-2019 by Conal Elliott; BSD3 license.

Page 59 of many | Previous | Next