Hoogle Search

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

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.

Pre-signed Amazon S3 URLs s3-signer creates cryptographically secure Amazon S3 URLs that expire within a user-defined period. It allows uploading and downloading of content from Amazon S3. Ideal for AJAX direct-to-s3 uploads via CORS and secure downloads. Web framework agnostic with minimal dependencies.

module Main where
import           Network.S3
main :: IO ()
main = print =<< generateS3URL credentials request
where
credentials = S3Keys "<public-key-goes-here>" "<secret-key-goes-here>"
request     = S3Request S3GET "application/extension" "bucket-name" "file-name.extension" 3 -- three seconds until expiration

Result

S3URL "https://bucket-name.s3.amazonaws.com/file-name.extension?AWSAccessKeyId=<public-key-goes-here>&Expires=1402346638&Signature=1XraY%2Bhp117I5CTKNKPc6%2BiihRA%3D"

package safe-foldable

Safe wrappers for null-partial Foldable operations Safe wrappers for null-partial Foldable operations
package safeio

Write output to disk atomically This package implements utilities to perform atomic output so as to avoid the problem of partial intermediate files.

Page 322 of many | Previous | Next