Hoogle Search

Within LTS Haskell 24.35 (ghc-9.10.3)

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

package relational-schemas

RDBMSs' schema templates for relational-query This package contains some RDBMSs' schema structure definitions. Supported RDBMS schemas are below:
- IBM DB2
- PostgreSQL
- Microsoft SQLServer
- SQLite3
- Oracle
- MySQL
package renderable

An API for managing renderable resources. The renderable package provides a method for managing resources of a rendering system. Resources are allocated according to a strategy and released automatically when your renderable data changes. These changes are detected during each draw call based on the hash of your renderable datatype. This package is meant to be pulled in as a portion of your rendering system. It aims to ease the task of managing allocation of resources over time as the value of your renderable datatype changes.
package repa-algorithms

Algorithms using the Repa array library. Reusable algorithms using the Repa array library.
package repa-io

Read and write Repa arrays in various formats. Read and write Repa arrays in various formats.
package rex

A quasi-quoter for typeful results of regex captures. Provides a quasi-quoter for regular expressions which yields a tuple, of appropriate arity and types, representing the results of the captures. Allows the user to specify parsers for captures as inline Haskell. Can also be used to provide typeful pattern matching in function definitions and pattern matches. Also, it precompiles the regular expressions into a PCRE compiled byte-array representation, at compile time.
package riak-protobuf

Haskell types for the Riak protocol buffer API A set of Haskell types for interacting with the protocol buffer API of the Riak decentralized data store.
package rollbar

error tracking through rollbar.com error tracking through rollbar.com
package rosezipper

Generic zipper implementation for Data.Tree A Haskell datastructure for working with locations in trees or forests.
package rss

A library for generating RSS 2.0 feeds. This library allows you to generate RSS 2.0 feeds.
package runmemo

A simple memoization helper library This library encourages you to do memoization in three separate steps:
1. Create a memoizable function
2. Create or select an appropriate memoizer
3. Run the memoizer on the memoizable function
Let's start with the first. When you create a memoizable function, you should use the self convention, which is that the first input to the function is self, and all recursive calls are replaced with self. One common convention that goes well with the self convention is using a helper function go, like so:
```
fib :: Memoizable (Integer -> Integer)
fib self = go
where go 0 = 1
go 1 = 1
go n = self (n-1) + self (n-2)
```
Now for the second. For this example, we need a Memoizer that can handle an Integer input, and an Integer output. Data.MemoCombinators provides integral, which handles any Integral input, and any output. Data.MemoUgly provides memo, which can memoize any function a -> b, given an Ord instance for a. Third, let's run our memoizers! Since we have decoupled the definition of the memoized function from its actual memoization, we can create multiple memoized versions of the same function if we so desire.
```
import qualified Data.MemoUgly as Ugly
import qualified Data.MemoCombinators as MC

fibUgly :: Integer -> Integer
fibUgly = runMemo Ugly.memo fib

fibMC :: Integer -> Integer
fibMC = runMemo MC.integral fib
```
You could easily do the same with Data.MemoTrie.memo, Data.Function.Memoize.memoize, etc. Using this technique, you can create local memoized functions whose memo tables are garbage collected as soon as they are no longer needed.

Page 320 of many | Previous | Next