Convert a list of Vega-Lite specifications into a single JSON object that may be passed to Vega-Lite for graphics generation. Commonly these will include at least data, mark and encoding specifications.

While simple functions like bar may be provided directly, it is usually clearer to label more complex functions such as encodings with separate expressions.

Specifications can be built up by chaining functions such as dataColumn or position. Functional composition using the << operator allows this to be done compactly:

myChart : Spec
myChart =
    let
        data =
            dataFromColumns []
                << dataColumn "a" (strs [ "C", "C", "D" ])
                << dataColumn "b" (nums [ 2, 7, 1 ])


        enc =
            encoding
                << position X [ pName "a" ]
                << position Y [ pName "b", pAggregate opMean ]
    in
    toVegaLite [ data [], enc [], bar [] ]

Top-level Vega-Lite properties. These are the ones that define the core of the visualization grammar. All VLProperties are created by functions in seven broad groups.

Data properties relate to the input data to be visualized. Generated by dataFromColumns, dataFromRows, dataFromUrl, dataFromSource, dataFromJson, dataSequence, sphere and graticule.

Transform properties indicate that some transformation of input data should be applied before encoding them visually. Generated by transform and projection they can include data transformations such as filter, binAs and calculateAs and geo transformations of longitude, latitude coordinates used by marks such as geoshape, point and line.

Mark functions specify the graphical symbols used to visualize data items. Generated by functions such as circle, bar and line.

Encoding properties specify which data elements are mapped to which mark characteristics (known as channels). Generated by encoding they include encodings such as position, color, size, shape, text, hyperlink and order.

Composition properties allow visualization views to be combined to form more complex visualizations. Generated by layer, repeatFlow, repeat, facetFlow, facet, concat, columns, hConcat, vConcat, specification and resolve.

Interaction properties allow clicking, dragging and other interactions generated via a GUI or data stream to influence the visualization. Generated by params with a paSelect parameter.

Supplementary and configuration properties provide a means to add metadata and styling to one or more visualizations. Generated by name, title, description, background, backgroundExpr, width, height, widthStep, heightStep, padding, autosize, viewBackground and configure.

Part or all of a Vega-Lite specification. Specs are usually nested and can range from a single Boolean value up to the full visualization specification.

You only need to name something as a Spec when providing a top level function with a type signature. For example,

myBarchart : Spec
myBarchart =
    ...

A named Vega-Lite specification, usually generated by an elm-vega function. You shouldn't need to create LabelledSpec tuples directly, but are useful for type annotations.

Combine a list of labelled specifications to be passed to JavaScript for rendering. Useful when you wish to create a single page with multiple visualizations.

myCharts : Spec
myCharts =
    combineSpecs
        [ ( "vis1", myVis1 )
        , ( "vis2", myVis2 )
        , ( "vis3", myVis3 )
        ]

Declare a data source from a url. The URL can be a local path such as a file name in the same folder as the elm specification or an external (CORS) URL. A list of field formatting instructions can be provided as the second parameter or an empty list to use the default formatting.

myPopData : Data
myPopData =
    dataFromUrl "https://vega.github.io/vega-lite/data/population.json" []


myBikeData : Data
myBikeData =
    dataFromUrl "./data/bicycleHires.csv"
        [ parse
            [ ( "numHires", foNum )
            , ( "avHireTime", foNum )
            ]
        ]

Declare a data source from a list of column values. Each column should contain values of the same type, but columns each with a different type are permitted. If columns do not contain the same number of items, the dataset will be truncated to the length of the shortest, so beware of inadvertently removing data rows at the 'bottom' of a table.

A list of field formatting instructions can be provided as the first parameter or an empty list to use the default formatting. Simple numbers and strings do not normally need formatting, but it is good practice to explicitly declare date-time formats because default date-time formats can vary between browsers.

The columns are most easily generated with dataColumn:

myChart : Spec
myChart =
    let
        data =
            dataFromColumns [ parse [ ( "Year", foDate "%Y" ) ] ]
                << dataColumn "Animal" (strs [ "Fish", "Dog", "Cat" ])
                << dataColumn "Age" (nums [ 28, 12, 6 ])
                << dataColumn "Year" (strs [ "2015", "2019", "2020" ])
    in
    toVegaLite [ data [], ... ]

For more complex inline data tables, such as mixtures of arrays and objects, consider using dataFromJson.

Create a column of data. A column has a name and a list of values which is then added to an existing list of data columns. This allows multiple data column specifications to be chained together with the << operator. For example, to represent a table of data in this form:

| x   | y   |
| --- | --- |
| a   | 1   |
| b   | 2   |
| c   | 3   |

you could specify:

myChart : Spec
myChart =
    let
        data =
            dataFromColumns []
                << dataColumn "x" (strs [ "a", "b", "c" ])
                << dataColumn "y" (nums [ 1, 2, 3 ])
    in
    toVegaLite [ data [], ... ]

Declare a data source from a list of row values. Each row should contain a list of tuples in the form (column name, value). Each column can have a value of a different type but you must ensure that values are of the same type as others in the same column. A list of field formatting instructions can be provided as the first parameter or an empty list to use the default formatting. Rows are most easily generated with dataRow.

myChart : Spec
myChart =
    let
        data =
            dataFromRows [ parse [ ( "Year", foDate "%Y" ) ] ]
                << dataRow [ ( "Animal", str "Fish" ), ( "Age", num 28 ), ( "Year", str "2015" ) ]
                << dataRow [ ( "Animal", str "Dog" ), ( "Age", num 12 ), ( "Year", str "2019" ) ]
                << dataRow [ ( "Animal", str "Cat" ), ( "Age", num 6 ), ( "Year", str "2020" ) ]
    in
    toVegaLite [ data [], ... ]

Generally, adding data by column is more efficient and less error-prone, but occasionally there can be greater clarity in arranging data by rows. For more complex inline data tables, such as mixtures of arrays and objects, consider using dataFromJson.

Create a row of data. A row comprises a list of (columnName, value) pairs. For example, to specify this table:

| x   | y   |
| --- | --- |
| a   | 1   |
| b   | 2   |
| c   | 3   |




myChart : Spec
myChart =
    let
        data =
            dataFromRows []
                << dataRow [ ( "x", str "a" ), ( "y", num 1 ) ]
                << dataRow [ ( "x", str "b" ), ( "y", num 2 ) ]
                << dataRow [ ( "x", str "c" ), ( "y", num 3 ) ]
    in
    toVegaLite [ data [], ...]

Declare a data source from a json specification. The most likely use-case is creating geojson objects with geometry, geometryCollection and geoFeatureCollection.

myChart : Spec
myChart =
    let
        geojson =
            geometry (geoPolygon [ [ ( -3, 59 ), ( 4, 59 ), ( 4, 52 ), ( -3, 59 ) ] ]) []
    in
    toVegaLite [ dataFromJson geojson [], geoshape [] ]

For more general cases of json creation such as data tables that mix arrays and objects, consider combining with jsonToSpec. For example,

myChart : Spec
myChart =
    let
        data =
            jsonToSpec """{
            "Revenue" : [ 150, 225, 300 ],
            "Profit" : [ 20, 25, 30 ],
            "Order size" : [ 350, 500, 600 ],
            "New customers" : [ 1400, 2000, 2500 ],
            "Satisfaction" : [ 3.5, 4.25, 5 ]
        }"""
                |> dataFromJson
    in
    toVegaLite [ data [], ... ]

Convert a string representing some JSON into a Spec. Useful when combined with dataFromJson to compactly import inline JSON as data. For example,

myChart : Spec
myChart =
    let
        data =
            jsonToSpec """{
            "Revenue" : [ 150, 225, 300 ],
            "Profit" : [ 20, 25, 30 ],
            "Order size" : [ 350, 500, 600 ],
            "New customers" : [ 1400, 2000, 2500 ],
            "Satisfaction" : [ 3.5, 4.25, 5 ]
        }"""
                |> dataFromJson
    in
    toVegaLite [ data [], ... ]

This can also be used to store a full visualization specification from a JSON object. For example,

myChart : Spec
myChart =
    """
{
    "$schema": "https://vega.github.io/schema/vega-lite/v5.json",
    "data": { "url": "https://cdn.jsdelivr.net/npm/[email protected]/data/cars.json"},
    "mark": "bar",
    "encoding": {
        "x": { "field": "Origin" },
        "y": { "field": "Miles_per_Gallon", "aggregate": "mean" }
    }
}
""" |> jsonToSpec

But note this is not type-safe – if the JSON is not well-formed, a JSON null value is returned.

Create a dataset comprising a collection of named Data items. Each data item can be created with normal data generating functions such as dataFromRows or dataFromJson. These can be later referred to using dataFromSource.

myChart : Spec
myChart =
    let
        data =
            dataFromColumns []
                << dataColumn "name" (strs [ "alphaville", "betatown" ])
                << dataColumn "pop" (nums [ 9350, 4770 ])


        geoBounds =
            geometry (geoPoints [ ( -4, 55 ), ( 3, 59 ) ]) []
                |> dataFromJson
    in
    toVegaLite
        [ datasets
            [ ( "myData", data [] )
            , ( "myJson", geoBounds [] )
            ]
        , dataFromSource "myData" []
        , ...
        ]

Declare data from a named source. The source may be from named datasets within a specification or one created via the Vega View API. A list of field formatting instructions can be provided as the second parameter or an empty list to use the default formatting.

myChart : Spec
myChart =
    let
        data = ...
        json = ...
    in
    toVegaLite
        [ datasets [ ( "myData", data ), ( "myJson", dataFromJson json [] ) ]
        , dataFromSource "myData" []
        , ...
        ]

Name to give a data source. Useful when a specification needs to reference a data source, such as one generated via an API call.

myChart : Spec
myChart =
    let
        data =
            dataFromUrl "myData.json" []
                |> dataName "myName"
    in
    toVegaLite [ data , ...]

Ignore the data of a specification's parent when used in a composed spec such as layering or concatenation.

Type annotation for describing data generation functions. Useful when annotating top-level data-generating functions. For example,

myRegion : List DataColumn -> Data
myRegion =
    dataFromColumns []
        << dataColumn "easting" (nums [ -3, 4, 4, -3, -3 ])
        << dataColumn "northing" (nums [ 52, 52, 45, 45, 52 ])

Type annotation for a single column of data. Used when describing inline data with dataColumn.

Type annotation for a single row of data. Used when describing inline data with dataRow.

Specify a geometric object. The first parameter is the geometry type, the second an optional list of properties to be associated with the object.

myGeo : Data
myGeo =
    (geometry (geoPoints [ ( -4, 55 ), ( 3, 59 ) ]) []
        |> dataFromJson
    )
        []

A collection of geo features to be used in a geoshape specification. Each feature in this collection can be created with geometry.

myGeo : Data
myGeo =
    (geoFeatureCollection
        [ geometry (geoPolygon [ [ ( -3, 59 ), ( -3, 52 ), ( 4, 52 ), ( -3, 59 ) ] ])
            [ ( "myRegionName", str "Northern region" ) ]
        , geometry (geoPolygon [ [ ( -3, 52 ), ( 4, 52 ), ( 4, 45 ), ( -3, 52 ) ] ])
            [ ( "myRegionName", str "Southern region" ) ]
        ]
        |> dataFromJson
    )
        []

Collection of geometry objects that make up a single feature. Can be used in a geoshape specification. Each geometry object can be created with geometry.

myGeo : Data
myGeo =
    (geometryCollection
        [ geometry (geoPolygon [ [ ( -3, 59 ), ( 4, 59 ), ( 4, 52 ), ( -3, 59 ) ] ]) []
        , geometry (geoPoint -3.5 55.5) []
        ]
        |> dataFromJson
    )
        []

Point geometry for programmatically creating GeoShapes. Equivalent to the GeoJson geometry point type.

myGeo : Data
myGeo =
    (geometry (geoPoint -3.5 55.5) []
        |> dataFromJson
    )
        []

Multi-point geometry for programmatically creating GeoShapes. Equivalent to the GeoJson geometry multi-point type.

