Module

Hylograph.Unified

Package: purescript-hylograph-selection
Repository: afcondon/purescript-hylograph-selection

PSD3.Unified - Unified Data DSL for Visualization and Computation

This module re-exports the unified DSL components, providing a single import for the new unified system.

Quick Start

import Hylograph.Unified

-- Define a computation that works in both viz and spreadsheet
growthAnalysis :: forall repr. DataDSL repr => repr (Array Number) -> repr Number
growthAnalysis data_ = avgA (mapA (\x -> x * 1.1) data_)

-- Use Display for formatting
myDisplay :: Display Number String
myDisplay = roundD 2 >>> showNumD >>> suffixD "%"

-- Create attributes with Display
myAttr :: Attribute DataPoint
myAttr = attr "cx" _.x (scaleD 10.0 >>> showNumD)

Module Organization

Hylograph.Unified.DataDSL - Core type class for data operations
Hylograph.Unified.Display - Profunctor-based display formatting
Hylograph.Unified.Attribute - Bridge to attribute system
Hylograph.Unified.Sugar - Syntactic sugar operators

Re-exports from Hylograph.Unified.Attribute

#yD Source

yD :: forall datum. (datum -> Number) -> Display Number String -> Attribute datum

y attribute with display formatting

#xD Source

xD :: forall datum. (datum -> Number) -> Display Number String -> Attribute datum

x attribute with display formatting

#widthD Source

widthD :: forall datum. (datum -> Number) -> Display Number String -> Attribute datum

width attribute with display formatting

#transformD Source

transformD :: forall datum. (datum -> String) -> Attribute datum

transform attribute with display formatting

#toAttribute Source

toAttribute :: forall datum a. AttributeName -> (datum -> a) -> Display a String -> Attribute datum

Convert a Display-based spec to an Attribute

This is useful when you have a Display and want to use it with existing attribute-based code.

#textContentD Source

textContentD :: forall datum a. (datum -> a) -> Display a String -> Attribute datum

text content with display formatting

#strokeD Source

strokeD :: forall datum. (datum -> String) -> Attribute datum

stroke attribute with display formatting

#rD Source

rD :: forall datum. (datum -> Number) -> Display Number String -> Attribute datum

r (radius) attribute with display formatting

#opacityD Source

opacityD :: forall datum. (datum -> Number) -> Attribute datum

opacity attribute with display formatting

#heightD Source

heightD :: forall datum. (datum -> Number) -> Display Number String -> Attribute datum

height attribute with display formatting

#fromDisplay Source

fromDisplay :: forall a. AttributeName -> Display a String -> Attribute a

Create an attribute that just uses a Display for formatting

The extraction is identity - useful when datum is already the right type.

#fillD Source

fillD :: forall datum. (datum -> String) -> Attribute datum

fill attribute with display formatting

#cyD Source

cyD :: forall datum. (datum -> Number) -> Display Number String -> Attribute datum

cy attribute with display formatting

#cxD Source

cxD :: forall datum. (datum -> Number) -> Display Number String -> Attribute datum

cx attribute with display formatting

#attrStatic Source

attrStatic :: forall datum. String -> String -> Attribute datum

Create a static attribute (same for all data)

Example:

attrStatic "fill" "steelblue"
attrStatic "stroke-width" "2"

#attrIndexed Source

attrIndexed :: forall datum a. String -> (datum -> Int -> a) -> Display a String -> Attribute datum

Create an indexed attribute (uses datum and index)

Example:

attrIndexed "fill" (\d i -> if i `mod` 2 == 0 then "red" else "blue") idD

#attr Source

attr :: forall datum a. String -> (datum -> a) -> Display a String -> Attribute datum

Create an attribute from extraction function and display

This is the primary way to create attributes in the new style.

Example:

attr "cx" _.x (scaleD 10.0 >>> showNumD)
attr "fill" _.category idD
attr "opacity" _.importance (clampD 0.0 1.0 >>> showNumD)

Re-exports from Hylograph.Unified.DataDSL

#TypedCell Source

newtype TypedCell :: forall k. k -> Typenewtype TypedCell a

Type-safe cell reference with phantom type tracking the value type

