prolens: Profunctor-based lightweight implementation of optics

[ data, lenses, library, mpl, optics ] [ Propose Tags ]

Lightweight and performance implementation of optics — lenses, prisms, traversals.

The library uses hardcore abstractions internally, but provides beginner-friendly, composable and convenient interface for working with data structures.


[Skip to Readme]
Versions [faq] 0.0.0.0
Change log CHANGELOG.md
Dependencies base (>=4.12.0.0 && <4.15) [details]
License MPL-2.0
Copyright 2020 Kowainik
Author Veronika Romashkina, Dmitrii Kovanikov
Maintainer Kowainik <xrom.xkov@gmail.com>
Category Data, Optics, Lenses
Home page https://github.com/kowainik/prolens
Bug tracker https://github.com/kowainik/prolens/issues
Source repo head: git clone https://github.com/kowainik/prolens.git
Uploaded by shersh at 2020-10-13T16:34:48Z
Distributions NixOS:0.0.0.0
Downloads 33 total (3 in the last 30 days)
Rating 2.0 (votes: 1) [estimated by Bayesian average]
Your Rating
  • λ
  • λ
  • λ
Status Hackage Matrix CI
Docs uploaded by user
Build status unknown [no reports yet]

Modules

[Index] [Quick Jump]

Downloads

Maintainer's Corner

For package maintainers and hackage trustees


Readme for prolens-0.0.0.0

[back to package description]

prolens

Prolens Logo

GitHub CI Hackage MPL-2.0 license

The prolens package is a Haskell library with a minimal and lightweight implementation of optics. Optic is a high-level concept for values that provide composable access to different parts of structures.

Prolens implements the following optics:

  • Lens — composable getters and setters
  • Prism — composable constructors and deconstructors
  • Traversal — composable data structures visitors

Goals

We created the prolens project in pursuit of the following goals:

  1. Education. Teach others how to implement and work with profunctor optics. This also means that some underlying types or type variables have different unconventional names
  2. Learning. Explore new concepts ourselves and understand better abstractions used in the implementation.
  3. Minimalism. Keep the number of dependencies, features and code low, but still solve common problems.
  4. Performance. Despite being minimalist, implement optics so they are as fast as manual and clumsy pattern matching.
  5. Exploration. Understand how different modern Haskell features can work on improving interface and bring new flavour into standard approaches. Because of this, we implement our own Profunctor typeclass with the QuantifiedConstraints feature, which is not present in any other library at the moment.
  6. Profunctors. We use profunctor encoding of optics because it has more elegant design with fewer surprises.

Features

  1. Lightweight. Only base in dependencies. The project itself also has a rather small amount of code.
  2. Fast. Despite being lightweight, prolens provides a performant API. We use the inspection-testing library to guarantee that our implementation of optics compiles to the same code as plain Haskell getters, record-update syntax and pattern matching.
  3. Excellent documentation. The prolens library contains a mini-tutorial on optics, enough to understand how and when to use basic lenses and prisms.
  4. Beginner-friendly. The abstractions in the implementation are hardcore, but our documentation presents the concept in a beginner-friendly and approachable manner.
  5. Lawful. We use property-based testing to make sure that laws of all underlying abstractions are verified.

How to use

prolens is compatible with the latest GHC compiler versions starting from 8.6.5.

In order to start using prolens in your project, you will need to set it up with the three easy steps:

  1. Add the dependency on prolens in your project's .cabal file. For this, you should modify the build-depends section by adding the name of this library. After the adjustment, this section could look like this:

    build-depends: base ^>= 4.14
                 , prolens ^>= 0.0
    
  2. In the module where you wish to use composable getters and setters, you should add the import:

    import Prolens (Lens', lens, view)
    
  3. Now you can use the types and functions from the library:

    data User = User
        { userName :: String
        , userAge  :: Int
        }
    
    nameL :: Lens' User String
    nameL = lens userName (\u new -> u { userName = new })
    
    main :: IO ()
    main = putStrln $ view nameL (User "Johnny" 27)
    

Usage with Stack

If prolens is not available on your current Stackage resolver yet, fear not! You can still use it from Hackage by adding the following to the extra-deps section of your stack.yaml file:

extra-deps:
  - prolens-0.0.0.0

Comparison to other libraries

  1. lens

    It is the most mature Haskell library for optics. lens provides a richer interface, but it is heavyweight and based on Van Laarhoven (VL) encoding of lenses.

  2. microlens

    A lightweight implementation of optics compatible with lens. microlens is also minimalistic, but it doesn't provide prisms and is based on VL encoding.

  3. optics

    The optics library uses the profunctor encoding. It provides much more features than prolens, but at the same time it's heavyweight. Also, optics uses an opaque representation of optics (e.g. they are wrapped in a newtype), which means that they are composed using the custom operator %, while in prolens optics are type aliases to functions and can be easily composed with the dot . operator.

  4. profunctor-optics

    This library is also based on profunctor encoding (as the name suggests) and provides optics as aliases to functions. But it is more heavyweight, though it provides more features.

In addition to this per-library comparison, prolens has a few unique features:

  • Beginner-friendly documentation with usage examples
  • Usage of inspection-testing to guarantee the performance of optics
  • Property-based tests of lens and typeclasses laws to make sure that all abstractions behave properly

Acknowledgement

  • Edward Kmett for lenses and profunctor typeclasses
  • Well-Typed for the implementation of optics