---
title: "MeasurePolicy"
description: "Defines the measure and layout behavior of a [Layout]. [Layout] and [MeasurePolicy] are the way
Compose layouts (such as `Box`, `Column`, etc.) are built, and they can also be used to achieve
custom layouts.

See [Layout] samples for examples of how to use [MeasurePolicy].

Intrinsic measurement methods define the intrinsic size of the layout. These can be queried by
the layout's parent in order to obtain, in specific cases, more information about the size of the
layout in the absence of specific constraints:
- [minIntrinsicWidth] defines the minimum width this layout can take, given a specific height, such that the content of the layout will be painted correctly
- [minIntrinsicHeight] defines the minimum height this layout can take, given a specific width, such that the content of the layout will be painted correctly
- [maxIntrinsicWidth] defines the minimum width such that increasing it further will not decrease the minimum intrinsic height
- [maxIntrinsicHeight] defines the minimum height such that increasing it further will not decrease the minimum intrinsic width

Most layout scenarios do not require querying intrinsic measurements. Therefore, when writing a
custom layout, it is common to only define the actual measurement, as most of the times the
intrinsic measurements of the layout will not be queried. Moreover, intrinsic measurement methods
have default implementations that make a best effort attempt to calculate the intrinsic
measurements by reusing the [measure] method. Note this will not be correct for all layouts, but
can be a convenient approximation.

Intrinsic measurements can be useful when the layout system enforcement of no more than one
measurement per child is limiting. Layouts that use them are the `preferredWidth(IntrinsicSize)`
and `preferredHeight(IntrinsicSize)` modifiers. See their samples for when they can be useful."
type: "interface"
---

<div class='type'>Interface</div>


<a id='references'></a>

<div class='sourceset sourceset-common'>Common</div>



```kotlin
@JvmDefaultWithCompatibility
fun interface MeasurePolicy
```


Defines the measure and layout behavior of a `Layout`. `Layout` and `MeasurePolicy` are the way
Compose layouts (such as `Box`, `Column`, etc.) are built, and they can also be used to achieve
custom layouts.

See `Layout` samples for examples of how to use `MeasurePolicy`.

Intrinsic measurement methods define the intrinsic size of the layout. These can be queried by
the layout's parent in order to obtain, in specific cases, more information about the size of the
layout in the absence of specific constraints:
- `minIntrinsicWidth` defines the minimum width this layout can take, given a specific height, such that the content of the layout will be painted correctly
- `minIntrinsicHeight` defines the minimum height this layout can take, given a specific width, such that the content of the layout will be painted correctly
- `maxIntrinsicWidth` defines the minimum width such that increasing it further will not decrease the minimum intrinsic height
- `maxIntrinsicHeight` defines the minimum height such that increasing it further will not decrease the minimum intrinsic width

Most layout scenarios do not require querying intrinsic measurements. Therefore, when writing a
custom layout, it is common to only define the actual measurement, as most of the times the
intrinsic measurements of the layout will not be queried. Moreover, intrinsic measurement methods
have default implementations that make a best effort attempt to calculate the intrinsic
measurements by reusing the `measure` method. Note this will not be correct for all layouts, but
can be a convenient approximation.

Intrinsic measurements can be useful when the layout system enforcement of no more than one
measurement per child is limiting. Layouts that use them are the `preferredWidth(IntrinsicSize)`
and `preferredHeight(IntrinsicSize)` modifiers. See their samples for when they can be useful.


## Functions

```kotlin
fun MeasureScope.measure(measurables: List<Measurable>, constraints: Constraints): MeasureResult
```


The function that defines the measurement and layout. Each `Measurable` in the `measurables`
list corresponds to a layout child of the layout, and children can be measured using the
`Measurable.measure` method. This method takes the `Constraints` which the child should
respect; different children can be measured with different constraints.

Measuring a child returns a `Placeable`, which reveals the size chosen by the child as a
result of its own measurement. According to the children sizes, the parent defines the
position of the children, by `placing` the `Placeable`s in
the `MeasureResult.placeChildren` of the returned `MeasureResult`. Therefore the parent needs
to measure its children with appropriate `Constraints`, such that whatever valid sizes
children choose, they can be laid out correctly according to the parent's layout algorithm.
This is because there is no measurement negotiation between the parent and children: once a
child chooses its size, the parent needs to handle it correctly.

Note that a child is allowed to choose a size that does not satisfy its constraints. However,
when this happens, the placeable's `width` and `height`
will not represent the real size of the child, but rather the size coerced in the child's
constraints. Therefore, it is common for parents to assume in their layout algorithm that its
children will always respect the constraints. When this does not happen in reality, the
position assigned to the child will be automatically offset to be centered on the space
assigned by the parent under the assumption that constraints were respected. Rarely, when a
parent really needs to know the true size of the child, they can read this from the
placeable's `Placeable.measuredWidth` and `Placeable.measuredHeight`.

`MeasureResult` objects are usually created using the `MeasureScope.layout` factory, which
takes the calculated size of this layout, its alignment lines, and a block defining the
positioning of the children layouts.


```kotlin
fun IntrinsicMeasureScope.minIntrinsicWidth(
        measurables: List<IntrinsicMeasurable>,
        height: Int,
    ): Int
```


The function used to calculate `IntrinsicMeasurable.minIntrinsicWidth`. It represents the
minimum width this layout can take, given a specific height, such that the content of the
layout can be painted correctly. There should be no side-effect from implementers of
`minIntrinsicWidth`.


```kotlin
fun IntrinsicMeasureScope.minIntrinsicHeight(
        measurables: List<IntrinsicMeasurable>,
        width: Int,
    ): Int
```


The function used to calculate `IntrinsicMeasurable.minIntrinsicHeight`. It represents the
minimum height this layout can take, given a specific width, such that the content of the
layout will be painted correctly. There should be no side-effect from implementers of
`minIntrinsicHeight`.


```kotlin
fun IntrinsicMeasureScope.maxIntrinsicWidth(
        measurables: List<IntrinsicMeasurable>,
        height: Int,
    ): Int
```


The function used to calculate `IntrinsicMeasurable.maxIntrinsicWidth`. It represents the
minimum width such that increasing it further will not decrease the minimum intrinsic height.
There should be no side-effects from implementers of `maxIntrinsicWidth`.


```kotlin
fun IntrinsicMeasureScope.maxIntrinsicHeight(
        measurables: List<IntrinsicMeasurable>,
        width: Int,
    ): Int
```


The function used to calculate `IntrinsicMeasurable.maxIntrinsicHeight`. It represents the
minimum height such that increasing it further will not decrease the minimum intrinsic width.
There should be no side-effects from implementers of `maxIntrinsicHeight`.