myGeo : Data
myGeo =
    (geometry (geoPoints [ ( -4, 55 ), ( -3, 59 ), ( -3, 56 ) ]) []
        |> dataFromJson
    )
        []

Line geometry for programmatically creating GeoShapes. Equivalent to the GeoJson geometry line type.

myGeo : Data
myGeo =
    (geometry (geoLine [ ( -3, 59 ), ( 4, 59 ), ( 4, 52 ) ]) []
        |> dataFromJson
    )
        []

Multi-line geometry for programmatically creating GeoShapes. Equivalent to the GeoJson geometry multi-line type.

myGeo : Data
myGeo =
    (geometry
        (geoLines
            [ [ ( -3, 59 ), ( 4, 59 ), ( 4, 52 ) ]
            , [ ( -4, 57 ), ( 2, 57 ), ( 2, 56 ) ]
            ]
        )
        []
        |> dataFromJson
    )
        []

Polygon geometry for programmatically creating GeoShapes. Equivalent to the GeoJson geometry polygon type.

myGeo : Data
myGeo =
    (geometry (geoPolygon [ [ ( -3, 59 ), ( 4, 59 ), ( 4, 52 ), ( -3, 59 ) ] ]) []
        |> dataFromJson
    )
        []

Multi-polygon geometry for programmatically creating GeoShapes. Equivalent to the GeoJson geometry multi-polygon type.

myGeo : Data
myGeo =
    (geometry
        (geoPolygons
            [ [ [ ( -3, 59 ), ( 4, 59 ), ( 4, 52 ), ( -3, 59 ) ] ]
            , [ [ ( -4, 57 ), ( 2, 57 ), ( 2, 56 ), ( -4, 57 ) ] ]
            ]
        )
        []
        |> dataFromJson
    )
        []

Generate a sequence of numbers as a data source between the value of the first parameter (inclusive) and the second (exclusive) in steps of the value of the third. The resulting sequence will have the name data when referring to it within a specification. For example,

sineWave : Spec
sineWave =
    let
        myData =
            dataSequence 0 (2 * pi) (pi / 90)


        trans =
            transform
                << calculateAs "sin(datum.data)" "y"


        enc =
            encoding
                << position X [ pName "data", pQuant ]
                << position Y [ pName "y", pQuant ]
    in
    toVegaLite [ myData, trans [], enc [], line [] ]

To give the sequence an alternative name use dataSequenceAs

Generate a sequence of numbers as a data source between the value of the first parameter (inclusive) and the second (exclusive) in steps of the value of the third. The resulting sequence will have the name provided as the fourth parameter.

myData : Data
myData =
    dataSequenceAs 0 (2 * pi) (pi / 90) "x"

Generate a data source that is a sphere for bounding global geographic data. The sphere will be subject to whatever projection is specified for the view.

myGlobe : Spec
myGlobe =
    toVegaLite
        [ sphere
        , projection [ prType orthographic ]
        , geoshape [ maFill "aliceblue" ]
        ]

Generate a grid of lines of longitude (meridians) and latitude (parallels). The parameter can be used to specify the number and extent of lines, or to use default values, provide an empty list.

myGlobe : Spec
myGlobe =
    let
        proj =
            projection [ prType orthographic ]


        sphereSpec =
            asSpec [ sphere, geoshape [ maFill "aliceblue" ] ]


        gratSpec =
            asSpec
                [ graticule [ grStep ( 15, 15 ) ]
                , geoshape [ maFilled False ]
                ]
    in
    toVegaLite [ proj, layer [ sphereSpec, gratSpec ] ]

Set the step sizes between all graticule lines. The parameter is a (longitude,latitude) pair defining the EW and NS graticule intervals respectively.

Set the step sizes between major graticule lines. By default, major graticule lines extend to both poles, but minor lines stop at ±80 degrees latitude. The parameter is a (longitude,latitude) pair defining the EW and NS graticule intervals respectively.

Set the step sizes between minor graticule lines. While major graticule lines extend to both poles, by default minor lines stop at ±80 degrees latitude. The parameter is a (longitude,latitude) pair defining the EW and NS graticule intervals respectively.

Set the extent of both major and minor graticule lines. The first parameter is a (longitude,latitude) pair defining the minimum extent, the second parameter the maximum extent.

Set the extent of major graticule lines. The first parameter is a (longitude,latitude) pair defining the minimum extent, the second parameter the maximum extent.

Set the extent of minor graticule lines. The first parameter is a (longitude,latitude) pair defining the minimum extent, the second parameter the maximum extent.

The precision of the graticule in degrees. If unspecified, the default of 2.5 degrees is used. Smaller values provide a less stepped appearance of curved lines but take longer to render.

Specify parsing rules when processing some data text with dataFromUrl, dataFromColumns etc. The parameter should be a list of tuples in the form (fieldName, DataType). Useful when automatic type inference needs to be overridden, for example to ensure numbers with - symbols are treated as integers and not strings in transform calculations or when converting integers representing years into dates. For example,

myData : Data
myData =
    dataFromUrl "myDataFile.csv"
        [ parse
            [ ( "year", foDate "%Y" )
            , ( "change", foNum )
            ]
        ]

Indicate numeric data type to be parsed when reading input data. Used by parse.

Indicate Boolean data type to be parsed when reading input data. Used by parse.

Specify a date/time format when parsing input data. Should use D3's formatting specifiers to describe the data-time format or an empty string for default formatting. Used by parse. For example,

myData : Data
myData =
    dataFromUrl "myDataFile.csv"
        [ parse [ ( "timestamp", foDate "%d %b %Y %H:%M" ) ] ]

Similar to foDate but for UTC format dates. Used by parse.

Specify a CSV (comma-separated values) file format when reading a data file. Only necessary if the file extension does not indicate the type. Used by dataFromUrl. For example,

myData : Data
myData =
    dataFromUrl "myData" [ csv ]

Specify a TSV (tab-separated values) file format when reading a data file. Only necessary if the file extension does not indicate the type. Used by dataFromUrl. For example,

myData : Data
myData =
    dataFromUrl "myData" [ tsv ]

Specify a custom delimited file format (DSV) with a given separator when reading a data file. Used by dataFromUrl. For example,

myData : Data
myData =
    dataFromUrl "myData" [ dsv '|' ]

Specify an Apache arrow data file format when reading a data file. Used by dataFromUrl. For example,

myData : Data
myData =
    dataFromUrl "https://gicentre.github.io/data/scrabble.arrow" [ arrow ]

A topoJSON feature format containing an object with the given name. The name of the object can be found by inspecting the topoJSON file and searching for the value associated with the objects key. Used by dataFromUrl. For example,

myData : Data
myData =
    dataFromUrl "https://gicentre.github.io/data/geoTutorials/londonBoroughs.json"
        [ topojsonFeature "boroughs" ]

A topoJSON mesh format containing an object with the given name. Unlike topojsonFeature, the corresponding geo data are returned as a single unified mesh, not as individual GeoJSON features. Generally meshes can be faster to render but only suitable for showing boundary features, not filled areas. Used by dataFromUrl. For example,

myLondon : Spec
myLondon =
    toVegaLite
        [ dataFromUrl "https://gicentre.github.io/data/geoTutorials/londonBoroughs.json"
            [ topojsonMesh "boroughs" ]
        , geoshape [ maFilled False ]
        ]

Property to be extracted from some JSON when it has some surrounding structure. e.g., specifying the property values.features is equivalent to retrieving json.values.features from a JSON object with a custom delimiter. Used by dataFromJson.

Create a single transform from a list of transformation specifications. The order of transformations can be important, e.g. labels created with calculateAs, timeUnitAs and binAs that are used in other transformations. Using the functional composition pipeline idiom (as example below) allows you to provide the transformations in the order intended in a clear manner.

trans =
    transform
        << filter (fiExpr "datum.year == 2010")
        << calculateAs "datum.sex == 2 ? 'Female' : 'Male'" "gender"

Create a map projection to transform geospatial coordinates. Only data positioned with Longitude and Latitude or displayed as a geoshape are affected by a projection.

myMap : Spec
myMap =
    let
        myData =
            dataFromUrl "https://gicentre.github.io/data/geoTutorials/londonBoroughs.json"
                [ topojsonFeature "boroughs" ]


        proj =
            projection
                [ prType transverseMercator
                , prRotate 2 0 0
                ]
    in
    toVegaLite [ myData, proj, geoshape [] ]

Provide an expression to a map projection property function requiring a numeric value. This can be used for interactive parameterisation when an expression is bound to an input element. Used by projection and coProjection. For example,

myMap : Spec
myMap =
    let
        geoData =
            dataFromUrl "https://gicentre.github.io/data/geoTutorials/world-110m.json"
                [ topojsonFeature "countries1" ]


        ps =
            params
                << param "zoom"
                    [ paValue (num 40)
                    , paBind (ipRange [ inMin 40, inMax 500 ])
                    ]


        proj =
            projection [ prNumExpr "zoom" prScale ]
    in
    toVegaLite [ ps [], geoData, proj, geoshape [] ]

Type of global map projection. Used by projection and coProjection. For example,

myProj =
    projection [ prType orthographic ]

An Albers equal-area conic map projection. Used by prType.

An Albers USA map projection that combines continental USA with Alaska and Hawaii. Unlike other projection types, this remains unaffected by prRotate. Used by prType.

An azimuthal equal area map projection. Used by prType.

An azimuthal equidistant map projection. Used by prType.

A conformal (shape-preserving) conic map projection. Used by prType.

An equal area conic map projection. Used by prType.

An equidistant conic map projection. Distance is preserved along a standard parallel (or two parallels for secant projections). Used by prType.

An Equal Earth map projection that provides a reasonable shape approximation while retaining relative areas. Used by prType.

An equirectangular map projection that maps longitude to x and latitude to y. While showing less area distortion towards the poles than the mercator projection, it is neither equal-area nor conformal. Used by prType.

A gnomonic map projection. Used by prType.

An 'identity' projection where longitude is projected directly to the x position and latitude to the y position. Can also reflect either of the coordinates by specifying prReflectX / prReflectY in the list of projection properties. Used by prType.

A Mercator map projection. This is the default projection of longitude,latitude values if no projection is set explicitly. It preserves shape (local angle) and lines of equal angular bearing remain parallel straight lines. But area is significantly enlarged towards the poles. Used by prType.

A natural earth map projection. Used by prType.

An orthographic map projection. Used by prType.

A stereographic map projection. Used by prType.

A transverse Mercator map projection. Used by prType.

Custom projection type. Additional custom projections from d3 can be defined via the Vega API and called from with this function where the parameter is the name of the D3 projection to use (e.g. customProjection "winkel3"). Used by prType.

Specify a map projection type with an expression that evaluates to a valid projection name. Useful for interactive selection of map projection. Used by prType. For example,

myMap : Spec
myMap =
    let
        geoData =
            dataFromUrl "https://gicentre.github.io/data/geoTutorials/world-110m.json"
                [ topojsonFeature "countries1" ]


        ps =
            params
                << param "myProj"
                    [ paValue (str "EqualEarth")
                    , paBind
                        (ipSelect
                            [ inName "Map projection "
                            , inOptions
                                [ "EqualEarth"
                                , "Orthographic"
                                ]
                            ]
                        )
                    ]


        proj =
            projection [ prType (prExpr "myProj") ]
    in
    toVegaLite [ ps [], geoData, proj, geoshape [] ]

Projection’s clipping circle radius to the specified angle in degrees. A value of 0 will switch to antimeridian cutting rather than small-circle clipping. Used by projection and coProjection.

Projection’s viewport clip extent to the specified bounds in pixels. Used by projection and coProjection.

Indicate no clipping to be applied. Used by prClipExtent.

Specify the bounds in pixel coordinates of a clipped map projection in left, top, right, and bottom order. Used by prClipExtent. For example,

myMap : Spec
myMap =
    let
        geoData =
            dataFromUrl "https://gicentre.github.io/data/geoTutorials/world-110m.json"
                [ topojsonFeature "countries1" ]


        proj =
            projection
                [ clipRect 0 0 600 270
                    |> prClipExtent
                ]
    in
    toVegaLite
        [ width 600
        , height 300
        , geoData
        , proj
        , geoshape []
        ]