Constructors

TypedCell CellAddr

#DataSource Source

data DataSource a

Data source - where data enters the computation pipeline

This is the "join point" - analogous to D3's selection.data()

Constructors

#CellAddr Source

type CellAddr = { col :: Int, row :: Int }

Cell address for spreadsheet sources

#DataDSL Source

class DataDSL :: (Type -> Type) -> Constraintclass DataDSL (repr :: Type -> Type)  where

The unified data operations type class

This class captures the fundamental operations on data that are shared between visualization and spreadsheet contexts.

Key insight: These operations are exactly what D3 data joins do, and also what spreadsheet formulas do. They're the same thing!

Members

num :: Number -> repr Number
Numeric literal
str :: String -> repr String
String literal
bool :: Boolean -> repr Boolean
Boolean literal
arr :: forall a. Array a -> repr (Array a)
Array literal
source :: forall a. DataSource a -> repr (Array a)
Data source - the "join point" where external data enters

In D3: selection.data(arr) In spreadsheet: cell range reference like A1:A10
mapA :: forall a b. (a -> b) -> repr (Array a) -> repr (Array b)
Map over array - the heart of D3 data joins

In D3: The template function in .join("rect").attr("height", d => d.value) In spreadsheet: =MAP(A1:A10, x => x * 2)
foldA :: forall a b. (b -> a -> b) -> b -> repr (Array a) -> repr b
Fold/reduce array to single value

In D3: .data(arr).reduce((acc, d) => acc + d.value, 0) In spreadsheet: =SUM(A1:A10), =PRODUCT(B1:B5)
filterA :: forall a. (a -> Boolean) -> repr (Array a) -> repr (Array a)
Filter array by predicate

In D3: .data(arr.filter(d => d.value > 0)) In spreadsheet: =FILTER(A1:A10, x => x > 0)
flatMapA :: forall a b. (a -> Array b) -> repr (Array a) -> repr (Array b)
FlatMap - map then flatten (for nested data)

This is the decompose in NestedJoin! In D3: Nested selections In spreadsheet: =FLATTEN(MAP(A1:A10, x => x.items))
zipWithA :: forall a b c. (a -> b -> c) -> repr (Array a) -> repr (Array b) -> repr (Array c)
Zip two arrays with combining function
headA :: forall a. repr (Array a) -> repr (Maybe a)
Get first element
add :: repr Number -> repr Number -> repr Number
Arithmetic operations (from NumExpr)
sub :: repr Number -> repr Number -> repr Number
mul :: repr Number -> repr Number -> repr Number
div :: repr Number -> repr Number -> repr Number
negate :: repr Number -> repr Number
concat :: repr String -> repr String -> repr String
String operations (from StringExpr)
lt :: repr Number -> repr Number -> repr Boolean
Comparison operations (from CompareExpr)
lte :: repr Number -> repr Number -> repr Boolean
gt :: repr Number -> repr Number -> repr Boolean
gte :: repr Number -> repr Number -> repr Boolean
eqNum :: repr Number -> repr Number -> repr Boolean
strEq :: repr String -> repr String -> repr Boolean
String comparison (from StringCompareExpr)
strNeq :: repr String -> repr String -> repr Boolean
and :: repr Boolean -> repr Boolean -> repr Boolean
Boolean operations (from BoolExpr)
or :: repr Boolean -> repr Boolean -> repr Boolean
not :: repr Boolean -> repr Boolean
ifThenElse :: forall a. repr Boolean -> repr a -> repr a -> repr a
Conditional

#TrigDSL Source

class TrigDSL :: (Type -> Type) -> Constraintclass (DataDSL repr) <= TrigDSL repr  where

Trigonometric operations - extension for visualization-specific math

Separated from DataDSL because spreadsheets rarely need trig, but polar/radial visualizations (chord diagrams, pie charts) do.

polarX :: forall repr. DataDSL repr => TrigDSL repr => repr Number -> repr Number -> repr Number
polarX r angle = r `mul` cos angle

Members

sin :: repr Number -> repr Number
cos :: repr Number -> repr Number
tan :: repr Number -> repr Number
asin :: repr Number -> repr Number
acos :: repr Number -> repr Number
atan :: repr Number -> repr Number
atan2 :: repr Number -> repr Number -> repr Number
pi :: repr Number

