haxl: A Haskell library for efficient, concurrent, and concise data access.

This is a package candidate release! Here you can preview how this package release will appear once published to the main package index (which can be accomplished via the 'maintain' link below). Please note that once a package has been published to the main package index it cannot be undone! Please consult the package uploading documentation for more information.

[maintain] [Publish]

Warnings:

'ghc-options: -O2' is rarely needed. Check that it is giving a real benefit and not just imposing longer compile times on your users.
These packages miss upper bounds: - deepseq - ghc-prim - hashtables - transformers Please add them, using `cabal gen-bounds` for suggestions. For more information see: https://pvp.haskell.org/
'ghc-options: -fprof*' profiling flags are typically not appropriate for a distributed library package. These flags are useful to profile this package, but when profiling other packages that use this one these flags clutter the profile output with excessive detail. If you think other packages really want to see cost centres from this package then use '-fprof-auto-exported' which puts cost centres only on exported functions. Alternatively, if you want to use this, make it conditional based on a Cabal configuration flag (with 'manual: True' and 'default: False') and enable that flag during development.

Haxl is a library and EDSL for efficient scheduling of concurrent data accesses with a concise applicative API.

To use Haxl, you need to implement one or more data sources, which provide the means for accessing remote data or other I/O that you want to perform using Haxl.

Haxl provides two top-level modules:

Data-source implementations import Haxl.Core,
Client code import your data sources and Haxl.Prelude, or some other client-level API that you provide.

[Skip to Readme]

Properties

Versions	0.1.0.0, 0.2.0.0, 0.3.0.0, 0.3.1.0, 0.4.0.0, 0.4.0.1, 0.4.0.2, 0.5.0.0, 0.5.1.0, 2.0.0.0, 2.0.1.0, 2.0.1.1, 2.1.2.0, 2.3.0.0, 2.4.0.0, 2.5.1.0, 2.5.1.0
Change log	changelog.md
Dependencies	aeson (>=0.6 && <2.1), base (>=4.10 && <5), binary (>=0.7 && <0.10), bytestring (>=0.9 && <0.12), containers (>=0.5 && <0.7), deepseq, exceptions (>=0.8 && <0.11), filepath (>=1.3 && <1.5), ghc-prim, hashable (>=1.2 && <1.5), hashtables (>=1.2.3.1), haxl, optparse-applicative, pretty (>=1.1 && <1.2), stm (>=2.4 && <2.6), text (>=1.2.1.0 && <1.3), time (>=1.4 && <1.12), transformers, unordered-containers (>=0.2 && <0.3), vector (>=0.10 && <0.13) [details]
License	BSD-3-Clause
Copyright	Copyright (c) 2014-present, Facebook, Inc.
Author	Facebook, Inc.
Maintainer	The Haxl Team <haxl-team@fb.com>
Category	Concurrency
Home page	https://github.com/facebook/Haxl
Bug tracker	https://github.com/facebook/Haxl/issues
Uploaded	by SimonMarlow at 2024-06-08T15:22:01Z

Modules

Haxl
- Haxl.Core
  - Haxl.Core.CallGraph
  - Haxl.Core.DataCache
  - Haxl.Core.DataSource
  - Haxl.Core.Exception
  - Haxl.Core.Fetch
  - Haxl.Core.Flags
  - Haxl.Core.Memo
  - Haxl.Core.Monad
  - Haxl.Core.Parallel
  - Haxl.Core.Profile
  - Haxl.Core.RequestStore
  - Haxl.Core.Run
  - Haxl.Core.ShowP
  - Haxl.Core.StateStore
  - Haxl.Core.Stats
- DataSource
  - Haxl.DataSource.ConcurrentIO
- Haxl.Prelude

Flags

Automatic Flags

Name	Description	Default
bench		Disabled

Use -f <flag> to enable a flag, or -f -<flag> to disable that flag. More info

Downloads

haxl-2.5.1.0.tar.gz [browse] (Cabal source package)
Package description (as included in the package)

Maintainer's Corner

Package maintainers

SimonMarlow, algoriddle, niteria

For package maintainers and hackage trustees

edit package information

Readme for haxl-2.5.1.0

[back to package description]

Haxl

Haxl is a Haskell library that simplifies access to remote data, such as databases or web-based services. Haxl can automatically

batch multiple requests to the same data source,
request data from multiple data sources concurrently,
cache previous requests,
memoize computations.

Having all this handled for you behind the scenes means that your data-fetching code can be much cleaner and clearer than it would otherwise be if it had to worry about optimizing data-fetching. We'll give some examples of how this works in the pages linked below.

There are two Haskell packages here:

haxl: The core Haxl framework
haxl-facebook (in [https://github.com/facebook/Haxl/tree/master/example/facebook](example/facebook)): An (incomplete) example data source for accessing the Facebook Graph API

To use Haxl in your own application, you will likely need to build one or more data sources: the thin layer between Haxl and the data that you want to fetch, be it a database, a web API, a cloud service, or whatever.

There is a generic datasource in "Haxl.DataSource.ConcurrentIO" that can be used for performing arbitrary IO operations concurrently, given a bit of boilerplate to define the IO operations you want to perform.

The haxl-facebook package shows how we might build a Haxl data source based on the existing fb package for talking to the Facebook Graph API.

Where to go next?

The Story of Haxl explains how Haxl came about at Facebook, and discusses our particular use case.
An example Facebook data source walks through building an example data source that queries the Facebook Graph API concurrently.
Fun with Haxl (part 1) Walks through using Haxl from scratch for a simple SQLite-backed blog engine.
The N+1 Selects Problem explains how Haxl can address a common performance problem with SQL queries by automatically batching multiple queries into a single query, without the programmer having to specify this behavior.
Haxl Documentation on Hackage.
There is no Fork: An Abstraction for Efficient, Concurrent, and Concise Data Access, our paper on Haxl, accepted for publication at ICFP'14.

Contributing

We welcome contributions! See CONTRIBUTING for details on how to get started, and our Code of Conduct.

License

Haxl uses the BSD 3-clause License, as found in the LICENSE file.