Codec.CBOR.Cuddle.Huddle

Top-level Huddle type is a list of rules.

Joins two Huddle values with a left-bias. This means that this function is not symmetric and that any rules that are present in both prefer the definition from the Huddle value on the left.

Type-parametrised value type handling CBOR primitives. This is used to constrain the set of constraints which can apply to a given postlude type.

Assign a rule

Add a description to a rule or group entry, to be included as a comment.

Use a number as a key

Explicitly cast an item in an Array as an ArrayEntry.

This function is used solely to resolve type inference by explicitly identifying something as an array.

Takes a NonEmpty list of Huddle choosable terms and folds over them with (/) to create a Choice.

  choiceFromList $ NE.fromList $ [tag t (arr $ fromList [0 <+ a x]) | t <- [121 .. 127]]

Allow choices between constructions

in CDDL, / a choice between types (concretely, between Type1 values, to make a Type0). // allows choice between groups. We can illustrate the difference with the following snippet:

 foo = [ 0  1, uint  2 3, tstr ]

This construction would match either of the following:

 [0, 3] [2, "Hello World"]

In other words, the // binds less strongly than comma (',') in CDDL.

In Haskell, of course, we cannot have syntax inside an array which binds stronger than the comma. so we have to do things a little differently. The way this is handled at the moment is that / has special treatment for arrays/groups, where it will, instead of creating a type-level choice, merge the two arraysgroupsmaps into a single one containing a group choice.

If one instead wants the behaviour corresponding to the CDDL / for arrays, maps or groups, one can "seal" the array or group using the seal, sarr or smp functions. For example:

 "foo" =:= sarr [0, a VUInt] / sarr [1, a VText]

Generates a choice (at the Type0) level between two arrays, whereas

 "foo" =:= arr [0, a VUInt] / arr [1, a VUInt]

will generate a single array containing a group choice between two groups.

As such, there is no // operator in Huddle.

Seal an array or map, indicating that it will no longer absorb (//). This is needed if you wish to include an array or map inside a top-level choice.

Create and seal an array, marking it as accepting no additional choices

Create and seal a map, marking it as accepting no additional choices.

Marker that we can apply the size CtlOp to something. Not intended for export.

Declare a size constraint on an int-style type or reference. Since 0.3.4 this has worked for reference types as well as values.

Establish a closed range bound.

Tag a CBOR item with a CDDL minor type. Thus, `tag n x` is equivalent to `#6.n(x)` in CDDL.

A reference to a generic parameter inside the body of a generic rule.

Bind a single variable into a generic call

Bind two variables as a generic call

Use a custom CBORGen generator to generate the term. Will override the custom generator passed via withGenerator.

Collect all rules starting from a given point. This will also insert a single pseudo-rule as the first element which references the specified top-level rules.

Same as collectFrom, but the rules passed into this function will be put at the top of the Huddle, and all of their dependencies will be added at the end in depth-first order.

Convert from Huddle to CDDL, generating a top level root element.

Convert from Huddle to CDDL, skipping a root element.