はてなブックマーク

Haskell Debugger A library for debugging Haskell programs. To use, take the functions that you are interested in debugging, e.g.: module QuickSort(quicksort) where import Data.List quicksort :: Ord a => [a] -> [a] quicksort [] = [] quicksort (x:xs) = quicksort lt ++ [x] ++ quicksort gt where (lt, gt) = partition (<= x) xs Turn on the TemplateHaskell, ViewPatterns and PartialTypeSignatures extensio

If you're using GHC.Generics, you should consider using the http://hackage.haskell.org/package/generic-deriving package, which contains many useful generic functions. Since: base-4.6.0.0 Synopsisdata V1 (p :: k)data U1 (p :: k) = U1newtype Par1 p = Par1 {unPar1 :: p}newtype Rec1 (f :: k -> Type) (p :: k) = Rec1 {unRec1 :: f p}newtype K1 i c (p :: k) = K1 {unK1 :: c}newtype M1 i (c :: Meta) (f :: k

mwc-random: Fast, high quality pseudo random number generation This package contains code for generating high quality random numbers that follow either a uniform or normal distribution. The generated numbers are suitable for use in statistical applications. . The uniform PRNG uses Marsaglia's MWC256 (also known as MWC8222) multiply-with-carry generator, which has a period of 2^8222 and fares well

CGrep: a context-aware grep for source codes Usage Cgrep 8.0.0. Usage: cgrep [OPTION] [PATTERN] files... cgrep [OPTIONS] [ITEM] Pattern: -f --file=FILE Read PATTERNs from file (one per line) -w --word Force word matching -p --prefix Force prefix matching -s --suffix Force suffix matching -e --edit Use edit distance -G --regex Use regex matching (posix) -P --pcre Use regex matching (pcre) -i --igno

Downloadstype-combinators-0.2.4.3.tar.gz [browse] (Cabal source package)Package description (revised from the package)Note: This package has metadata revisions in the cabal description newer than included in the tarball. To unpack the package including the revisions, use 'cabal get'. Maintainer's Corner Package maintainers KyleCarter For package maintainers and hackage trustees edit package inform

Please see the documentation at https://docs.haskellstack.org for usage information. If building a stack executable for distribution, please download the source code from https://github.com/commercialhaskell/stack/releases and build it using Stack itself in order to ensure identical behaviour to official binaries. This package on Hackage is provided for convenience and bootstrapping purposes. Note

Write terminal user interfaces (TUIs) painlessly with brick! You write an event handler and a drawing function and the library does the rest. module Main where import Brick ui :: Widget () ui = str "Hello, world!" main :: IO () main = simpleMain uiTo get started, see: The README The Brick user guide The demonstration programs in the programs directory This package deprecates vty-ui. [Skip to Readm

OpenGLRaw is a raw Haskell binding for the OpenGL 4.6 graphics system and lots of OpenGL extensions. It is basically a 1:1 mapping of OpenGL's C API, intended as a basis for a nicer interface. OpenGLRaw offers access to all necessary functions, tokens and types plus a general facility for loading extension entries. The module hierarchy closely mirrors the naming structure of the OpenGL extensions,

This lens tutorial targets Haskell beginners and assumes only basic familiarity with Haskell. By the end of this tutorial you should: understand what problems the lens library solves,know when it is appropriate to use the lens library,be proficient in the most common lens idioms,understand the drawbacks of using lenses, and:know where to look if you wish to learn more advanced tricks.If you would

This package provides a plugin provider for neovim. It allows you to write plugins for one of the great editors of our time in the best programming language of our time! ;-) . You should find all the documentation you need inside the Neovim module. Most other modules are considered internal, so don't be annoyed if using things from there may break your code! . The following modules may also be of

haskellscript: Command line tool for running Haskell scripts with a hashbang. This tool provides the ability to script in a shell with Haskell (including dependencies) the same way that has been possible with bash scripts or Python. Examples Print out JSON constructed with Aeson https://github.com/seanparsons/haskellscript/blob/master/Example.hs Lookup weather for your current IP address https://g

Use turtle if you want to write light-weight and maintainable shell scripts. turtle embeds shell scripting directly within Haskell for three main reasons: Haskell code is easy to refactor and maintain because the language is statically typedHaskell is syntactically lightweight, thanks to global type inferenceHaskell programs can be type-checked and interpreted very rapidly (< 1 second)These featur