Specify the bounds of a clipped map projection region with four expressions in left, top, right, and bottom order that evaluate to pixel positions. Useful when parameterising clip extent interactively. Used by prClipExtent. For example,

myMap : Spec
myMap =
    let
        geoData =
            dataFromUrl "https://gicentre.github.io/data/geoTutorials/world-110m.json"
                [ topojsonFeature "countries1" ]


        ps =
            params
                << param "left"
                    [ paValue (num 0)
                    , paBind (ipRange [ inMin 0, inMax 300 ])
                    ]
                << param "right"
                    [ paValue (num 600)
                    , paBind (ipRange [ inMin 300, inMax 600 ])
                    ]
                << param "top"
                    [ paValue (num 0)
                    , paBind (ipRange [ inMin 0, inMax 150 ])
                    ]
                << param "bottom"
                    [ paValue (num 300)
                    , paBind (ipRange [ inMin 150, inMax 300 ])
                    ]


        proj =
            projection
                [ clipRectExpr "left" "top" "right" "bottom"
                    |> prClipExtent
                ]
    in
    toVegaLite
        [ width 600
        , height 300
        , ps []
        , geoData
        , proj
        , geoshape []
        ]

Adjust map projection to fit the given geoShape within the display area. The geoShape can be a feature collection, a single feature or array of features. This is usually easier than adjusting a projection's prScale and prTranslate. Used by projection and coProjection. For example,

geoFrame =
    geometry (geoPoints [ ( -8, 60 ), ( 1, 47 ) ])
        []


proj =
    projection [ prFit geoFrame ]

Projection’s center as longitude and latitude in degrees. Used by projection and coProjection.

Specify a projection’s centre with two expressions that should evaluate to a longitude and latitude respectively. Used by projection and coProjection.

A projection’s zoom scale, which if set, overrides automatic scaling of a geo feature to fit within the viewing area. Used by projection and coProjection.

A projection’s panning translation in pixel units, which if set, override automatic positioning of a geo feature to fit within the viewing area. Parameters should be provided in x y order. Used by projection and coProjection.

Specify a projection’s panning translation in pixel units, with two expressions that should evaluate to x and y translations respectively. Used by projection and coProjection.

A projection’s three-axis rotation angle. This should be in order lambda phi gamma specifying the rotation angles in degrees about each spherical axis. Used by projection and coProjection.

Specify a projection’s three-axis rotation angle with three expressions that should evaluate to angular rotations (degrees) in lambda phi gamma order. Used by projection and coProjection.

Threshold for the projection’s adaptive resampling in pixels. Corresponds to the Douglas–Peucker distance. If precision is not specified, the projection’s current resampling precision of 0.707 is used. Used by projection and coProjection.

'Hammer' map projection coefficient. Used by projection and coProjection.

'Satellite' map projection distance. Used by projection and coProjection.

Bottomley map projection fraction. Used by projection and coProjection.

Number of lobes in lobed map projections such as the 'Berghaus star'. Used by projection and coProjection.

Standard parallel for map projections such as the 'Armadillo'. Used by projection and coProjection.

A conic projection’s two standard parallels. Used by projection and coProjection.

Specify a conic projection’s two standard parallels with two expressions. Used by projection and coProjection.

Radius in pixels when drawing geo point features in a GeoFeature. Used by projection and coProjection.

Radius value for map projections such as the 'Gingery'. Used by projection and coProjection.

Ratio value for map projections such as the 'Hill'. Used by projection and coProjection.

Reflect the x-coordinates after performing an identity projection. This creates a left-right mirror image of the geoshape marks when subject to an identityProjection. Used by projection and coProjection.

Reflect the y-coordinates after performing an identity projection. This creates a top-bottom mirror image of the geoshape marks when subject to an identityProjection. Used by projection and coProjection.

Spacing value for map projections such as the 'Lagrange'. Used by projection and coProjection.

'Satellite' map projection tilt. Used by projection and coProjection.

Aggregation transformations to be used when encoding channels. Useful when for applying the same transformation to a number of channels without defining it each time. The first parameter is a list of the named aggregation operations to apply. The second is a list of 'group by' fields.

trans =
    transform
        << aggregate
            [ opAs opMin "people" "lowerBound", opAs opMax "people" "upperBound" ]
            [ "age" ]

Aggregation transformations to be used when encoding channels. Unlike aggregate, this transformation joins the results to the input data. Can be helpful for creating derived values that combine raw data with some aggregate measure, such as percentages of group totals. The first parameter is a list of the named aggregation operations to apply. The second is a list of possible window aggregate field properties, such as a field to group by when aggregating. The third parameter is a list of transformations to which this is added.

transform
    << joinAggregate [ opAs opMean "rating" "avYearRating" ]
        [ wiGroupBy [ "year" ] ]
    << filter (fiExpr "(datum.rating - datum.avYearRating) > 3")

For details, see the Vega-Lite join aggregate documentation

Aggregation operation. The first parameter is the operation to use; the second the name of the field in which to apply it and the third the name to be given to this transformation.

trans =
    transform
        << aggregate
            [ opAs opMin "people" "lowerBound"
            , opAs opMax "people" "upperBound"
            ]
            [ "age" ]

If the operation is opCount, it does not apply to any specific field, so the second parameter can be an empty string.

Create a new data field based on the given temporal binning. Unlike the direct encoding binning, this transformation is named and so can be referred to in multiple encodings. The first parameter is the width of each temporal bin, the second is the field to bin and the third is name to give the newly binned field.

An input data object containing the minimum field value to be used in an aggregation operation. If supplied as part of an encoding aggregation, the parameter should be Just the name of the field to maximise. Used by mAggregate, pAggregate, hAggregate, oAggregate, tAggregate, dAggregate, fAggregate, opAs, piOp, wiAggregateOp, soByField and soByRepeat.

For example, the following would find the production budget for the maximum US grossing film in each genre:

encoding
    << position X
        [ pName "Production_Budget"
        , pQuant
        , pAggregate (opArgMax (Just "US_Gross"))
        ]
    << position Y [ pName "Major_Genre", pNominal ]

If supplied as part of a transform, the parameter should be Nothing as the field is specified in the aggregate parameter.

trans =
    transform
        << aggregate
            [ opAs (opArgMax Nothing) "US_Gross" "amUSGross" ]
            [ "Major_Genre" ]

An input data object containing the minimum field value to be used in an aggregation operation. Used by mAggregate, pAggregate, hAggregate, oAggregate, tAggregate, dAggregate, fAggregate, opAs, piOp, wiAggregateOp, soByField and soByRepeat.

Lower 95% confidence interval to be used in an aggregation operation. Used by mAggregate, pAggregate, hAggregate, oAggregate, tAggregate, dAggregate, fAggregate, opAs, piOp, wiAggregateOp, soByField and soByRepeat.

Upper 95% confidence interval to be used in an aggregation operation. Used by mAggregate, pAggregate, hAggregate, oAggregate, tAggregate, dAggregate, fAggregate, opAs, piOp, wiAggregateOp, soByField and soByRepeat.

Total count of data objects to be used in an aggregation operation. Used by mAggregate, pAggregate, hAggregate, oAggregate, tAggregate, dAggregate, fAggregate, opAs, piOp, wiAggregateOp, soByField and soByRepeat.

Count of distinct data objects to be used in an aggregation operation. Used by mAggregate, pAggregate, hAggregate, oAggregate, tAggregate, dAggregate, fAggregate, opAs, piOp, wiAggregateOp, soByField and soByRepeat.

Maximum field value to be used in an aggregation operation. Used by mAggregate, pAggregate, hAggregate, oAggregate, tAggregate, dAggregate, fAggregate, opAs, piOp, wiAggregateOp, soByField and soByRepeat.

Mean value to be used in an aggregation operation. Used by mAggregate, pAggregate, hAggregate, oAggregate, tAggregate, dAggregate, fAggregate, opAs, piOp, wiAggregateOp, soByField and soByRepeat.

Median field value to be used in an aggregation operation. Used by mAggregate, pAggregate, hAggregate, oAggregate, tAggregate, dAggregate, fAggregate, opAs, piOp, wiAggregateOp, soByField and soByRepeat.

Minimum field value to be used in an aggregation operation. Used by mAggregate, pAggregate, hAggregate, oAggregate, tAggregate, dAggregate, fAggregate, opAs, piOp, wiAggregateOp, soByField and soByRepeat.

Count of null or undefined field value to be used in an aggregation operation. Used by mAggregate, pAggregate, hAggregate, oAggregate, tAggregate, dAggregate, fAggregate, opAs, piOp, wiAggregateOp, soByField and soByRepeat.

Product of field values to be used in an aggregation operation. Used by mAggregate, pAggregate, hAggregate, oAggregate, tAggregate, dAggregate, fAggregate, opAs, piOp, wiAggregateOp, soByField and soByRepeat.

Lower quartile boundary of field values to be used in an aggregation operation. Used by mAggregate, pAggregate, hAggregate, oAggregate, tAggregate, dAggregate, fAggregate, opAs, piOp, wiAggregateOp, soByField and soByRepeat.

Upper quartile boundary of field values to be used in an aggregation operation. Used by mAggregate, pAggregate, hAggregate, oAggregate, tAggregate, dAggregate, fAggregate, opAs, piOp, wiAggregateOp, soByField and soByRepeat.

Standard error of field values to be used in an aggregation operation. Used by mAggregate, pAggregate, hAggregate, oAggregate, tAggregate, dAggregate, fAggregate, opAs, piOp, wiAggregateOp, soByField and soByRepeat.

Sample standard deviation of field values to be used in an aggregation operation. Used by mAggregate, pAggregate, hAggregate, oAggregate, tAggregate, dAggregate, fAggregate, opAs, piOp, wiAggregateOp, soByField and soByRepeat.

Population standard deviation of field values to be used in an aggregation operation. Used by mAggregate, pAggregate, hAggregate, oAggregate, tAggregate, dAggregate, fAggregate, opAs, piOp, wiAggregateOp, soByField and soByRepeat.

Sum of field values to be used in an aggregation operation. Used by mAggregate, pAggregate, hAggregate, oAggregate, tAggregate, dAggregate, fAggregate, opAs, piOp, wiAggregateOp, soByField and soByRepeat.

Count of values that are not null, undefined or NaN to be used in an aggregation operation. Used by mAggregate, pAggregate, hAggregate, oAggregate, tAggregate, dAggregate, fAggregate, opAs, piOp, wiAggregateOp, soByField and soByRepeat.

Sample variance of field value to be used in an aggregation operation. Used by mAggregate, pAggregate, hAggregate, oAggregate, tAggregate, dAggregate, fAggregate, opAs, piOp, wiAggregateOp, soByField and soByRepeat.

Population variance of field value to be used in an aggregation operation. Used by mAggregate, pAggregate, hAggregate, oAggregate, tAggregate, dAggregate, fAggregate, opAs, piOp, wiAggregateOp, soByField and soByRepeat.

Binning transformation that may be referenced in other transformations or encodings. The first parameter is a list of customisation options (biBase, biDivide etc.) or an empty list to use the default binning. The second is the field to bin and the third the name to give the output binned data. Usually, direct binning within an encoding is preferred over this form of bin transformation.

trans =
    transform
        << binAs [ biMaxBins 3 ] "IMDB_Rating" "ratingGroup"

The name given to store the binned values (third parameter) will reference the start of each bin value. To extract the end of each bin, use the same name but with _end appended.

Value in the binned domain at which to anchor the binning. Boundaries are possibly shifted to ensure they align with the anchor value. Used by pBin, mBin, tBin, hBin, oBin, dBin and fBin.

Number base to use for automatic bin determination (default is base 10). Used by pBin, mBin, tBin, hBin, oBin, dBin and fBin.

