Hylograph.Scale.Pure

newtype Scale :: forall k. Type -> Type -> k -> Typenewtype Scale domain range kind

A pure scale is a record holding the forward mapping function, an inverse function, the current domain and range arrays, clamping state, a tick generator, and transform-specific parameters.

The phantom types mirror those in Hylograph.Scale:

• domain - the input type (always Number for continuous scales)
• range - the output type (always Number for continuous scales)
• kind - the scale kind (always Continuous here)

Constructors

• Scale { base_ :: Number, clamped :: Boolean, domain_ :: Array domain, exponent_ :: Number, forward :: domain -> range, inverse :: range -> Maybe domain, range_ :: Array range, rounded :: Boolean, ticks_ :: Int -> Array domain, transform :: Number -> Number, untransform :: Number -> Number }

type ContinuousScale = Scale Number Number Continuous

Convenient alias matching Hylograph.Scale.ContinuousScale

data Continuous

Phantom type for continuous scales

linear :: ContinuousScale

Create a linear scale with default domain [0, 1] and range [0, 1]

scale = linear # domain [0.0, 100.0] # range [0.0, 500.0]
applyScale scale 50.0  -- Returns 250.0

pow :: ContinuousScale

Create a power scale with configurable exponent (default exponent 1.0)

scale = pow # exponent 2.0 # domain [0.0, 10.0] # range [0.0, 100.0]

sqrt :: ContinuousScale

Create a square root scale (power scale with exponent 0.5)

Useful for sizing circles by area:

radiusScale = sqrt # domain [0.0, maxValue] # range [0.0, 50.0]

log :: ContinuousScale

Create a logarithmic scale (default base 10)

Domain must not include zero.

scale = log # domain [1.0, 1000.0] # range [0.0, 300.0]

domain :: Array Number -> ContinuousScale -> ContinuousScale

Set the domain (input extent) of a scale

myScale = linear # domain [0.0, 100.0] # range [0.0, 500.0]

range :: Array Number -> ContinuousScale -> ContinuousScale

Set the range (output extent) of a scale

myScale = linear # domain [0.0, 100.0] # range [0.0, 500.0]

clamp :: Boolean -> ContinuousScale -> ContinuousScale

Enable or disable clamping

When enabled, output values are constrained to the range even for out-of-domain inputs.

clamped = linear # domain [0.0, 100.0] # range [0.0, 500.0] # clamp true
applyScale clamped 200.0  -- Returns 500.0, not 1000.0

nice :: ContinuousScale -> ContinuousScale

Extend the domain to nice round values

Uses 10 as the default tick count hint for computing step size.

niceScale = linear # domain [3.0, 97.0] # nice
-- Domain becomes approximately [0.0, 100.0]

niceCount :: Int -> ContinuousScale -> ContinuousScale

Extend the domain to nice round values with a specified tick count hint

niceScale = linear # domain [3.0, 97.0] # niceCount 5

exponent :: Number -> ContinuousScale -> ContinuousScale

Set the exponent for a power scale

squareScale = pow # exponent 2.0 # domain [0.0, 10.0] # range [0.0, 100.0]

base :: Number -> ContinuousScale -> ContinuousScale

Set the base for a logarithmic scale (default 10)

scale = log # base 2.0 # domain [1.0, 1024.0] # range [0.0, 10.0]

round :: Boolean -> ContinuousScale -> ContinuousScale

Enable or disable output rounding

When enabled, output values are rounded to the nearest integer.

rounded = linear # domain [0.0, 100.0] # range [0.0, 500.0] # round true
applyScale rounded 33.3  -- Returns 167.0, not 166.5

applyScale :: ContinuousScale -> Number -> Number

Apply a scale to a domain value, producing a range value

scale = linear # domain [0.0, 100.0] # range [0.0, 500.0]
applyScale scale 50.0  -- Returns 250.0

invert :: ContinuousScale -> Number -> Maybe Number

Invert a continuous scale (range value back to domain value)

Returns Nothing if the inversion is not defined (e.g. division by zero).

scale = linear # domain [0.0, 100.0] # range [0.0, 500.0]
invert scale 250.0  -- Returns Just 50.0

ticks :: Int -> ContinuousScale -> Array Number

Generate nice tick positions for a scale

Uses D3's tick algorithm to find "nice" numbers (multiples of 1, 2, or 5 times a power of 10).

scale = linear # domain [0.0, 100.0] # range [0.0, 500.0]
ticks 5 scale  -- Returns [0.0, 20.0, 40.0, 60.0, 80.0, 100.0]

tickFormat :: Int -> String -> ContinuousScale -> (Number -> String)

Get a tick formatter function

The specifier argument is accepted for API compatibility but this pure implementation uses show for formatting.

copy :: ContinuousScale -> ContinuousScale

Create a copy of a scale (identity operation for pure data, included for API compatibility with the D3 FFI module)

andThen :: ContinuousScale -> ContinuousScale -> (Number -> Number)

Compose two scales: apply the first, then the second

normalize = linear # domain [0.0, 100.0] # range [0.0, 1.0]
toPixels  = linear # domain [0.0, 1.0]   # range [0.0, 500.0]
combined  = normalize `andThen` toPixels
combined 50.0  -- Returns 250.0

contramap :: forall a. (a -> Number) -> ContinuousScale -> (a -> Number)

Transform the input before applying the scale (contravariant mapping)

fahrenheitScale = linear # domain [32.0, 212.0] # range [0.0, 100.0]
celsiusScale = contramap (\c -> c * 9.0 / 5.0 + 32.0) fahrenheitScale
celsiusScale 100.0  -- Returns 100.0

map :: forall b. (Number -> b) -> ContinuousScale -> (Number -> b)

Transform the output after applying the scale (covariant/functor-like)

baseScale = linear # domain [0.0, 100.0] # range [0.0, 500.0]
offsetScale = map (_ + 50.0) baseScale
offsetScale 0.0  -- Returns 50.0

dimap :: forall a b. (a -> Number) -> (Number -> b) -> ContinuousScale -> (a -> b)

Transform both input and output (profunctor-like)

transformed = scale # dimap preprocess postprocess

type Interpolator a = Number -> a

An interpolator maps [0, 1] to a value