An SQL-generating DSL targeting PostgreSQL. Allows Postgres queries to be written within Haskell in a typesafe and composable fashion. [Skip to Readme] OpaleyeOpaleye.AdaptorsOpaleye.AggregateOpaleye.BinaryOpaleye.ColumnOpaleye.DistinctOpaleye.ExistsExperimentalOpaleye.Experimental.EnumOpaleye.FieldOpaleye.FunctionalJoinOpaleye.InferrableInternalOpaleye.Internal.AggregateOpaleye.Internal.BinaryOpa

An AST for the "the good parts" of Javascript (as defined by Douglas Crockford) and a pretty printer for that AST. Designed to be the target of a code generator. Does not include a parser.

SourceContentsIndexjs-good-parts-0.0.7: Javascript: The Good Parts -- AST & Pretty Printer In Chapter 2 of "JavaScript: The Good Parts", Douglas Crockford presents a concrete grammar for "the good parts" of JavaScript. This module provides an abstract grammar for those good parts. Henceforth, we abbreviate this language to JS:TGP Crockford presents the grammar as a series of railroad diagrams. The

This module provides support for raising and catching both built-in and user-defined exceptions. In addition to exceptions thrown by IO operations, exceptions may be thrown by pure code (imprecise exceptions) or by external events (asynchronous exceptions), but may only be caught in the IO monad. For more details, see: A semantics for imprecise exceptions, by Simon Peyton Jones, Alastair Reid, Ton

Extensible, type-safe unions. This package is very new and likely to change. Basic usage example (language tags ommitted due to https://github.com/haskell/cabal/issues/774) import Data.OpenUniontype MyUnion = Union '[Char, Int, [()]]showMyUnion :: MyUnion -> String showMyUnion = (\(c :: Char) -> "char: " ++ show c) @> (\(i :: Int) -> "int: " ++ show i) @> (\(l :: [()]) -> "list length: " ++ show (

formatting: Combinator-based type-safe formatting (like printf() or FORMAT) Combinator-based type-safe formatting (like printf() or FORMAT), modelled from the HoleyMonoids package. See the README at https://github.com/AJChapman/formatting#readme for more info. [Skip to Readme]

loops is a library for fast, imperative-style loops with a clean syntax. Features Fast, imperative-style loops with a clean syntax. Bind (>>=) nests loops, so in do-notation, each subsequent line is nested inside loops that appear above it. Iteration over common data structures, like lists and vectors. Robust performance because there is no reliance on fusion. NEW! Loop-unrolling to arbitrary dept

This package implements extensible effects, an alternative to monad transformers. The original paper can be found at http://okmij.org/ftp/Haskell/extensible/exteff.pdf. The main differences between this library and the one described in the paper are that this library does not use the Typeable type class, does not require that effects implement the Functor type class, and has a simpler API for hand

This library can help you to get some data read and written in Office Open XML xlsx format. Small subset of xlsx format is supported. For examples look into Codec.Xlsx. Format is covered by ECMA-376 standard: https://ecma-international.org/publications-and-standards/standards/ecma-376/ 4th edition of the standard with the transitional schema is used for this library.

This toolbox provides everything you need to get a quick start into web hacking with haskell: fast routing middleware json sessions cookies database helper csrf-protection A tutorial is available at spock.li [Skip to Readme]

Provides a monadic API for efficient concurrency based on a thread pool. The implementation is based on a "parallel-io" library.

The Prelude: a standard module. The Prelude is imported by default into all Haskell modules unless either there is an explicit import statement for it, or the NoImplicitPrelude extension is enabled. Synopsisdata Bool= False| True(&&) :: Bool -> Bool -> Bool(||) :: Bool -> Bool -> Boolnot :: Bool -> Boolotherwise :: Booldata Maybe a= Nothing| Just amaybe :: b -> (a -> b) -> Maybe a -> bdata Either

This is an FRP library with the following characteristics: classical: it has first-class signals synchronous: it has a clear notion of simultaneous events higher-order: signals inside signals can be flattened to get a switching behavior push-based: inactive events has zero runtime costs This package is in the alpha stage.