https://github.com/athanclark/dag

A well-typed Directed Acyclic Graph in Haskell
https://github.com/athanclark/dag

dag directed-acyclic-graph graph haskell type-level-programming

Last synced: 11 days ago
JSON representation

A well-typed Directed Acyclic Graph in Haskell

• Host: GitHub
• URL: https://github.com/athanclark/dag
• Owner: athanclark
• License: bsd-3-clause
• Created: 2015-01-07T18:11:25.000Z (about 10 years ago)
• Default Branch: master
• Last Pushed: 2015-01-25T05:14:44.000Z (almost 10 years ago)
• Last Synced: 2023-04-10T16:35:09.765Z (over 1 year ago)
• Topics: dag, directed-acyclic-graph, graph, haskell, type-level-programming
• Language: Haskell
• Size: 281 KB
• Stars: 11
• Watchers: 5
• Forks: 2
• Open Issues: 1
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

README

        
[![Stories in Ready](https://badge.waffle.io/athanclark/dag.png?label=ready&title=Ready)](https://waffle.io/athanclark/dag)

dag

===

> Directed Acyclic Graphs for Haskell

## Description

This is a type-safe directed acyclic graph library for Haskell. This library

differs from others in a number of ways:

- Edge construction is incremental, creating a "schema":

  ```haskell

  {-# LANGUAGE DataKinds #-}

  import Data.Graph.DAG.Edge

  -- | Edges are statically defined:

  edges = ECons (Edge :: EdgeValue "foo" "bar") $

    ECons (Edge :: EdgeValue "bar" "baz") $

    ECons (Edge :: EdgeValue "foo" "baz")

    unique -- ENil, but casted for uniquely edged graphs

  ```

- The nodes are separate from edges; graph may be not connected:

  ```haskell

  data Cool = AllRight

            | Radical

            | SuperDuper

  graph = GCons "foo" AllRight $

    GCons "bar" Radical $

    GCons "baz" SuperDuper $

    GNil edges

  ```

- Type safety throughout edge construction:

  ```haskell

  *Data.Graph.DAG> :t edges

  edges

    :: EdgeSchema

         '['EdgeType "foo" "bar", 'EdgeType "bar" "baz",

           'EdgeType "foo" "baz"] -- Type list of edges

         '['("foo", '["bar", "baz"]), '("bar", '["baz"])] -- potential loops

         'True -- uniqueness

  ```

- Various type-level computation

  ```haskell

  *Data.Graph.DAG> :t getSpanningTrees $ edges

  getSpanningTrees $ edges

    :: Data.Proxy.Proxy

         '['Node "foo" '['Node "bar" '['Node "baz" '[]],

                         'Node "baz" '[]],

           'Node "bar" '['Node "baz" '[]],

           'Node "baz" '[]]

  *Data.Graph.DAG> reflect $ getSpanningTrees $ edges

  [Node "foo" [Node "bar" [Node "baz" []]

              ,Node "baz" []]

  ,Node "bar" [Node "baz" []]

  ,Node "baz" []]

  ```

This library is still very naive, but it will give us compile-time enforcement

of acyclicity in these graphs - ideal for dependency graphs.

## Usage

You will need `-XDataKinds` for the type-level symbols:

```haskell

{-# LANGUAGE DataKinds #-}

import Data.Graph.DAG

import GHC.TypeLits

...

```