#sumA Source

sumA :: forall repr. DataDSL repr => repr (Array Number) -> repr Number

Sum numeric array

Spreadsheet equivalent: =SUM(range)

#productA Source

productA :: forall repr. DataDSL repr => repr (Array Number) -> repr Number

Product of numeric array

Spreadsheet equivalent: =PRODUCT(range)

#negateA Source

negateA :: forall repr. DataDSL repr => repr (Array Number) -> repr (Array Number)

Negate all values in array

Spreadsheet equivalent: =MAP(range, x => -x)

#minA Source

minA :: forall repr. DataDSL repr => repr (Array Number) -> repr Number

Minimum value

Spreadsheet equivalent: =MIN(range)

#maxA Source

maxA :: forall repr. DataDSL repr => repr (Array Number) -> repr Number

Maximum value

Spreadsheet equivalent: =MAX(range)

#countA Source

countA :: forall repr a. DataDSL repr => repr (Array a) -> repr Number

Count elements

Spreadsheet equivalent: =COUNT(range)

#avgA Source

avgA :: forall repr. DataDSL repr => repr (Array Number) -> repr Number

Average of numeric array

Spreadsheet equivalent: =AVERAGE(range)

#absA Source

absA :: forall repr. DataDSL repr => repr Number -> repr Number

Absolute value

Spreadsheet equivalent: =ABS(x)

Re-exports from Hylograph.Unified.Display

#Display Source

newtype Display a b

Display transformation from type a to type b

This is essentially a newtype around a -> b, but with a semantic meaning: it's a non-destructive presentation transformation.

The profunctor structure (contravariant in a, covariant in b) enables flexible composition and adaptation.

Constructors

Display (a -> b)

#yesNoD Source

yesNoD :: Display Boolean String

Boolean display: true -> "Yes", false -> "No"

#upperD Source

upperD :: Display String String

Convert to uppercase

#trimD Source

trimD :: Display String String

Trim whitespace

#thousandsD Source

thousandsD :: Display String String

Add thousands separators: 1234567 -> "1,234,567"

#suffixD Source

suffixD :: String -> Display String String

Add suffix

Example: suffixD "%" makes 50 display as 50%

#signedD Source

signedD :: Display Number String

Signed display: negative in parentheses (accounting style)

Example: -100 -> "(100)", 100 -> "100"

#showNumD Source

showNumD :: Display Number String

Default numeric display (smart formatting)

Integers display without decimal point
Floats display with minimal precision (trimmed trailing zeros)

#sciD Source

sciD :: Int -> Display Number String

Scientific notation

Example: sciD 2 makes 1234.5 display as 1.23e3

#scaleD Source

scaleD :: Number -> Display Number Number

Scale by a factor

Example: scaleD 100.0 for percentages (0.5 -> 50.0)

#runDisplay Source

runDisplay :: forall a b. Display a b -> a -> b

Run a display transformation

#roundD Source

roundD :: Int -> Display Number Number

Round to N decimal places

Example: roundD 2 makes 3.14159 display as 3.14

#rmapD Source

rmapD :: forall a b b'. (b -> b') -> Display a b -> Display a b'

Covariant map: change output type

Given a way to transform b to b', adapt a Display a b to Display a b'

#prefixD Source

prefixD :: String -> Display String String

Add prefix

Example: prefixD "$" makes 100 display as $100

#percentageD Source

percentageD :: Display Number String

Percentage display: 0.156 -> "15.6%"

#padRightD Source

padRightD :: Int -> Char -> Display String String

Pad right to width with character

#padLeftD Source

padLeftD :: Int -> Char -> Display String String

Pad left to width with character

#negateD Source

negateD :: Display Number Number

Negate

#lowerD Source

lowerD :: Display String String

Convert to lowercase

#lmapD Source

lmapD :: forall a a' b. (a' -> a) -> Display a b -> Display a' b

Contravariant map: change input type

Given a way to get a from a', adapt a Display a b to Display a' b

Example:

percentageD :: Display Number String
lmapD _.rate percentageD :: Display { rate :: Number } String

