https://github.com/obsidiansystems/dependent-map

Dependently-typed finite maps (partial dependent products)
https://github.com/obsidiansystems/dependent-map

Last synced: 8 days ago
JSON representation

Dependently-typed finite maps (partial dependent products)

• Host: GitHub
• URL: https://github.com/obsidiansystems/dependent-map
• Owner: obsidiansystems
• License: other
• Created: 2011-02-09T00:35:59.000Z (over 14 years ago)
• Default Branch: master
• Last Pushed: 2025-02-11T20:42:55.000Z (3 months ago)
• Last Synced: 2025-04-03T10:11:14.376Z (about 2 months ago)
• Language: Haskell
• Homepage:
• Size: 170 KB
• Stars: 65
• Watchers: 22
• Forks: 33
• Open Issues: 11
• Metadata Files:
  • Readme: README.md
  • Changelog: ChangeLog.md
  • License: LICENSE

Awesome Lists containing this project

README

        
dependent-map [![Build Status](https://github.com/obsidiansystems/dependent-map/actions/workflows/haskell-ci.yml/badge.svg)](https://github.com/obsidiansystems/dependent-map/actions/workflows/haskell-ci.yml) [![Hackage](https://img.shields.io/hackage/v/dependent-map.svg)](http://hackage.haskell.org/package/dependent-map)

==============

This library defines a dependently-typed finite map type. It is derived from `Data.Map.Map` in the `containers` package, but rather than (conceptually) storing pairs indexed by the first component, it stores `DSum`s (from the `dependent-sum` package) indexed by tag. For example

```haskell

{-# LANGUAGE FlexibleInstances #-}

{-# LANGUAGE GADTs #-}

{-# LANGUAGE MultiParamTypeClasses #-}

{-# LANGUAGE TemplateHaskell #-}

{-# LANGUAGE TypeFamilies #-}

module Example where

import Data.Constraint.Extras.TH (deriveArgDict)

import Data.Dependent.Map (DMap, fromList, singleton, union, unionWithKey)

import Data.Dependent.Sum ((==>))

import Data.Functor.Identity (Identity(..))

import Data.GADT.Compare.TH (deriveGCompare, deriveGEq)

import Data.GADT.Show.TH (deriveGShow)

data Tag a where

  StringKey :: Tag String

  IntKey    :: Tag Int

  DoubleKey :: Tag Double

deriveGEq ''Tag

deriveGCompare ''Tag

deriveGShow ''Tag

deriveArgDict ''Tag

x :: DMap Tag Identity

x = fromList [DoubleKey ==> pi, StringKey ==> "hello there"]

y :: DMap Tag Identity

y = singleton IntKey (Identity 42)

z :: DMap Tag Identity

z = y `union` fromList [DoubleKey ==> -1.1415926535897931]

addFoo :: Tag v -> Identity v -> Identity v -> Identity v

addFoo IntKey (Identity x) (Identity y) = Identity $ x + y

addFoo DoubleKey (Identity x) (Identity y) = Identity $ x + y

addFoo _ x _ = x

main :: IO ()

main = mapM_ print

  [ x, y, z

  , unionWithKey addFoo x z

  ]

```