This is a weakref map for Go 1.18, with some inspiration from @urlhttps://github.com/xeus2001/go-weak,xeus2001's weakref implementation.

Package go4.org/unsafe/assume-no-moving-gc exists so you can depend on it from unsafe code that wants to declare that it assumes that the Go runtime does not use a moving garbage collector. Specifically, it asserts that the caller is playing stupid games with the addresses of heap-allocated values. It says nothing about values that Go's escape analysis keeps on the stack. Ensuring things aren't stack-allocated is the caller's responsibility.

This package provides a GTK4 bindings generator for Go.

This is an industrial-strength monadic parser combinator library. Megaparsec is a feature-rich package that tries to find a nice balance between speed, flexibility, and quality of parse errors.

This library provides tools for reading and manipulating the .cabal file format.

Generate Haskell bindings for GObject Introspection capable libraries. This includes most notably Gtk+, but many other libraries in the GObject ecosystem provide introspection data too.

Included are some folds and maps I've found useful in parsing XML data.

This package provides a pure interface for compressing and decompressing LZMA (Lempel–Ziv–Markov chain algorithm) streams of data represented as lazy ByteStrings. A monadic incremental interface is provided as well. This package relies on the liblzma C library.

This package implements an SMTLIB based Horn-Clause\/Logical Implication constraint solver used for Liquid Types. . The package includes: . 1. Types for Expressions, Predicates, Constraints, Solutions 2. Code for solving constraints . Requirements . In addition to the .cabal dependencies you require . * A Z3 (<http://z3.codeplex.com>) or CVC4 (<http://cvc4.cs.nyu.edu>) binary.

This package gives you access to the set of operating system services standardised by <http://pubs.opengroup.org/onlinepubs/9699919799/ POSIX.1-2008> (or the IEEE Portable Operating System Interface for Computing Environments - IEEE Std. 1003.1). . The package is not supported under Windows.

Please see the README on Github at <https://github.com/IvanMalison/dbus-hslogger#readme>

This library allows an application to extend the 'global state' hidden inside the IO monad with semi-arbitrary data. Data is required to be 'Typeable'. The library provides an essentially unbounded number of key-value stores indexed by strings, with each key within the stores also being a string.

This library implements an SMT-LIB backend (in the sense of the smtlib-backends package) which runs solvers as external processes.

@pipes-group@ uses @FreeT@ and lenses to group streams into sub-streams. Notable features include: . * /Perfect Streaming/: Group elements without collecting them into memory . * /Lens Support/: Use lenses to simplify many common operations . @Pipes.Group@ contains the full documentation for this library. . Read @Pipes.Group.Tutorial@ for an extensive tutorial.

This package lacks a description. Run "info '(guix) Synopses and Descriptions'" for more information.

Many recursive functions share the same structure, e.g. pattern-match on the input and, depending on the data constructor, either recur on a smaller input or terminate the recursion with the base case. Another one: start with a seed value, use it to produce the first element of an infinite list, and recur on a modified seed in order to produce the rest of the list. Such a structure is called a recursion scheme. Using higher-order functions to implement those recursion schemes makes your code clearer, faster, and safer. See README for details.

Simple and high performance IO toolkit for Haskell, including file system, network, ipc and more!

Cairo is a library to render high quality vector graphics. There exist various backends that allows rendering to Gtk windows, PDF, PS, PNG and SVG documents, amongst others.

This package provides portable implementations of parts of the unix package. This package re-exports the unix package when available. When it isn't available, portable implementations are used.

@pipes-parse@ builds upon the @pipes@ library to provide shared parsing idioms and utilities: . * /Leftovers/: Save unused input for later consumption . * /Leftover propagation/: Leftovers are propagated backwards perfectly . * /Connect and Resume/: Use @StateT@ to save unused input for later . * /Termination Safety/: Detect and recover from end of input . @Pipes.Parse@ contains the full documentation for this library. . Read @Pipes.Parse.Tutorial@ for an extensive tutorial.

For upgrading to streamly-0.9.0+ please read the <https://github.com/composewell/streamly/blob/streamly-0.10.0/docs/User/Project/Upgrading-0.8-to-0.9.md Streamly-0.9.0 upgrade guide>. . Streamly is a standard library for Haskell that focuses on C-like performance, modular combinators, and streaming data flow model. Streamly consists of two packages, the <https://hackage.haskell.org/package/streamly-core streamly-core> package provides functionality that depends only on boot libraries, and the <https://hackage.haskell.org/package/streamly streamly> package provides additional functionality like concurrency, time, lifted exceptions, and networking. For unified documentation visit <https://streamly.composewell.com the streamly website>. . Streamly provides unified, modular building blocks to build high-performance, concurrent, scalable applications in Haskell . Stream fusion optimizations in streamly enable exceptional modularity with high performance comparable to C. Streamly complements the Haskell <https://hackage.haskell.org/package/base base> package, supplying additional functionality to quickly build general-purpose applications in Haskell. For high-level functionality built over streamly like streaming OS processes, shell programming, GNU coreutils, statistics, and compression libraries please see the <https://streamly.composewell.com/ecosystem.html streamly ecosystem packages>. . Performance with modularity: . * Performance on par with C (<https://github.com/composewell/streaming-benchmarks Benchmarks>) * API close to standard Haskell lists (<https://github.com/composewell/streamly-examples Examples>) * Declarative concurrency with automatic scaling * Filesystem, fsnotify, network, and Unicode support included * Fast binary serialization (with optional JSON like features) * More functionality is provided via many (<https://streamly.composewell.com/ecosystem.html ecosystem packages>) . Unified and powerful abstractions: . * Unifies streams, arrays, folds, and parsers * Unifies @Data.List@, @list-t@, and @logict@ with streaming * Unifies concurrency with standard streaming abstractions * Unifies reactive, time-domain programming with streaming * Unifies binary serialization and unboxed arrays * Interworks with other streaming libraries.

This package provides array, slice and text operations.

This package provides a plugin to verify Haskell programs. But most likely you should be using the [liquidhaskell package](https://hackage.haskell.org/package/liquidhaskell) instead, which rexports this plugin together with necessary specifications for definitions in the boot libraries.