The main datatype in the high level bindings is a Layout. Layouts are used to store a tree of nodes that represent the different components of a layout. Layouts can be composed by adding one as a sub-tree to another. The parent-child relationship dictates different parameters such as width, height and position. This type is opaque to the user in order to facilitate updates to the library. For more control, use the C-level bindings in Yoga.Bindings.

Children are a list of layouts annotated with a style for how they should be laid out in their container.

Collects a list of layouts and orients them from start to end depending on the orientation of the parent (LTR vs RTL).

Collects a list of layouts and orients them from end to start depending on the orientation of the parent (LTR vs RTL).

Collects a list of children and centers them within the parent.

Collects a list of children that span the parent such that the space between each child is equal

Collects a list of children that span the parent such that the space to the left and right of each child is equal.

Permits children to wrap to a new line if they exceed the bounds of their parent

Generates a layout from a group of children and a payload such that the children are laid out horizontally. The orientation (RTL vs LTR) is inherited from the parent

Generates a layout from a group of children and a payload such that the children are laid out vertically. The orientation (top to bottom vs bottom to top) is inherited from the parent.

Generates a layout from a group of children and a payload such that the children are laid out horizontally from left to right.

Generates a layout from a group of children and a payload such that the children are laid out horizontally from right to left.

Generates a layout from a group of children and a payload such that the children are laid out vertically from top to bottom.

Generates a layout from a group of children and a payload such that the children are laid out vertically from bottom to top.

A Size is used to set properties about given layouts. In general, the width and height of a node along with its position are laid out by Yoga's internal layout engine. However, the user may decide to set limits on how much internal nodes can shrink or grow. This datatype controls those properties

Creates a layout that may shrink up to the given size. The weight parameter is used to determine how much this layout will shrink in relation to any siblings.

Creates a layout that may grow up to the given size. The weight parameter is used to determine how much this layout will grow in relation to any siblings.

Creates a layout with the exact width and height for the given payload.

Edges are used to describe the direction from which we want to alter an attribute of a node. They are currently only being used with withMargin and withPadding.

Allows a container to stretch to fit its parent

Transforms a layout generator to one which applies the given margin using continuation passing style. In this way we maintain the const-ness of layout nodes. E.g.:

let lyt = ($ payload) (withMargin Edge'Left 10.0 $ exact 200.0 300.0)

Transforms a layout generator to one which applies the given padding using continuation passing style. In this way we maintain the const-ness of layout nodes. E.g.:

let lyt = ($ payload) (withPadding Edge'Left 10.0 $ exact 200.0 300.0)

Stores the calculated layout information for a given node. During rendering, the rendering function will take the payload and layout info to facilitate the renderer to do whatever it needs to with the given layout calculations.

A RenderFn takes a top-left position and a width and height of a node with the given payload. The function is expected to perform some monadic action in the Monad m, and return a new payload of type b. This function is called on each node in order during a call to render.

Renders a layout with the user-supplied function. The renderer traverses the tree from root node to children and transforms each payload using the user-supplied function.

Renders a layout with the user-supplied function. For each return value of type '(b, c)', we append the first result to the output of the previous node. The second result is stored as the new payload for the given node. Hence, the resulting monadic action produces a mappend-ed set of bs and a new layout with payloads of type c.