#intD Source

intD :: Display Number String

Integer display (truncates decimal part)

#idD Source

idD :: forall a. Display a a

Identity display (does nothing)

#floorD Source

floorD :: Display Number Number

Floor (round down)

#fixedD Source

fixedD :: Int -> Display Number String

Fixed decimal places

Example: fixedD 2 makes 3.1 display as 3.10

#dimapD Source

dimapD :: forall a a' b b'. (a' -> a) -> (b -> b') -> Display a b -> Display a' b'

Profunctor dimap: change both types

#currencyWithSymbol Source

currencyWithSymbol :: String -> Display Number String

Currency with custom symbol

#currencyD Source

currencyD :: Display Number String

Currency display (USD): 1234.56 -> "$1,234.56"

#composeD Source

composeD :: forall a b c. Display a b -> Display b c -> Display a c

Compose two displays (left to right)

f >>> g means: first apply f, then apply g

#compactD Source

compactD :: Display Number String

Compact display for large numbers

Example: 1500000 -> "1.5M", 1500 -> "1.5K"

#clampD Source

clampD :: Number -> Number -> Display Number Number

Clamp to range [lo, hi]

#ceilD Source

ceilD :: Display Number Number

Ceiling (round up)

#boolD Source

boolD :: Display Boolean String

Boolean display: true -> "true", false -> "false"

#absD Source

absD :: Display Number Number

Absolute value

#(>>>) Source

Operator alias for Hylograph.Unified.Display.composeD (left-associative / precedence 9)

Re-exports from Hylograph.Unified.Sugar

#subOp Source

subOp :: forall repr. DataDSL repr => repr Number -> repr Number -> repr Number

#subLit Source

subLit :: forall repr. DataDSL repr => repr Number -> Number -> repr Number

#strNeqOp Source

strNeqOp :: forall repr. DataDSL repr => repr String -> repr String -> repr Boolean

#strEqOp Source

strEqOp :: forall repr. DataDSL repr => repr String -> repr String -> repr Boolean

#s Source

s :: forall repr. DataDSL repr => String -> repr String

Short alias for str - creates a string literal Usage: s "hello"

#neg Source

neg :: forall repr. DataDSL repr => repr Number -> repr Number

#n Source

n :: forall repr. DataDSL repr => Number -> repr Number

Short alias for num - creates a numeric literal Usage: n 42.0

#mulOp Source

mulOp :: forall repr. DataDSL repr => repr Number -> repr Number -> repr Number

#mulLit Source

mulLit :: forall repr. DataDSL repr => repr Number -> Number -> repr Number

#lteOp Source

lteOp :: forall repr. DataDSL repr => repr Number -> repr Number -> repr Boolean

#ltOp Source

ltOp :: forall repr. DataDSL repr => repr Number -> repr Number -> repr Boolean

#ite Source

ite :: forall repr a. DataDSL repr => repr Boolean -> repr a -> repr a -> repr a

Short alias for ifThenElse - conditional expression Usage: ite (x <. n 0.0) (s "negative") (s "non-negative")

#gteOp Source

gteOp :: forall repr. DataDSL repr => repr Number -> repr Number -> repr Boolean

#gtOp Source

gtOp :: forall repr. DataDSL repr => repr Number -> repr Number -> repr Boolean

#eqOp Source

eqOp :: forall repr. DataDSL repr => repr Number -> repr Number -> repr Boolean

#divOp Source

divOp :: forall repr. DataDSL repr => repr Number -> repr Number -> repr Number

#divLit Source

divLit :: forall repr. DataDSL repr => repr Number -> Number -> repr Number

#concatOp Source

concatOp :: forall repr. DataDSL repr => repr String -> repr String -> repr String

#b Source

b :: forall repr. DataDSL repr => Boolean -> repr Boolean

Short alias for bool - creates a boolean literal Usage: b true

#addOp Source

addOp :: forall repr. DataDSL repr => repr Number -> repr Number -> repr Number

#addLit Source

addLit :: forall repr. DataDSL repr => repr Number -> Number -> repr Number

#(>=.) Source

Operator alias for Hylograph.Unified.Sugar.gteOp (non-associative / precedence 4)