Scale factors indicating allowable subdivisions for binning. The default value is [5, 2], which indicates that for base 10 numbers (the default base), binning will consider dividing bin sizes by 5 and/or 2. Used by pBin, mBin, tBin, hBin, oBin, dBin and fBin.

Desired extent of bin values when binning a collection of values. The first and second parameters indicate the minimum and maximum extent. To base a binning extent on an interactive selection, use biSelectionExtent instead. Used by pBin, mBin, tBin, hBin, oBin, dBin and fBin.

Set the desired range of bin values based on an interactive selection. The parameter should be the name of an interval selection parameter that defines the extent. Used by pBin, mBin, tBin, hBin, oBin, dBin and fBin.

ps =
    params
        << param "brush" [ paSelect seInterval [ seEncodings [ chX ] ] ]


enc =
    encoding
        << position X
            [ pName "temperature"
            , pBin [ biSelectionExtent "brush" ]
            ]

Maximum number of bins when binning a collection of values. Used by pBin, mBin, tBin, hBin, oBin, dBin and fBin.

Step size between bins when binning a collection of values. Used by pBin, mBin, tBin, hBin, oBin, dBin and fBin.

Whether or not binning boundaries use human-friendly values such as multiples of ten. Used by pBin, mBin, tBin, hBin, oBin, dBin and fBin.

Step size between bins when binning a collection of values. Used by pBin, mBin, tBin, hBin, oBin, dBin and fBin.

Allowable step sizes between bins when binning a collection of values. Used by pBin, mBin, tBin, hBin, oBin, dBin and fBin.

Apply a stack transform for positioning multiple values. This is an alternative to specifying stacking directly when encoding position. First parameter is the field to be stacked; the second the fields to group by; the third and fourth are the names to give the output field names; the fifth lists the optional offset and sort properties.

Stack offset when applying a stack transformation.

Rescale a stacked layout to use a common height while preserving relative size of stacked quantities. Used by pStack and stOffset.

Offset a stacked layout using a central stack baseline. Used by pStack and stOffset.

Offset a stacked layout using a baseline at the foot of a stack. Used by pStack and stOffset.

Do not stack marks (produces a layered plot). Used by pStack and stOffset.

Ordering within a stack when applying a stack transformation.

Indicate that the given field should be sorted in ascending order. Used by stSort.

Indicate that the given field should be sorted in descending order. Used by stSort.

Generate a new data field based on some calculations from existing values and fields. The first parameter is an expression representing the calculation and the second is the name to give the newly calculated field.

trans =
    transform << calculateAs "datum.sex == 2 ? 'F' : 'M'" "gender"

Apply a filter to a channel or field that specifies which values will 'pass through' for encoding. A filter can an expression such as,

trans =
    transform << filter (fiExpr "datum.y < 50")

noting that to refer to a particular data value, prefix the field name with datum.. Alternatively a boolean filtering function such as fiOneOf or fiLessThan can be supplied,

trans =
    transform << filter (fiLessThan "y" (num 50))

Filter a data stream so that only data in a given field equal to the given value are used. Used by filter, fiOp and fiOpTrans.

Filter a data stream so that only data in a given field less than the given value are used. Used by filter, fiOp and fiOpTrans.

Filter a data stream so that only data in a given field less than or equal to the given value are used. Used by filter, fiOp and fiOpTrans.

Filter a data stream so that only data in a given field greater than the given value are used. Used by filter, fiOp and fiOpTrans.

Filter a data stream so that only data in a given field greater than or equal to the given value are used. Used by filter, fiOp and fiOpTrans.

Filter a data stream so that only data that satisfy the given predicate expression are used. Used by filter, fiOp and fiOpTrans.

Filter a data stream in response to the value of a selection parameter. Useful for creating interactive filtering from a selection. Used by filter, fiOp and fiOpTrans.

Similar to fiSelection except that an empty selection filters out all values. Used by filter, fiOp and fiOpTrans.

Convert a filter into a BooleanOp so that it may be used as part of a more complex Boolean composition. Used by prTest, fiCompose, axDataCondition, and, or and not.

trans =
    transform
        << filter
            (fiCompose
                (and
                    (fiValid "IMDB_Rating" |> fiOp)
                    (fiValid "Rotten_Tomatoes_Rating" |> fiOp)
                )
            )

Combine a data transformation operation with a filter before converting into a Boolean operation. This can be useful when working with dates. Used by prTest, fiCompose, axDataCondition, and, or and not. For example, the following will aggregate a set of dates into years and filter only those years between 2010 and 2017 inclusive:

filter
    (fiRange "date" (dtRange [ dtYear 2010 ] [ dtYear 2017 ])
        |> fiOpTrans (mTimeUnit year)
        |> fiCompose
    )

Note the use of fiCompose to convert the Boolean operation back into a Filter.

Build up a filtering predicate through logical composition (and, or etc.). Used by filter, fiOp and fiOpTrans. For example, to filter only items selected interactively and that represent ages over 65:

trans =
    transform
        << filter
            (fiCompose
                (and (selected "brush") (expr "datum.age > 65"))
            )

Filter a data stream so that only data in a given field contained in the given list of values are used. Used by filter, fiOp and fiOpTrans.

Filter a data stream so that only data in a given field that are within the given range are used. Used by filter, fiOp and fiOpTrans.

For example,

filter (fiRange "date" (dtRange [ dtYear 2006 ] [ dtYear 2016 ]))

Filter a data stream so that only valid data (i.e. not null or NaN) in a given field are used. Used by filter, fiOp and fiOpTrans.

Minimum-maximum number range to be used in data filtering. Used by fiRange.

Min max date-time range to be used in data filtering. If either parameter is an empty list, it is assumed to be unbounded. Used by fiRange.

Map array-valued fields to a set of individual data objects, one per array entry.

Similar to flatten but allows the new output fields to be named (second parameter).

Perform a gather operation to tidy a table. Collapse multiple data fields into two new data fields: key containing the original data field names and value containing the corresponding data values. This performs the same function as 'gather' in the Tidy Elm package and the pivot_longer / gather operation in the R tidyverse . It is the inverse of pivot.

data =
    dataFromColumns []
        << dataColumn "city" (strs [ "Bristol", "Sheffield", "Glasgow" ])
        << dataColumn "temp2017" (nums [ 12, 11, 7 ])
        << dataColumn "temp2018" (nums [ 14, 13, 10 ])


trans =
    transform
        << fold [ "temp2017", "temp2018" ]


enc =
    encoding
        << position X [ pName "key", pNominal ]
        << position Y [ pName "city", pNominal ]
        << size [ mName "value", mQuant ]

Similar to fold but allows the new output key and value fields to be given alternative names.

Perform a pivot operation on a table. Spreads a key-value pair of fields across multiple fields according to the data in the key field. The first two parameters are the key and value fields respectively. The third is a set of customisation options. This performs the same function as 'spread' in the Tidy Elm package and the pivot_wider / spread operation in the R tidyverse. It is the inverse of fold.

data =
    dataFromColumns []
        << dataColumn "city" (strs [ "Bristol", "Bristol", "Sheffield", "Sheffield", "Glasgow", "Glasgow" ])
        << dataColumn "temperature" (nums [ 12, 14, 11, 13, 7, 10 ])
        << dataColumn "year" (nums [ 2017, 2018, 2017, 2018, 2017, 2018 ])


trans =
    transform
        << pivot "year" "temperature" [ piGroupBy [ "city" ] ]


enc =
    encoding
        -- 2017 temperatures for the Bristol, Sheffield and Glasgow
        << position X [ pName "2017", pQuant ]
        << position Y [ pName "city", pNominal ]

The data fields to group by when performing a pivot. If not specified, a single group containing all data objects will be used.

Maximum number of fields to generate performing a pivot. If 0 or unspecified, all fields are pivoted. The pivot names are sorted in ascending order before any limit is applied.

The aggregation to apply to grouped fields during a pivot.

Perform a lookup of named fields between two data sources. This allows you to find values in one data source based on the values in another. The first parameter is the field in the primary data source to act as key, the second is the secondary data source which can be specified with a call to dataFromUrl or other data generating function. The third is the name of the field in the secondary data source to match values with the primary key. The fourth parameter is the list of fields to be stored when the keys match.

For linking data with interactive selections, see lookupSelection.

A common use for lookup is to join geographic and attribute data sources. Below geodata is the primary data source containing borough boundaries and censusData the secondary data source containing attribute data. Both have common data field values identifying a borough (id and borough) that is used to join the data sources:

geoData =
    dataFromUrl "city.json" [ topojsonFeature "boroughs" ]


censusData =
    dataFromUrl "census.csv" []


trans =
    transform
        << lookup "id"
            (censusData [])
            "borough"
            (luFields [ "carOwnership", "numBedrooms" ])

Attach the results of an interactive selection to a primary data source. The first three parameters are the field in the primary data source to look up; the name of the interactive selection parameter; and the name of the field in the selection to link with the primary data field. This is similar to lookup except that the data in a selection are used in place of the secondary data source.

  ps =
      params
          << param "mySel"
              [ paSelect sePoint [ seOn "mouseover", seEncodings [ chX ] ] ]


  trans =
      transform
          << lookupSelection "country" "mySel" "country"

Names of the fields to be returned from a secondary data source when performing a lookup transformation.

The same as luFields except with a second parameter providing the default value if the lookup fails.

Names of the fields and their aliases to be returned from a secondary data source when performing a lookup transformation. Each tuple should be a name of a field to return followed by the new name to give it. Unlike luAs this allows separate aliases to be given to each matched field.

The same as luFieldsAs except with a second parameter providing the default value if the lookup fails.

Name to give the entire set of fields in a secondary data source when performing a lookup. To refer to individual fields via this name, use Javascript dot notation (or if the field contains spaces, use equivalent array index notation in single quotes such as o['my field']).

data =
    dataFromUrl "data/flights-airport.csv" []


trans =
    transform
        << lookup "origin"
            (dataFromUrl "data/airports.csv" [])
            "iata"
            (luAs "o")


enc =
    encoding
        << position Longitude [ pName "o.longitude", pQuant ]
        << position Latitude [ pName "o.latitude", pQuant ]

The same as luAs except with a second parameter providing the default value if the lookup fails.

Impute missing data values as a data transform. The first parameter is the data field to process; the second the key field to uniquely identify data objects within a group; the third customisable options.

For example, to impute the missing value of b with the mean of existing b values, when a is 30 and its color group (c) is 1:

let
    data =
        dataFromColumns []
            << dataColumn "a" (nums [ 0, 0, 10, 10, 20, 20, 30 ])
            << dataColumn "b" (nums [ 28, 91, 43, 55, 81, 53, 19 ])
            << dataColumn "c" (nums [ 0, 1, 0, 1, 0, 1, 0 ])


    trans =
        transform
            << impute "b" "a" [ imMethod imMean, imGroupBy [ "c" ] ]


    enc =
        encoding
            << position X [ pName "a", pQuant ]
            << position Y [ pName "b", pQuant ]
            << color [ mName "c", mNominal ]
in
toVegaLite [ data [], trans [], enc [], line [] ]

1d window over which data imputation values are generated. The two parameters should either be Just a number indicating the offset from the current data object, or Nothing to indicate unbounded rows preceding or following the current data object. Used by pImpute.

Key values to be considered for imputation. Used by pImpute.

Key values to be considered for imputation as a sequence of numbers between a start (first parameter), to less than an end (second parameter) in steps of the third parameter. Used by pImpute.

Imputation method to use when replacing values. Used by pImpute.

Allow imputing of missing values on a per-group basis. For use with the impute transform only and not a channel encoding. Used by pImpute.

New value to use when imputing with imValue. Used by pImpute.

Use field value when imputing missing data. Used by imMethod.

Use mean of values when imputing missing data. Used by imMethod.

Use median of values when imputing missing data. Used by imMethod.

Use maximum of values when imputing missing data. Used by imMethod.

Use maximum of values when imputing missing data. Used by imMethod.

Randomly sample rows from a data source up to a given maximum. For example, to randomly sample 50 values from a sine curve:

data =
    dataSequenceAs 0 13 0.001 "x"