#(>.) Source

Operator alias for Hylograph.Unified.Sugar.gtOp (non-associative / precedence 4)

#(===) Source

Operator alias for Hylograph.Unified.Sugar.strEqOp (non-associative / precedence 4)

#(==.) Source

Operator alias for Hylograph.Unified.Sugar.eqOp (non-associative / precedence 4)

#(<=.) Source

Operator alias for Hylograph.Unified.Sugar.lteOp (non-associative / precedence 4)

#(<.) Source

Operator alias for Hylograph.Unified.Sugar.ltOp (non-associative / precedence 4)

#(<+>) Source

Operator alias for Hylograph.Unified.Sugar.concatOp (right-associative / precedence 5)

#(/==) Source

Operator alias for Hylograph.Unified.Sugar.strNeqOp (non-associative / precedence 4)

#(/:) Source

Operator alias for Hylograph.Unified.Sugar.divLit (left-associative / precedence 7)

#(/.) Source

Operator alias for Hylograph.Unified.Sugar.divOp (left-associative / precedence 7)

#(-:) Source

Operator alias for Hylograph.Unified.Sugar.subLit (left-associative / precedence 6)

#(-.) Source

Operator alias for Hylograph.Unified.Sugar.subOp (left-associative / precedence 6)

#(+:) Source

Operator alias for Hylograph.Unified.Sugar.addLit (left-associative / precedence 6)

#(+.) Source

Operator alias for Hylograph.Unified.Sugar.addOp (left-associative / precedence 6)

#(*:) Source

Operator alias for Hylograph.Unified.Sugar.mulLit (left-associative / precedence 7)

#(*.) Source

Operator alias for Hylograph.Unified.Sugar.mulOp (left-associative / precedence 7)

Modules: Data.DependencyGraph; Hylograph.Brush; Hylograph.Brush.FFI; Hylograph.Brush.Types; Hylograph.Classify; Hylograph.Data.Graph; Hylograph.Data.Graph.Algorithms; Hylograph.Data.Node; Hylograph.Data.Tree; Hylograph.Expr.Animation; Hylograph.Expr.Attr; Hylograph.Expr.Datum; Hylograph.Expr.Expr; Hylograph.Expr.Friendly; Hylograph.Expr.Integration; Hylograph.Expr.Interpreter.CodeGen; Hylograph.Expr.Interpreter.Eval; Hylograph.Expr.Interpreter.Meta; Hylograph.Expr.Interpreter.PureSVG; Hylograph.Expr.Interpreter.SVG; Hylograph.Expr.Path; Hylograph.Expr.Path.Generators; Hylograph.Expr.Sugar; Hylograph.Expr.Units; Hylograph.HATS; Hylograph.HATS.Friendly; Hylograph.HATS.InterpreterTick; Hylograph.HATS.Transitions; Hylograph.Interaction.Brush; Hylograph.Interaction.Coordinated; Hylograph.Interaction.Pointer; Hylograph.Interaction.Zoom; Hylograph.Internal.Attribute; Hylograph.Internal.Behavior.FFI; Hylograph.Internal.Behavior.Types; Hylograph.Internal.Element.Operations; Hylograph.Internal.Element.Types; Hylograph.Internal.FFI; Hylograph.Internal.Transition.FFI; Hylograph.Internal.Transition.Manager; Hylograph.Internal.Transition.Scene; Hylograph.Internal.Transition.Types; Hylograph.Internal.Types; Hylograph.Interpreter.English; Hylograph.Interpreter.Mermaid; Hylograph.Interpreter.MetaHATS; Hylograph.Interpreter.SemiQuine; Hylograph.Interpreter.SemiQuine.TreeToCode; Hylograph.Interpreter.SemiQuine.Types; Hylograph.Scale; Hylograph.Scale.FP; Hylograph.Shape.Arc; Hylograph.Shape.Pie; Hylograph.Shape.Polygon; Hylograph.Tooltip; Hylograph.Transform; Hylograph.Unified; Hylograph.Unified.Attribute; Hylograph.Unified.DataDSL; Hylograph.Unified.Display; Hylograph.Unified.Sugar