trans =
    transform
        << calculateAs "sin(datum.x)" "y"
        << sample 50

Apply Kernel Density Estimation to a data stream to generate a new stream of samples of the estimated density. Useful for representing probability distributions and generating continuous distributions from discrete samples.

The data fields to group by when estimating density. If not specified, a single group containing all data objects will be used.

Whether or not density estimates will be cumulative. If unspecified, non-cumulative estimates will be generated.

Whether density estimates should generate counts (true) or probabilities (false). If unspecified, probabilities will be generated.

The bandwidth (standard deviation) of the Gaussian kernel used in KDE estimation. If 0 or unspecified, the bandwidth will be calculated using Scott's method. Used by density.

The min (first parameter) - max (second parameter) domain from which to sample a distribution for density estimation. If unspecified, the full extent of input values will be sampled.

The minimum number of samples to take from the extent domain when estimating density. Default is 25.

The maximum number of samples to take when estimating density. Default is 200.

The exact number of samples to take from the extent domain when estimating density. Will override dnMinSteps and dnMaxSteps and is useful in conjunction with a fixed extent to ensure consistent sample points for stacked densities.

Name the outputs of the density transform. The first parameter is the name to give the field containing samples, the second the name to give the field containing density estimates. If not specified, the default names value and density will be used.

Generate a loess (locally-estimated scatterplot smoothing) trendline through a pair of data fields. The first parameter is the name of the field representing the dependent variable (commonly mapped to the y-axis), the second is the name of the field representing the independent variable (commonly mapped to the x-axis). The third parameter is a list of optional loess parameters to customise the trend fitting.

The data fields to group by when generating a loess trendline. If not specified, a single group containing all data objects will be used.

The bandwidth scaled between [0,1] to determine the amount of loess smoothing. Default value is 0.3

Name the outputs of a loess transform. The first parameter is the name to give the field containing the smoothed independent variable, the second the name to give the field containing smoothed dependent variable. If not specified, the original input independent and dependent field names are used.

Generate a 2d regression model for smoothing and predicting data. The first parameter is the name of the field representing the dependent variable (commonly mapped to the y-axis), the second is the name of the field representing the independent variable (commonly mapped to the x-axis). The third parameter is a list of optional regression customisation options.

The data fields to group by when generating a regression model. If not specified, a single group containing all data objects will be used.

The type of regression model to use when generating a 2d regression. Used by rgMethod.

The order of a polynomial model to use when generating a 2d regression. Only applies if rgMethod is set to rgPoly.

The min (first parameter) - max (second parameter) domain over which to estimate the dependent variable in a regression. If unspecified, the full extent of input values will be used.

Whether or not the regression transform should return just the parameters of the regression function (one object per group) instead of trend line points. If True, objects include a coef array of fitted coefficient values, starting with the intercept term and then terms of increasing order and an rSquared value, indicating the total variance explained by the model.

Name the outputs of a regression transform. The first parameter is the name to give the field containing the independent variable, the second the name to give the field containing dependent variable. If not specified, the original input independent and dependent field names are used.

Indicate a linear regression method. Used by rgMethod.

Indicate a log regression method. Used by rgMethod.

Indicate an exponential regression method. Used by rgMethod.

Indicate a power regression method. Used by rgMethod.

Indicate a quadratic regression method. Used by rgMethod.

Indicate a polynomial regression method. The order of the polynomial can be set with rgOrder (defaulting to cubic if not provided). Used by rgMethod.

Calculate quantile values from an input data stream. Useful for examining distributional properties of a data stream and for creating Q-Q plots.

The data fields to group by when performing a quantile transformation. If not specified, a single group containing all data objects will be used.

A list of probabilities in the range [0,1] for which to compute quantile values. If not specified, the default step size of 0.01 or the value specified via qtStep will be used.

The interval between probabilities to use when performing a quantile transformation. All values from half the given step size to 1 will be sampled. Only used if qtProbs is not specified.

The field names to give the probability and associated quantile values generated by a quantile transformation. If not specified, prob and value are used.

Window transform for performing calculations over sorted groups of data objects such as ranking, lead/lag analysis, running sums and averages.

The first parameter is a list of tuples each comprising a window transform field definition and an output name. The second is the window transform definition.

   trans =
       transform
           << window [ ( [ wiAggregateOp opSum, wiField "Time" ], "TotalTime" ) ]
               [ wiFrame Nothing Nothing ]

An aggregate operation to be used in a window transformation. For example,

transform
    << window [ ( [ wiAggregateOp opSum, wiField "Time" ], "TotalTime" ) ]
        [ wiFrame Nothing Nothing ]

Window-specific operation to be used in a window transformation.

Numeric parameter for window-only operations that can be parameterised (woPercentile, woLag, woLead and woNthValue).

Field for which to compute a window operation. Not needed for operations that do not apply to fields such as opCount, woRank and woDenseRank.

Assign consecutive row number to values in a data object to be applied in a window transform. Used by wiOp.

Rank opertation to be applied in a window transform. Used by wiOp.

Dense rank operation to be applied in a window transform. Used by wiOp.

Percentile of values in a sliding window be applied in a window transform. Used by wiOp.

Cumulative distribution operation to be applied in a window transformation. Used by wiOp.

Value preceding the current object in a sliding window to be applied in a window transform. Used by wiOp.

Value preceding the current object in a sliding window to be applied in a window transform. Used by wiOp.

Value following the current object in a sliding window to be applied in a window transform. Used by wiOp.

First value in a sliding window to be applied in a window transform. Used by wiOp.

Last value in a sliding window to be applied in a window transform. Used by wiOp.

Nth value in a sliding window to be applied in a window transform. Used by wiOp.

Moving window for use by a window transform. The two parameters should either be Just a number indicating the offset from the current data object, or Nothing to indicate unbounded rows preceding or following the current data object.

Whether or not the sliding window frame in a window transform should ignore peer values (those considered identical by the sort criteria).

Fields for partitioning data objects in a window transform into separate windows. If unspecified, all points will be in a single group.

Comparator for sorting data objects within a window transform.

Indicate that the given field should be sorted in ascending order when performing a window transform. Used by wiSort.

Indicate that the given field should be sorted in descending order when performing a window transform. Used by wiSort.

Arc mark for radial plots such as pie charts or rose diagrams.

An area mark for representing a series of data elements, such as in a stacked area chart or streamgraph.

Bar mark for histograms, bar charts etc.

Boxplot composite mark for showing summaries of statistical distributions. By default, just box and whiskers are shown, but ticks and outliers can be specified explicitly.

boxplot
    [ maTicks [ maColor "black", maSize 8 ]
    , maBox [ maFill "grey" ]
    , maOutliers [ maColor "firebrick" ]
    ]

Errorband composite mark for showing summaries of variation along a signal. By default no border is drawn. To add a border use maBorders with an empty list for default border, or mark properties to customise.

errorband [ maBorders [ maColor "black", maStrokeWidth 0.5 ] ]

Errorbar composite mark for showing summaries of variation along a signal. By default no ticks are drawn. To add ticks with use maTicks with an empty list for default appearance, or with a list of mark properties to customise.

errorbar [ maTicks [ maColor "black", maSize 8 ] ]

Circle mark for symbolising points. Unlike the point mark, circles are filled by default and may be sized via a separate size encoding.

Display a geoshape determined by geographically referenced coordinates.

myMap : Spec
myMap =
    let
        myData =
            dataFromUrl "https://gicentre.github.io/data/geoTutorials/londonBoroughs.json"
                [ topojsonFeature "boroughs" ]


        proj =
            projection
                [ prType transverseMercator
                , prRotate 2 0 0
                ]
    in
    toVegaLite
        [ myData
        , proj
        , geoshape
            [ maFill "lightgrey"
            , maStroke "white"
            ]
        ]

Image mark for displaying an image. The parameter is a list of standard mark properties for customising the image. The image files to be displayed should be specified via the url channel. Normally, the width and height of the image should be specified with maWidth and maHeight.

let
    data =
        dataFromColumns []
            << dataColumn "x" (nums [ 0.5, 1.5, 2.5 ])
            << dataColumn "y" (nums [ 0.5, 1.5, 2.5 ])


    enc =
        encoding
            << position X [ pName "x", pQuant ]
            << position Y [ pName "y", pQuant ]
            << url [ hStr "myImage.png" ]
in
toVegaLite [ data [], enc [], image [ maWidth 50, maHeight 25 ] ]

Alternatively, data-driven images can be used by referencing a data field containing image URLs.

let
    data =
        dataFromColumns []
            << dataColumn "x" (nums [ 0.5, 1.5, 2.5 ])
            << dataColumn "y" (nums [ 0.5, 1.5, 2.5 ])
            << dataColumn "img" (strs [ "img1.png", "img2.png", "img3.png" ])


    enc =
        encoding
            << position X [ pName "x", pQuant ]
            << position Y [ pName "y", pQuant ]
            << url [ hName "img", hNominal ]
in
toVegaLite [ data [], enc [], image [ maWidth 30, maHeight 30 ] ]

Line mark for symbolising a sequence of values.

Point mark for symbolising a data point with a symbol.

Rectangle mark.

Rule line connecting two vertices.

Square mark for symbolising points.

Text mark to be displayed at some point location.

Short line (tick) mark for symbolising point locations.

Trail mark (line with variable width along its length).

Provide an expression to a mark property function requiring a boolean value. This can be used to provide an interactive parameterisation of a mark property by providing an expression bound to an input element. For example,

ps =
    params
        << param "asp"
            [ paValue (boo True)
            , paBind (ipCheckbox [ inName "maintain aspect ratio" ])
            ]


mk =
    image [ maBooExpr "asp" maAspect ]

Provide an expression to a mark property function requiring a numeric value. This can be used for interactive parameterisation when an expression is bound to an input element. For example,

ps =
    params
        << param "r"
            [ paValue (num 0)
            , paBind (ipRange [ inMax 100 ])
            ]


mk =
    arc [ maNumExpr "r" maInnerRadius ]

Provide an expression to a mark property function requiring a list of numbers (for dash styles). This can be used to provide an interactive parameterisation of a mark's dash property when an expression is bound to an input element. For example,

ps =
    params
        << param "dashStyle"
            [ paValue (nums [ 2, 2 ])
            , paBind (ipSelect [ inDataOptions [ nums [ 2, 2 ], nums [ 8, 8 ] ] ])
            ]


mk =
    bar
        [ maNumsExpr "dashStyle" maStrokeDash, maStroke "black" ]

Provide an expression to a mark property function requiring a string value. This can be used to provide an interactive parameterisation of a mark property by providing an expression bound to an input element. For example,

ps =
    params
        << param "clr"
            [ paValue (str "red")
            , paBind (ipColor [])
            ]


mk =
    circle [ maStrExpr "clr" maFill ]

Horizontal alignment of a textMark.

Rotation angle of a textMark (degrees from horizontal).

ARIA properties for providing accessible SVG output associated with a mark such as bar or line. If an empty list is provided, ARIA tagging will be switched off.

Band size of a bar mark.

Vertical alignment of a textMark.

Offset between bars for a binned field using a bar mark.

Color blend mode for drawing a mark such as bar or circle over its current background. Standard CSS blend modes can be specified such as bmHue, bmDarken etc.

Border properties for an errorband mark.

Box symbol properties for the boxplot mark. If an empty list is provided, no box will be shown.

Whether or not a mark such as bar or line should be clipped to the enclosing group's dimensions.

Determine whether or not invalid (null and NaN) values are considered for encoding as marks such as bar or point. If true (default), invalid values are ignored, otherwise they are treated as if 0.

Default color of a mark. Note that maFill and maStroke have higher precedence and will override this if specified. Used by mark functions such as bar and line.

Color strings can use any valid HTML color specification.

maColor "#eee"


maColor "#734FD8"


maColor "crimson"


maColor "rgb(255,204,210)"


maColor "hsl(180, 50%, 50%)"

A color gradient to apply to a mark such as bar or circle. The first parameter indicates whether the gradient should be linear or radial. The second is a set of customisation options for the colors, positioning and rate of change of the gradient. For example, to set a radial red-blue color gradient for a mark:

maColorGradient grRadial [ grStops [ ( 0, "red" ), ( 1, "blue" ) ] ]

The radius in pixels of selected marks' corners. For rectangular marks such as bar, it shapes all four corners; for arc marks it shapes the vertices of segment. Default is 0 indicating no rounding.

The radius in pixels of the 'end' corners of a bar mark. For vertical bars this would be the top corners and for horizontal bars, the right corners.

The radius in pixels of the top-left corner of a rectangular mark such as bar. Will override any value specified in maCornerRadius.

The radius in pixels of the top-right corner of a rectangular mark such as bar. Will override any value specified in maCornerRadius.

The radius in pixels of the bottom-left corner of a rectangular mark such as bar. Will override any value specified in maCornerRadius.

The radius in pixels of the bottom-right corner of a rectangular mark such as bar. Will override any value specified in maCornerRadius.

Cursor to be associated with a hyperlink mark.

Extent of whiskers used in a boxplot, errorbar or errorband.

Hyperlink to be associated with a mark such as a circle making it a clickable hyperlink.

Continuous band size of a bar mark.

Discrete band size of a bar mark.

Width in pixels indicating maximum permitted space for a [textMark](#textMark Any mark that exceeds this limit will be truncated with an ellipsis.

Direction of text in a textMark, which determines which end is truncated in cases where text is larger than available space.

Text to indicate a truncated piece of a textMark. Default is the ellipsis ...

Horizontal offset between a textMark and its anchor.

Vertical offset between a textMark mark and its anchor.

Fix the inner radius (R2) of a radial plot using an arc mark. Can be used for creating 'holes' in pie chart.

Fix the outer radius (R) of a radial plot using an arc mark.

Angular padding applied to sides of an arc mark (in radians).

Default fill color of a mark such as bar or circle. Color strings can use any valid HTML color specification.

maFill "#eee"


maFill "#734FD8"


maFill "crimson"


maFill "rgb(255,204,210)"


maFill "rgba(255,50,80,0.3)"


maFill "hsl(180, 50%, 50%)"

Usually, to avoid filling the interior of a mark, use maFilled False, but maFill "" can instead be used for cases where an interactive tooltip needs to 'see through' a stroked mark to one underneath it in a layered specification.

A color gradient to apply to a mark's interior. The first parameter indicates whether the gradient should be linear or radial. The second is a set of customisation options for the colors, positioning and rate of change of the gradient. For example, to set a radial red-blue color gradient as a fill for a mark:

maStrokeGradient grRadial [ grStops [ ( 0, "red" ), ( 1, "blue" ) ] ]

Fill gradients have a higher priority than maColorGradient. Used by mark functions such as bar and circle.

Whether or not a mark's color should be used as the fill color instead of stroke color. Used by mark functions such as bar and circle.

Fill opacity of a mark such as bar or circle.

Font of a textMark. Can be any font name made accessible via a css file (or a generic font like serif, monospace etc.).

Font size in pixels used by a textMark.

Font style (e.g. italic) used by a textMark.

Font weight used by a textMark.

Interpolation method used by line and area marks. For example, to create a curved line joining data points:

line [ maInterpolate miMonotone ]

Overall opacity of a mark such as bar or line in the range 0 (completely transparent) to 1 (completely opaque).

Ordering of vertices in a line or area mark. If true (default), order is determined by measurement type or order channel. If false, the original data order is used.

Orientation of a non-stacked bar, tick, area or line mark.

Appearance of a point marker joining the vertices of a line or area mark.

line [ maPoint (pmMarker [ maFill "black" ]) ]

Appearance of a line marker joining the vertices of an area mark. For example,

area
    [ maLine (lmMarker [ maStroke "black" ])
    , maInterpolate miMonotone
    ]

Median line properties for the boxplot mark. If an empty list is provided, no median line will be shown.

Outlier symbol properties for the boxplot mark. If an empty list is provided, no outliers will be shown.

Radial offset of a textMark from an origin specified in Cartesian X and Y coordinates.

Rule (main line) properties for the errorbar and boxplot marks. If an empty list is provided, no rule will be shown.

Shape of a point mark.

Whether or not month and weekday names are abbreviated in a textMark.

Size of a mark such as a circle or square in square units. For example, to create a circle of diameter 50 pixels:

circle [ maSize 2500 ]

Default stroke color of a mark such as circle or bar. Color strings can use any valid HTML color specification.

maStroke "#eee"


maStroke "#734FD8"


maStroke "crimson"


maStroke "rgb(255,204,210)"


maStroke "hsl(180, 50%, 50%)"

An empty string ("") indicates that no stroke around a mark be drawn.

A color gradient to apply to a mark's boundary stroke. The first parameter indicates whether the gradient should be linear or radial. The second is a set of customisation options for the colors, positioning and rate of change of the gradient. For example, to set a radial red-blue color gradient for a mark's stroke:

maStrokeGradient grRadial [ grStops [ ( 0, "red" ), ( 1, "blue" ) ] ]

Stroke gradients have a higher priority than maColorGradient.

Used by mark functions such as bar and line.

Cap style of a mark's stroke. Used by mark functions such as point and line.

Rounded stroke cap. Used by maStrokeCap, axDomainCap, axcoDomainCap, axTickCap, axcoTickCap, axGridCap, axcoGridCap, viewStrokeCap and vicoStrokeCap.

Square stroke cap. Used by maStrokeCap, axDomainCap, axcoDomainCap, axTickCap, axcoTickCap, axGridCap, axcoGridCap, viewStrokeCap and vicoStrokeCap.

Butt stroke cap. Used by maStrokeCap, axDomainCap, axcoDomainCap, axTickCap, axcoTickCap, axGridCap, axcoGridCap, viewStrokeCap and vicoStrokeCap.

Expression that evaluates to some stroke cap style such as "square", "butt" or "round". Used by maStrokeCap, axDomainCap, axcoDomainCap, axTickCap, axcoTickCap, axGridCap, axcoGridCap, viewStrokeCap and vicoStrokeCap.

Stroke dash style used by a mark such as circle or line. Determined by an alternating 'on-off' sequence of line lengths.

Number of pixels before the first line dash is drawn in a mark such as line.

Line segment join style of a mark's stroke. Used by mark functions such as point and line.

Rounded stroke join. Used by maStrokeJoin, viewStrokeJoin and vicoStrokeJoin.

Bevelled stroke join. Used by maStrokeJoin, viewStrokeJoin and vicoStrokeJoin.

Mitred stroke join. Used by maStrokeJoin, viewStrokeJoin and vicoStrokeJoin.

Expression that evaluates to some stroke join style such as "bevel", "miter" or "round". Used by maStrokeJoin, viewStrokeJoin and vicoStrokeJoin.

Mitre limit at which to bevel a join between line segments of a mark's stroke. Used by mark functions such as point and line.

Stroke opacity of a mark in the range 0 to 1. Used by mark functions such as circle or bar.

Stroke width of a mark in pixel units. Used by mark functions such as circle or bar.

Names of custom styles to apply to a mark such as bar or area. Each should refer to a named style defined in a separate style configuration with coMarkStyles. While this is provided for compatibility with Vega-Lite style specification, for greater type safety in elm-vegalite, instead create functions that generate MarkProperties.

Interpolation tension used when interpolating line and area marks.

Placeholder text for a textMark for when a text channel is not specified. Multi-line text can be specified by adding a \n at each line break or by using a """ multi-line string.

Line height for a multi-line textMark.

Polar coordinate angle (clockwise from north in radians) of an arc or textMark. If a text mark it represents polar coordinate angle relative to an origin determined by its x and y properties. For an arc mark it is its length in radians or, when combined with maTheta2, the arc's start angle.

Polar coordinate angle (clockwise from north in radians) of the end of an arc mark.

Thickness of a tick mark.

Tick properties for the errorbar or boxplot mark.

Provide source of a mark's tooltip content. For example to show all encoded data values in the tooltip of a circle mark:

circle [ maTooltip ttEncoding ]

An image mark's URL.

Explicitly set the width of a mark such as a bar.

Set the width of a mark as a proportion of its band size. For example, to set a bar width to be three quarters of its normal width,

bar [ maWidthBand 0.75 ]

Explicitly set the height of a mark such as rect.

Set the height of a bar mark as a proportion of its band size.

X position of a mark such as a point or square.

Y position of a mark such as rect or [rule][#rule].

X position offset for a mark such as textMark.

Y position offset for a mark such as textMark.

Clockwise angular offset (in radians) of a radially positioned mark such as an arc.

Clockwise angular offset (in radians) of the second theta value of a radially positioned mark such as an arc. Useful when the offsets to apply to the start and end angle of an arc need to be set independently.

X2 position (secondary x value for linear marks such as rule and areal marks such as rect).

Y2 position (secondary y value for linear marks such as rule and areal marks such as rect).

X2 position offset for a mark such as rect or [rule][#rule].

Y2 position offset for a mark.

Polar coordinate radial offset of a textMark or arc mark from a polar origin specified with Theta and R.

Polar coordinate inner radial offset of an arc mark from a polar origin specified with Theta, R and R2.

Whether or not the aspect ratio of an image mark should be preserved.

Indicate a linear color gradient. See the Vega-Lite color gradient documentation. Used by maColorGradient, maFillGradient and maStrokeGradient.

Indicate a radial color gradient. See the Vega-Lite color gradient documentation. Used by maColorGradient, maFillGradient and maStrokeGradient.

The x-coordinate, normalised to [0, 1], for the start of a color gradient. If the gradient is linear the default is 0; if radial, it is the x-position of the centre of the inner circle with a default of 0.5. Used by maColorGradient, maFillGradient and maStrokeGradient.

The x-coordinate, normalised to [0, 1], for the end of a color gradient. If the gradient is linear the default is 1; if radial, it is the x-position of the centre of the outer circle with a default of 0.5. Used by maColorGradient, maFillGradient and maStrokeGradient.

The y-coordinate, normalised to [0, 1], for the start of a color gradient. If the gradient is linear the default is 0; if radial, it is the y-position of the centre of the inner circle with a default of 0.5. Used by maColorGradient, maFillGradient and maStrokeGradient.

The y-coordinate, normalised to [0, 1], for the end of a color gradient. If the gradient is linear the default is 1; if radial, it is the y-position of the centre of the outer circle with a default of 0.5. Used by maColorGradient, maFillGradient and maStrokeGradient.

The radius, normalised to [0, 1], of the inner circle for a radial color gradient. Default is 0. Used by maColorGradient, maFillGradient and maStrokeGradient.

The radius, normalised to [0, 1], of the outer circle for a radial color gradient. Default is 0.5. Used by maColorGradient, maFillGradient and maStrokeGradient.

Color interpolation points. Each tuple in the list is a position normalised [0, 1] and its associated color. Used by maColorGradient, maFillGradient and maStrokeGradient.

Enable ARIA attributes when generating SVG output. Default is that Aria is enabled, so this is only useful when overriding more global disabling of Aria attributes. Used by maAria, axAria, axcoAria, leAria and lecoAria.

Disable ARIA attributes when generating SVG output. Default is that Aria is enabled. Used by maAria, axAria, axcoAria, leAria and lecoAria.

Description to be provided in ARIA tag when generating SVG output. If not specified, the an auto-generated description will be provided. Used by maAria, axAria, axcoAria, leAria and lecoAria.

Set ARIA attributes with the the given expression. Used by maAria, axAria, axcoAria, leAria and lecoAria. For example,

params
    << param "barDesc"
        [ paValue (dataObject [ ( "description", str "Bar chart bar" ) ]) ]


bar [ maAria [ arExpr "barDesc" ] ]

Indicate horizontal mark orientation. Used by maOrient, leDirection, lecoDirection, lecoGradientDirection and lecoSymbolDirection.

Indicate vertical mark orientation. Used by maOrient, leDirection, lecoDirection, lecoGradientDirection and lecoSymbolDirection.

Cubic basis spline interpolation between points anchored at first and last points. Used by maInterpolate.

Open cubic basis spline interpolation between points, which may not intersect first and last points. Used by maInterpolate.

Closed cubic basis spline interpolation between points forming a polygon. Used by maInterpolate.

Bundle curve interpolation between points.

Cubic cardinal spline interpolation between points anchored at first and last points. Used by maInterpolate.

Open cubic cardinal spline interpolation between points, which may not intersect first and last points. Used by maInterpolate.

Closed cubic cardinal spline interpolation between points forming a polygon. Used by maInterpolate.

Linear (straight) interpolation between points. Used by maInterpolate.

Linear (straight) interpolation between points that joins the first and last points in a sequence to form a closed polygon. Used by maInterpolate.

Cubic spline interpolation that preserves monotonicity between points. Used by maInterpolate.

Piecewise (stepped) constant interpolation function centred on each point in a sequence. Used by maInterpolate.

Piecewise (stepped) constant interpolation function after each point in a sequence. Used by maInterpolate.

Piecewise (stepped) constant interpolation function before each point in a sequence. Used by maInterpolate.

Expression that evaluates to some interpolation method such as "linear", "basis" or "monotone". Used by maInterpolate.

Indicate a left-to-right text direction.

Indicate a right-to-left text direction.

Expression that evaluates to a text direction "ltr" (left-to-right) or 'rtl' (right-to-left) .

Specify a circular symbol for a shape mark. Used by maShape, mSymbol, leSymbolType, lecoSymbolType and racoSymbols.

Specify a cross symbol for a shape mark. Used by maShape, mSymbol, leSymbolType, lecoSymbolType and racoSymbols.

Specify a diamond symbol for a shape mark. Used by maShape, mSymbol, leSymbolType, lecoSymbolType and racoSymbols.

Specify a square symbol for a shape mark. Used by maShape, mSymbol, leSymbolType, lecoSymbolType and racoSymbols.

Specify an upward triangular symbol for a shape mark. Used by maShape, mSymbol, leSymbolType, lecoSymbolType and racoSymbols.

Specify a downward triangular symbol for a shape mark. Used by maShape, mSymbol, leSymbolType, lecoSymbolType and racoSymbols.

Specify a leftward facing triangular symbol for a shape mark. Used by maShape, mSymbol, leSymbolType, lecoSymbolType and racoSymbols.

Specify a rightward facing triangular symbol for a shape mark. Used by maShape, mSymbol, leSymbolType, lecoSymbolType and racoSymbols.

A custom symbol shape as an SVG path description. Used by maShape, mSymbol, leSymbolType, lecoSymbolType and racoSymbols.

Specify a linear symbol for a shape mark. Note that this will only be visible if the symbol has a stroke setting (unlike all the other areal symbols filling it has no effect). Used by maShape, mSymbol, leSymbolType, lecoSymbolType and racoSymbols.

Specify a centred arrow symbol for a shape mark. Useful for vector plots. Used by maShape, mSymbol, leSymbolType, lecoSymbolType and racoSymbols.

Specify a centred wedge (thin triangle) symbol for a shape mark. Useful for vector plots. Used by maShape, mSymbol, leSymbolType, lecoSymbolType and racoSymbols.

Specify a centred triangle symbol for a shape mark. Useful for vector plots. Used by maShape, mSymbol, leSymbolType, lecoSymbolType and racoSymbols.

Expression that evaluates to some symbol such as "diamond", "cross" or "circle". Used by maShape, mSymbol, leSymbolType, lecoSymbolType and racoSymbols.

No point marker to be shown on a line or area mark. Used by maPoint.

Transparent point marker to be placed on area or line mark. Useful for interactive selections. Used by maPoint.

Properties of a point marker that is overlaid on a line or area mark. Used when specifying an maPoint.

Properties of a line marker that is overlaid on an area mark. Used when specifying an maLine.

Indicate no line marker on an area mark. Used when specifying an maLine.

Band extent between the minimum and maximum values in a distribution. Used by maExtent.

Band extent between the 95% confidence intervals of a distribution. Used by maExtent.

Band extent between the lower and upper quartiles of a distribution. Used by maExtent.

A scaling of the interquartile range to be used as whiskers in a boxplot. For example, a value of 1.5 would extend whiskers to ±1.5x the IQR from the mean. Used by maExtent.

Band extent as the standard error about the mean of a distribution. Used by maExtent.

Band extent as the standard deviation of a distribution. Used by maExtent.

Indicate tooltips are generated by all fields in the underlying data. Used by maTooltip. For example,

circle [ maTooltip ttData ]

Indicate tooltips should be enabled using the encoded data of the mark. Used by maTooltip. For example,

circle [ maTooltip ttEncoding ]

Indicate that tooltips should be disabled for the mark (default). Used by maTooltip. For example,

circle [ maTooltip ttNone ]

Indicate the default blend mode should be applied when drawing over some background. Used by maBlend.

Multiplicative blend mode to be applied when drawing over some background. Used by maBlend.

Screen blend mode to be applied when drawing over some background. Used by maBlend.

Overlay blend mode to be applied when drawing over some background. Used by maBlend.

Darken blend mode to be applied when drawing over some background.

Lighten blend mode to be applied when drawing over some background. Used by maBlend.

Color dodge blend mode to be applied when drawing over some background.

Color burn blend mode to be applied when drawing over some background.

Hard light blend mode to be applied when drawing over some background. Used by maBlend.

Soft light blend mode to be applied when drawing over some background. Used by maBlend.

Difference blend mode to be applied when drawing over some background. Used by maBlend.

Exclusion blend mode to be applied when drawing over some background. Used by maBlend.

Hue blend mode to be applied when drawing over some background. Used by maBlend.

Saturation blend mode to be applied when drawing over some background. Used by maBlend.

Color blend mode to be applied when drawing over some background.

Luminosity blend mode to be applied when drawing over some background. Used by maBlend.

Expression that evaluates to some blend mode such as "darken", "hue" or "luminosity". Used by maBlend.

Automatically determine a cursor type depending on interaction context. Used by maCursor, smCursor and vicoCursor.

Default cursor. Used by maCursor, smCursor and vicoCursor.

No cursor. Used by maCursor, smCursor and vicoCursor.

Context menu cursor. Used by maCursor, smCursor and vicoCursor.

Help cursor. Used by maCursor, smCursor and vicoCursor.

Pointer cursor. Used by maCursor, smCursor and vicoCursor.

Progress cursor. Used by maCursor, smCursor and vicoCursor.

Waiting cursor. Used by maCursor, smCursor and vicoCursor.

Cell cursor. Used by maCursor, smCursor and vicoCursor.

Crosshair cursor. Used by maCursor, smCursor and vicoCursor.

Text cursor. Used by maCursor, smCursor and vicoCursor.

Vertical text cursor. Used by maCursor, smCursor and vicoCursor.

Alias cursor. Used by maCursor, smCursor and vicoCursor.

Copy cursor. Used by maCursor, smCursor and vicoCursor.

Move cursor. Used by maCursor, smCursor and vicoCursor.

'No drop' cursor. Used by maCursor, smCursor and vicoCursor.

'Not allowed' cursor. Used by maCursor, smCursor and vicoCursor.

Scrolling cursor. Used by maCursor, smCursor and vicoCursor.

Resizing cursor. Used by maCursor, smCursor and vicoCursor.

Resizing cursor. Used by maCursor, smCursor and vicoCursor.

Resizing cursor. Used by maCursor, smCursor and vicoCursor.

Resizing cursor. Used by maCursor, smCursor and vicoCursor.

Resizing cursor. Used by maCursor, smCursor and vicoCursor.

Resizing cursor. Used by maCursor, smCursor and vicoCursor.

Resizing cursor. Used by maCursor, smCursor and vicoCursor.

Resizing cursor. Used by maCursor, smCursor and vicoCursor.

Resizing cursor.

Resizing cursor. Used by maCursor, smCursor and vicoCursor.

Resizing cursor. Used by maCursor, smCursor and vicoCursor.

Resizing cursor. Used by maCursor, smCursor and vicoCursor.

Resizing cursor. Used by maCursor, smCursor and vicoCursor.

Resizing cursor. Used by maCursor, smCursor and vicoCursor.

Zooming cursor. Used by maCursor, smCursor and vicoCursor.

Zooming cursor. Used by maCursor, smCursor and vicoCursor.

Grab cursor. Used by maCursor, smCursor and vicoCursor.

Grabbing cursor. Used by maCursor, smCursor and vicoCursor.

Expression that evaluates to some cursor style such as "crosshair", "grab" or "help". Used by maCursor, smCursor and vicoCursor.

Create an encoding specification from a list of channel encodings. These are commonly built by chaining series of channel encoding functions together such as position, color, size etc.

enc =
    encoding
        << position X [ pName "month", pTemporal ]
        << position Y [ pName "score", pQuant ]
        << color [ mName "team" ]

Type of measurement to be associated with some channel.

• Nominal indicates categories that have no order. e.g. people's names; country names.
• Ordinal indicates ordered categories. e.g. Small / Medium / Large; 1st, 2nd, 3rd.
• Quantitative indicates numerical measurements and counts. e.g. price; temperature; frequency.
• Temporal indicates time-related data.
• GeoFeature indicates one or more geographic locations. e.g. a longitude/latitude; country outline.

Encode a position channel. The first parameter identifies the channel, the second a list of position encoding options.

enc =
    encoding
        << position X [ pName "month", pTemporal ]
        << position Y [ pName "numHires", pQuant ]

Type of position channel. X and Y position marks along the horizontal and vertical axes. X2 and Y2 are used in combination with X and Y when two boundaries of a mark need to be specified (e.g. a rule mark). XOffset and YOffset can additional shift position in response to some field, for example to create a grouped bar chart or jitter-plot.

Theta positions an arc mark's angular offset allowing, for example, pie chart segments to be specified. Theta2 allows an end angle to be specified in radians (where 0 is 'north'), useful for individual 'pie' segments.

R and R2 position the outer and inner radial edges of an arc segment. Useful for rose diagrams where arc radii are data-driven.

Longitude/Longitude2 and Latitude/Latitude2 are the equivalent for geographic positioning subject to projection.

XError/XError2 and YError/YError2 are used when specifying bounds of an errorbar mark.

Name of field used for encoding with a position channel.

Set a position to an arbitrary data value. Useful for placing items at the specific points in the data space. To place in data screen space, use pNum.

Reference in a position channel to a field name generated by repeatFlow or repeat. The parameter identifies whether reference is being made to fields that are to be encoded in layers, or in columns / rows with a flow layout. For example,

enc =
    encoding
        << position X [ pRepeat arFlow, pQuant ]


spec =
      asSpec [ data [], tick [], enc [] ]


toVegaLite
    [ repeatFlow [ "Horsepower", "Miles_per_Gallon", "Acceleration"]
    , specification spec
    ]

Reference in a position channel to a datum value generated by repeat.

Indicate a data field encoded as a position is nominal. This is the default data type.

Indicate a data field encoded as a position is ordinal.

Indicate a data field encoded as a position is quantitative. This is not necessary when field is aggregated by a numeric operator (e.g. opSum), scaled with a numeric operator (e.g. scLog), a position field is longitude/latitude or it is binned numerically.

Indicate a data field encoded as a position is temporal. This is not necessary if the field is aggregated with a time unit (e.g. pTimeUnit) or scaled with scTime or scUtc.

Indicate a data field encoded as a position is a geo feature.

Discretize numeric values into bins when encoding with a position channel. For non-default binning, bin-widths, extent etc. can be specified in the first parameter. For example, to encode a frequency histogram with bins every 5 units. For example,

enc =
    encoding
        << position X [ pName "x", pOrdinal, pBin [ biStep 5 ] ]
        << position Y [ pQuant, pAggregate opCount ]

Indicate that data encoded with position are already binned.

Form of time unit aggregation of field values when encoding with a position channel.

Title of a field when encoding with a position channel. For multi-line titles, insert \n at each line break or use a """ multi-line string.

Compute some aggregate summary statistics for a field to be encoded with a position channel. The type of aggregation is determined by the given operation parameter. For example,

enc =
    encoding
        << position X [ pName "role", pOrdinal ]
        << position Y [ pName "salary", pQuant, pAggregate opMean ]

Scaling applied to a field when encoding with a position channel. The scale will transform a field's value into a position along one axis.

For example, the following will scale the bars positioned along a horizontal axis to have an inner spacing of 50% (0.5) of the total space allocated to each bar:

enc =
    encoding
        << position X [ pName "ageGroup", pNominal, pScale [ scPaddingInner 0.5 ] ]

Axis properties used when encoding with a position channel. For no axis, provide an empty list.

Sort order for field when encoding with a position channel.

Specify mark position or size relative to band size. For non-rect marks, the relative position on a band of a stacked, binned, time unit or band scale is used. A value of 0, positions the mark at the beginning of the band; 0.5, in the middle etc.

For rect-based marks (rect, bar, and image), if set to 1, the mark size is set to the band width or the time unit interval. If set to 0.5, the mark size is half of the bandwidth or the time unit interval. etc.

Type of stacking offset for field when encoding with a position channel. For example, stacking areas away from a centre-line can be used to create a streamgraph:

enc =
    encoding
        << position X [ pName "week", pOrdinal ]
        << position Y [ pName "takings", pQuant, pStack stCenter ]
        << color [ mName "shop", mNominal ]

Set the position to the width of the enclosing data space. Useful for justifying a mark to the right hand edge of a view. e.g. to position a mark at the right of the data rectangle. For example,

enc =
    encoding
        << position X [ pWidth ]

Set the position to the height of the enclosing data space. Useful for placing a mark relative to the bottom edge of a view.

Set a position to an arbitrary value. Useful for placing items at the top of a plot area (pNum 0) or a fixed number of pixels from the top. To place in data sspace rather than screen space, use pDatum.

Imputation rules for a position channel. See the Vega-Lite impute documentation For example, to impute the missing value of b with the mean of existing b values, when a is 30 and its color group (c) is 1:

let
    data =
        dataFromColumns []
            << dataColumn "a" (nums [ 0, 0, 10, 10, 20, 20, 30 ])
            << dataColumn "b" (nums [ 28, 91, 43, 55, 81, 53, 19 ])
            << dataColumn "c" (nums [ 0, 1, 0, 1, 0, 1, 0 ])


    enc =
        encoding
            << position X [ pName "a", pQuant ]
            << position Y [ pName "b", pQuant, pImpute [ imMethod imMean ] ]
            << color [ mName "c", mNominal ]
in
toVegaLite [ data [], enc [], line [] ]

Indicate sorting is to be applied from low to high.

Indicate sorting is to be applied from high to low.

Sort by the aggregated summary of a given field using a given aggregation operation. Used by pSort, mSort, oSort and fSort. For example, to sort the categorical data field variety by the mean age of the data in each variety category:

position Y
    [ pName "variety"
    , pOrdinal
    , pSort [ soByField "age" opMean, soDescending ]
    ]

Sort by another channel. Used by pSort, mSort, oSort and fSort. For example,

position Y [ pName "age", pOrdinal, pSort [ soByChannel chX ] ]

Sort by the aggregated summaries of the given fields (referenced by a repeat iterator) using a given aggregation operation. Used by pSort, mSort, oSort and fSort.

Custom sort order listing data values explicitly. Used by pSort, mSort, oSort and fSort.

Provide an expression to an axis property function requiring a Boolean value. This can be used to provide an interactive parameterisation of an axis property when an expression is bound to an input element. Used by pAxis. For example,

ps =
    params
        << param "lbls"
            [ paValue (boo True)
            , paBind (ipCheckbox [])
            ]


enc =
    encoding
        << position X
            [ pName "x"
            , pAxis [ axBooExpr "lbls" axLabels ]
            ]

Provide an expression to an axis configuration function requiring a Boolean value. Used by coAxis, coAxisLeft, coAxisRight, coAxisTop, coAxisBottom, coAxisBand, coAxisDiscrete, coAxisPoint, coAxisQuant and coAxisTemporal.

Provide an expression to an axis property function requiring a numeric value. This can be used for interactive parameterisation when an expression is bound to an input element. Used by pAxis. For example,

ps =
    params
        << param "axo"
            [ paValue (num 0)
            , paBind (ipRange [ inMax 20 ])
            ]


enc =
    encoding
        << position X
            [ pName "x"
            , pAxis [ axNumExpr "axo" axOffset ]
            ]

Provide an expression to an axis property configuration function requiring a numeric value. Used by coAxis, coAxisLeft, coAxisRight, coAxisTop, coAxisBottom, coAxisBand, coAxisDiscrete, coAxisPoint, coAxisQuant and coAxisTemporal.

Provide an expression to an axis property function requiring a list of numbers (for dash styles). This can be used to provide an interactive parameterisation of an axis dash property when an expression is bound to an input element. Used by pAxis. For example,

ps =
    params
        << param "gridDash"
            [ paValue (nums [ 2, 2 ])
            , paBind (ipSelect [ inDataOptions [ nums [ 2, 2 ], nums [ 8, 8 ] ] ])
            ]


enc =
    encoding
        << position X [ pAxis [ axNumsExpr "gridDash" axGridDash ] ]

Provide an expression to an axis configuration function requiring a list of numbers (for dash styles). Used by coAxis, coAxisLeft, coAxisRight, coAxisTop, coAxisBottom, coAxisBand, coAxisDiscrete, coAxisPoint, coAxisQuant and coAxisTemporal.

Provide an expression to an axis property function requiring a string value. This can be used to provide an interactive parameterisation of an axis property when an expression is bound to an input element. Used by pAxis. For example,

ps =
    params
        << param "color"
            [ paValue (str "black")
            , paBind (ipColor [])
            ]


enc =
    encoding
        << position X
            [ pName "x"
            , pAxis [ axStrExpr "color" axTitleColor ]
            ]

Provide an expression to an axis configuration function requiring a string value. This can be used to provide an interactive parameterisation of an axis configuration property when an expression is bound to an input element. Used by coAxis, coAxisLeft, coAxisRight, coAxisTop, coAxisBottom, coAxisBand, coAxisDiscrete, coAxisPoint, coAxisQuant and coAxisTemporal.

ARIA properties for providing accessible SVG output associated with an axis. If an empty list is provided, ARIA tagging will be switched off. Used by pAxis.

Position of axis tick relative to a band (0 to 1). Used by pAxis.

Maximum extent in pixels that axis ticks and labels should use. Used by pAxis.

Minimum extent in pixels that axis ticks and labels should use. Used by pAxis.

Orientation of an axis relative to the plot it is describing. Used by pAxis.

Offset to displace the axis from the edge of the enclosing group or data rectangle. Used by pAxis.

Anchor position of the axis in pixels. For x-axis with top or bottom orientation, this sets the axis group x coordinate. For y-axis with left or right orientation, this sets the axis group y coordinate. Used by pAxis.

Drawing order of the axis and its associated features (grid lines, ticks etc.) relative to the other chart elements. A value greater than 0 indicates axis is drawn in front of chart marks, 0 indicates it is drawn behind them. The z-order of intersecting grid lines associated with x- and y- axes can be controlled by assigning a higher z-value to the axis to appear on top. Used by pAxis.

Make an axis property (tick, grid or label) conditional on one or more predicate expressions. The first parameter is the test to apply. The second is a pair of properties to set if the test evaluates to true or false.

The test parameter has access to the axis properties value and label corresponding to the value associated with an individual axis element and its text label. These should be used rather than the underlying data field when referencing a data value.

 pAxis
    [ axDataCondition (expr "datum.value <= 2")
        (cAxTickColor "red" "blue")
    , axDataCondition (expr "datum.label =='4.0'")
        (cAxTickWidth 5 2)
    ]

You can also apply inline aggregation before applying the test using fiOpTrans, which can be particularly useful for filtering temporal data. Used by pAxis. For example, the following will apply solid grid lines for January 1st of each year and dashes for all other dates:

pAxis
    [ axDataCondition
        (fiEqual "value" (dt [ dtMonth Jan, dtDate 1 ])
            |> fiOpTrans (mTimeUnit monthDate)
        )
        (cAxGridDash [] [ 2, 2 ])
    ]

A list of named styles to apply to an axis. Named styles can be specified via coAxisStyles. Later styles in the list will override earlier styles if there is a conflict in any of the properties specified. Used by pAxis.

While this is provided for compatibility with Vega-Lite style specification, for greater type safety in elm-vegalite, instead create functions that generate AxisProperties.

Coordinate space translation offset for axis layout. By default, axes are translated by 0.5 pixels for both the x and y coordinates in order to align stroked lines with the pixel grid. This translation can be changed, for example, to zero. Used by pAxis.

Whether or not an axis baseline (domain) should be included as part of an axis. Used by pAxis.

Dash style of axis baseline (domain). The parameter should list number of pixels in alternating dash and gap lengths. Used by pAxis.

Number of pixels before the first axis baseline (domain) line dash is drawn. Used by pAxis.

How the ends of the axis baseline (domain) are capped. Used by pAxis.

Color of axis domain line. Used by pAxis.

Opacity of axis domain line. Used by pAxis.

Width of axis domain line. Used by pAxis.

Formatting pattern for axis labels. To distinguish between formatting as numeric values and data/time values, additionally use axFormatAsNum, axFormatAsTemporal or axFormatAsCustom. Used by pAxis.

Specify multiple time formats for axis labels that might vary according to the temporal resolution. This is especially useful when used with paBindScales that will adjust the granularity of time labels dynamically. The parameter is a list of time units to customise and their respective formatting pattern. Used by pAxis. For example,

pAxis
    [ axTemporalFormats
        [ ( year, "`%Y" )
        , ( hours, "kl %-H" )
        , ( minutes, "%H:%M" )
        ]
    ]

Indicate that axis labels should be formatted as numbers. To control the precise numeric format, additionally use axFormat providing a d3 numeric format string. Used by pAxis.

Indicate that axis labels should be formatted as dates/times. To control the precise temporal format, use axFormat or axTemporalFormats providing d3 date/time format strings. Used by pAxis.

Indicate that axis labels should be formatted with a registered custom formatter with the given name. See how to register a Vega-Lite custom formatter. Used by pAxis.

Whether or not axis labels should be displayed. Used by pAxis.

Horizontal alignment of axis tick labels. Used by pAxis.

Conditional axis label alignment. The first parameter provides the alignment when a predicate is true, the second when it is false. Used by axDataCondition.

Rotation angle of axis labels (degrees from horizontal). Used by pAxis.

Vertical alignment of axis tick labels. Used by pAxis.

Conditional axis vertical label alignment. The first parameter provides the alignment when a predicate is true, the second when it is false. Used by axDataCondition.

How or if labels should be hidden if they exceed the axis range. If Nothing, no check for label size is made. A number specifies the permitted overflow in pixels. Used by pAxis.

Expression that evaluates to True, False or a number depending whether a check is to be made for an axis label size. A number specifies the permitted overflow in pixels. Used by pAxis.

Color of axis tick label. Used by pAxis.

Conditional axis label color. The first parameter provides the color when a predicate is true, the second when it is false. Used by axDataCondition.

An expression to generate axis labels. The parameter is a valid Vega expression. Can reference datum.value and datum.label for access to the underlying data values and default label text respectively. Used by pAxis. For example, to provide 4 digit years every decade and 2-digit years for all other tick marks:

pAxis
    [ axLabelExpr "if(year(datum.value) % 10 == 0"
        ++ ", utcFormat(datum.value,'%Y')"
        ++ ", utcFormat(datum.value,'%y'))"
    ]

How or if labels at beginning and end of the axis should be aligned. Specifies the distance threshold from an end-point within which labels are flush-adjusted or if Nothing, no flush-adjustment made. Used by pAxis.

Number of pixels by which to offset flush-adjusted labels. Used by pAxis.

Font name of an axis label. Used by pAxis.

Conditional axis label font. The first parameter provides the font when a predicate is true, the second when it is false. Used by axDataCondition.