Interface StringNamespace

String functions for Lazy dataframes

interface StringNamespace {
    concat(delimiter: string, ignoreNulls?: boolean): pl.Expr;
    contains(
        pat: string | RegExp | pl.Expr,
        literal?: boolean,
        strict?: boolean,
    ): pl.Expr;
    decode(encoding: "base64" | "hex", strict?: boolean): pl.Expr;
    decode(options: { encoding: "base64" | "hex"; strict?: boolean }): pl.Expr;
    encode(encoding: "base64" | "hex"): pl.Expr;
    endsWith(suffix: string | pl.Expr): pl.Expr;
    extract(pattern: string | RegExp | pl.Expr, groupIndex: number): pl.Expr;
    jsonDecode(dtype?: DataType, inferSchemaLength?: number): pl.Expr;
    jsonPathMatch(pat: string): pl.Expr;
    lengths(): pl.Expr;
    lstrip(): pl.Expr;
    padEnd(length: number, fillChar: string): pl.Expr;
    padStart(length: number, fillChar: string): pl.Expr;
    replace(
        pattern: string | RegExp | pl.Expr,
        value: string | pl.Expr,
        literal?: boolean,
        n?: number,
    ): pl.Expr;
    replaceAll(
        pattern: string | RegExp | pl.Expr,
        value: string | pl.Expr,
        literal?: boolean,
    ): pl.Expr;
    rstrip(): pl.Expr;
    slice(start: number | pl.Expr, length?: number | pl.Expr): pl.Expr;
    split(by: string, options?: boolean | { inclusive?: boolean }): pl.Expr;
    startsWith(prefix: string | pl.Expr): pl.Expr;
    strip(): pl.Expr;
    stripChars(prefix: string | pl.Expr): pl.Expr;
    stripCharsEnd(prefix: string | pl.Expr): pl.Expr;
    stripCharsStart(prefix: string | pl.Expr): pl.Expr;
    strptime(datatype: Date, fmt?: string): pl.Expr;
    strptime(datatype: Datetime, fmt?: string): pl.Expr;
    strptime(
        datatype: (
            timeUnit?: TimeUnit | "ms" | "ns" | "us",
            timeZone?: undefined | null | string,
        ) => Datetime,
        fmt?: string,
    ): pl.Expr;
    toLowerCase(): pl.Expr;
    toUpperCase(): pl.Expr;
    zFill(length: number | pl.Expr): pl.Expr;
}

Hierarchy

StringFunctions<pl.Expr>
- StringNamespace

Methods

concat

concat(delimiter: string, ignoreNulls?: boolean): pl.Expr

Vertically concat the values in the Expression to a single string value.

Parameters

delimiter: string
OptionalignoreNulls: boolean

Returns pl.Expr

Example

>>> df = pl.DataFrame({"foo": [1, null, 2]})
>>> df = df.select(pl.col("foo").str.concat("-"))
>>> df
shape: (1, 1)
┌──────────┐
│ foo      │
│ ---      │
│ str      │
╞══════════╡
│ 1-null-2 │
└──────────┘

contains

contains(
    pat: string | RegExp | pl.Expr,
    literal?: boolean,
    strict?: boolean,
): pl.Expr

Check if strings in Expression contain a substring that matches a pattern.

Parameters

pat: string | RegExp | pl.Expr
A valid regular expression pattern, compatible with the regex crate @param literal Treat pattern` as a literal string, not as a regular expression.
Optionalliteral: boolean
Optionalstrict: boolean
Raise an error if the underlying pattern is not a valid regex, otherwise mask out with a null value.

Returns pl.Expr

Boolean mask

Example

const df = pl.DataFrame({"txt": ["Crab", "cat and dog", "rab$bit", null]})
df.select(
...     pl.col("txt"),
...     pl.col("txt").str.contains("cat|bit").alias("regex"),
...     pl.col("txt").str.contains("rab$", true).alias("literal"),
... )
shape: (4, 3)
┌─────────────┬───────┬─────────┐
│ txt         ┆ regex ┆ literal │
│ ---         ┆ ---   ┆ ---     │
│ str         ┆ bool  ┆ bool    │
╞═════════════╪═══════╪═════════╡
│ Crab        ┆ false ┆ false   │
│ cat and dog ┆ true  ┆ false   │
│ rab$bit     ┆ true  ┆ true    │
│ null        ┆ null  ┆ null    │
└─────────────┴───────┴─────────┘

decode

decode(encoding: "base64" | "hex", strict?: boolean): pl.Expr

Decodes a value in Expression using the provided encoding

Parameters

encoding: "base64" | "hex"
hex | base64

Optionalstrict: boolean

how to handle invalid inputs

- true: method will throw error if unable to decode a value
- false: unhandled values will be replaced with `null`

Returns pl.Expr

Example

>>> df = pl.DataFrame({"strings": ["666f6f", "626172", null]})
>>> df.select(col("strings").str.decode("hex"))
shape: (3, 1)
┌─────────┐
│ strings │
│ ---     │
│ str     │
╞═════════╡
│ foo     │
├╌╌╌╌╌╌╌╌╌┤
│ bar     │
├╌╌╌╌╌╌╌╌╌┤
│ null    │
└─────────┘

decode(options: { encoding: "base64" | "hex"; strict?: boolean }): pl.Expr

Decodes a value using the provided encoding

Parameters

options: { encoding: "base64" | "hex"; strict?: boolean }

Returns pl.Expr

Example

> df = pl.DataFrame({"strings": ["666f6f", "626172", null]})
> df.select(col("strings").str.decode("hex"))
shape: (3, 1)
┌─────────┐
│ strings │
│ ---     │
│ str     │
╞═════════╡
│ foo     │
├╌╌╌╌╌╌╌╌╌┤
│ bar     │
├╌╌╌╌╌╌╌╌╌┤
│ null    │
└─────────┘

encode

encode(encoding: "base64" | "hex"): pl.Expr

Encodes a value in Expression using the provided encoding

Parameters

encoding: "base64" | "hex"
hex | base64

Returns pl.Expr

Example

>>> df = pl.DataFrame({"strings", ["foo", "bar", null]})
>>> df.select(col("strings").str.encode("hex"))
shape: (3, 1)
┌─────────┐
│ strings │
│ ---     │
│ str     │
╞═════════╡
│ 666f6f  │
├╌╌╌╌╌╌╌╌╌┤
│ 626172  │
├╌╌╌╌╌╌╌╌╌┤
│ null    │
└─────────┘

endsWith

endsWith(suffix: string | pl.Expr): pl.Expr

Check if string values in Expression ends with a substring.

Parameters

suffix: string | pl.Expr
Suffix substring or expression

Returns pl.Expr

Example

>>> df = pl.DataFrame({"fruits": ["apple", "mango", None]})
>>> df.withColumns(
...     pl.col("fruits").str.endsWith("go").alias("has_suffix"),
... )
shape: (3, 2)
┌────────┬────────────┐
│ fruits ┆ has_suffix │
│ ---    ┆ ---        │
│ str    ┆ bool       │
╞════════╪════════════╡
│ apple  ┆ false      │
│ mango  ┆ true       │
│ null   ┆ null       │
└────────┴────────────┘

>>> df = pl.DataFrame(
...     {"fruits": ["apple", "mango", "banana"], "suffix": ["le", "go", "nu"]}
... )
>>> df.withColumns(
...     pl.col("fruits").str.endsWith(pl.col("suffix")).alias("has_suffix"),
... )
shape: (3, 3)
┌────────┬────────┬────────────┐
│ fruits ┆ suffix ┆ has_suffix │
│ ---    ┆ ---    ┆ ---        │
│ str    ┆ str    ┆ bool       │
╞════════╪════════╪════════════╡
│ apple  ┆ le     ┆ true       │
│ mango  ┆ go     ┆ true       │
│ banana ┆ nu     ┆ false      │
└────────┴────────┴────────────┘

   Using `ends_with` as a filter condition:

>>> df.filter(pl.col("fruits").str.endsWith("go"))
shape: (1, 2)
┌────────┬────────┐
│ fruits ┆ suffix │
│ ---    ┆ ---    │
│ str    ┆ str    │
╞════════╪════════╡
│ mango  ┆ go     │
└────────┴────────┘

extract

extract(pattern: string | RegExp | pl.Expr, groupIndex: number): pl.Expr

Extract the target capture group from provided patterns.

Parameters

pattern: string | RegExp | pl.Expr
A valid regex pattern
groupIndex: number
Index of the targeted capture group. Group 0 mean the whole pattern, first group begin at index 1 Default to the first capture group

Returns pl.Expr

Utf8 array. Contain null if original value is null or regex capture nothing.

Example

> df = pl.DataFrame({
...   'a': [
...       'http://vote.com/ballon_dor?candidate=messi&ref=polars',
...       'http://vote.com/ballon_dor?candidat=jorginho&ref=polars',
...       'http://vote.com/ballon_dor?candidate=ronaldo&ref=polars'
...   ]})
> df.select(pl.col('a').str.extract(/candidate=(\w+)/, 1))
shape: (3, 1)
┌─────────┐
│ a       │
│ ---     │
│ str     │
╞═════════╡
│ messi   │
├╌╌╌╌╌╌╌╌╌┤
│ null    │
├╌╌╌╌╌╌╌╌╌┤
│ ronaldo │
└─────────┘

jsonDecode

jsonDecode(dtype?: DataType, inferSchemaLength?: number): pl.Expr

Parse string values in Expression as JSON. Throw errors if encounter invalid JSON strings.

Parameters

Optionaldtype: DataType
The dtype to cast the extracted value to. If None, the dtype will be inferred from the JSON value.
OptionalinferSchemaLength: number
The maximum number of rows to scan for schema inference.

Returns pl.Expr

DF with struct

Example

>>> df = pl.DataFrame( {json: ['{"a":1, "b": true}', null, '{"a":2, "b": false}']} )
>>> df.select(pl.col("json").str.jsonDecode())
shape: (3, 1)
┌─────────────┐
│ json        │
│ ---         │
│ struct[2]   │
╞═════════════╡
│ {1,true}    │
│ {null,null} │
│ {2,false}   │
└─────────────┘
See Also
----------
jsonPathMatch : Extract the first match of json string with provided JSONPath expression

jsonPathMatch

jsonPathMatch(pat: string): pl.Expr

Extract the first match of json string in Expression with provided JSONPath expression. Throw errors if encounter invalid json strings. All return value will be casted to Utf8 regardless of the original value.

Parameters

pat: string
A valid JSON path query string

Returns pl.Expr

Utf8 array. Contain null if original value is null or the jsonPath return nothing.

See

https://goessner.net/articles/JsonPath/

Example

>>> df = pl.DataFrame({
...   'json_val': [
...     '{"a":"1"}',
...     null,
...     '{"a":2}',
...     '{"a":2.1}',
...     '{"a":true}'
...   ]
... })
>>> df.select(pl.col('json_val').str.jsonPathMatch('$.a')
shape: (5, 1)
┌──────────┐
│ json_val │
│ ---      │
│ str      │
╞══════════╡
│ 1        │
│ null     │
│ 2        │
│ 2.1      │
│ true     │
└──────────┘

lengths

lengths(): pl.Expr

Get number of chars of the string values in Expression.

df = pl.DataFrame({"a": ["Café", "345", "東京", null]})
df.withColumns(
   pl.col("a").str.lengths().alias("n_chars"),
)
shape: (4, 3)
┌──────┬─────────┬─────────┐
│ a    ┆ n_chars ┆ n_bytes │
│ ---  ┆ ---     ┆ ---     │
│ str  ┆ u32     ┆ u32     │
╞══════╪═════════╪═════════╡
│ Café ┆ 4       ┆ 5       │
│ 345  ┆ 3       ┆ 3       │
│ 東京 ┆ 2       ┆ 6       │
│ null ┆ null    ┆ null    │
└──────┴─────────┴─────────┘

Returns pl.Expr

lstrip

lstrip(): pl.Expr
Remove leading whitespace of the string values in Expression.

Returns pl.Expr
Overrides StringFunctions.lstrip
- Defined in polars/lazy/expr/string.ts:271

padEnd

padEnd(length: number, fillChar: string): pl.Expr

Add a trailing fillChar to a string until string length is reached. If string is longer or equal to given length no modifications will be done

Parameters

length: number
of the final string
fillChar: string
that will fill the string. Note: If a string longer than 1 character is provided only the first character will be used

Returns pl.Expr

Example

> df = pl.DataFrame({
...   'foo': [
...       "a",
...       "b",
...       "LONG_WORD",
...       "cow"
...   ]})
> df.select(pl.col('foo').str.padEnd("_", 3)
shape: (4, 1)
┌──────────┐
│ a        │
│ -------- │
│ str      │
╞══════════╡
│ a__      │
├╌╌╌╌╌╌╌╌╌╌┤
│ b__      │
├╌╌╌╌╌╌╌╌╌╌┤
│ LONG_WORD│
├╌╌╌╌╌╌╌╌╌╌┤
│ cow      │
└──────────┘

padStart

padStart(length: number, fillChar: string): pl.Expr

Add a leading fillChar to a string in Expression until string length is reached. If string is longer or equal to given length no modifications will be done

Parameters

length: number
of the final string
fillChar: string
that will fill the string. If a string longer than 1 character is provided only the first character will be used

Returns pl.Expr

Example

> df = pl.DataFrame({
...   'foo': [
...       "a",
...       "b",
...       "LONG_WORD",
...       "cow"
...   ]})
> df.select(pl.col('foo').str.padStart("_", 3)
shape: (4, 1)
┌──────────┐
│ a        │
│ -------- │
│ str      │
╞══════════╡
│ __a      │
├╌╌╌╌╌╌╌╌╌╌┤
│ __b      │
├╌╌╌╌╌╌╌╌╌╌┤
│ LONG_WORD│
├╌╌╌╌╌╌╌╌╌╌┤
│ cow      │
└──────────┘

replace

replace(
    pattern: string | RegExp | pl.Expr,
    value: string | pl.Expr,
    literal?: boolean,
    n?: number,
): pl.Expr

Replace first match with a string value in Expression.

Parameters

pattern: string | RegExp | pl.Expr
A valid regex pattern, string or expression
value: string | pl.Expr
Substring or expression to replace.
Optionalliteral: boolean
Treat pattern as a literal string. Note: pattern as expression is not yet supported by polars
Optionaln: number

Returns pl.Expr

Example

df = pl.DataFrame({"cost": ["#12.34", "#56.78"], "text": ["123abc", "abc456"]})
df = df.withColumns(
    pl.col("cost").str.replace(/#(\d+)/, "$$$1"),
    pl.col("text").str.replace("ab", "-")
    pl.col("text").str.replace("abc", pl.col("cost")).alias("expr")
);
shape: (2, 2)
┌────────┬───────┬───────────┐
│ cost   ┆ text  │ expr      │
│ ---    ┆ ---   │ ---       │
│ str    ┆ str   │ str       │
╞════════╪═══════╪═══════════╡
│ $12.34 ┆ 123-c │ 123#12.34 │
│ $56.78 ┆ -c456 │ #56.78456 │
└────────┴───────┴───────────┘

replaceAll

replaceAll(
    pattern: string | RegExp | pl.Expr,
    value: string | pl.Expr,
    literal?: boolean,
): pl.Expr

Replace all regex matches with a string value in Expression.

Parameters

pattern: string | RegExp | pl.Expr
A valid regex pattern, string or expression
value: string | pl.Expr
Substring or expression to replace.
Optionalliteral: boolean
Treat pattern as a literal string. Note: pattern as expression is not yet supported by polars

Returns pl.Expr

Example

df = df = pl.DataFrame({"weather": ["Rainy", "Sunny", "Cloudy", "Snowy"], "text": ["abcabc", "123a123", null, null]})
df = df.withColumns(
    pl.col("weather").str.replaceAll(/foggy|rainy/i, "Sunny"),
    pl.col("text").str.replaceAll("a", "-")
)
shape: (4, 2)
┌─────────┬─────────┐
│ weather ┆ text    │
│ ---     ┆ ---     │
│ str     ┆ str     │
╞═════════╪═════════╡
│ Sunny   ┆ -bc-bc  │
│ Sunny   ┆ 123-123 │
│ Cloudy  ┆ null    │
│ Snowy   ┆ null    │
└─────────┴─────────┘

rstrip

rstrip(): pl.Expr
Remove trailing whitespace.

Returns pl.Expr
Overrides StringFunctions.rstrip
- Defined in polars/lazy/expr/string.ts:337

slice

slice(start: number | pl.Expr, length?: number | pl.Expr): pl.Expr
Create subslices of the string values of a Utf8 Series.
Parameters
- start: number | pl.Expr
  Start of the slice (negative indexing may be used).
- Optionallength: number | pl.Expr
  Optional length of the slice.
Returns pl.Expr
Overrides StringFunctions.slice
- Defined in polars/lazy/expr/string.ts:441

split

split(by: string, options?: boolean | { inclusive?: boolean }): pl.Expr
Split a string into substrings using the specified separator and return them as a Series.
Parameters
- by: string
  — A string that identifies character or characters to use in separating the string.
- Optionaloptions: boolean | { inclusive?: boolean }
  - boolean
  - { inclusive?: boolean }
    Optionalinclusive?: boolean
    Include the split character/string in the results
Returns pl.Expr
Overrides StringFunctions.split
- Defined in polars/lazy/expr/string.ts:447

startsWith

startsWith(prefix: string | pl.Expr): pl.Expr

Check if string values start with a substring.

Parameters

prefix: string | pl.Expr
Prefix substring or expression

Returns pl.Expr

Example

>>> df = pl.DataFrame({"fruits": ["apple", "mango", None]})
>>> df.withColumns(
...     pl.col("fruits").str.startsWith("app").alias("has_prefix"),
... )
shape: (3, 2)
┌────────┬────────────┐
│ fruits ┆ has_prefix │
│ ---    ┆ ---        │
│ str    ┆ bool       │
╞════════╪════════════╡
│ apple  ┆ true       │
│ mango  ┆ false      │
│ null   ┆ null       │
└────────┴────────────┘

>>> df = pl.DataFrame(
...     {"fruits": ["apple", "mango", "banana"], "prefix": ["app", "na", "ba"]}
... )
>>> df.withColumns(
...     pl.col("fruits").str.startsWith(pl.col("prefix")).alias("has_prefix"),
... )
shape: (3, 3)
┌────────┬────────┬────────────┐
│ fruits ┆ prefix ┆ has_prefix │
│ ---    ┆ ---    ┆ ---        │
│ str    ┆ str    ┆ bool       │
╞════════╪════════╪════════════╡
│ apple  ┆ app    ┆ true       │
│ mango  ┆ na     ┆ false      │
│ banana ┆ ba     ┆ true       │
└────────┴────────┴────────────┘

   Using `starts_with` as a filter condition:

>>> df.filter(pl.col("fruits").str.startsWith("app"))
shape: (1, 2)
┌────────┬────────┐
│ fruits ┆ prefix │
│ ---    ┆ ---    │
│ str    ┆ str    │
╞════════╪════════╡
│ apple  ┆ app    │
└────────┴────────┘

strip

strip(): pl.Expr
Remove leading and trailing whitespace.

Returns pl.Expr
Overrides StringFunctions.strip
- Defined in polars/lazy/expr/string.ts:499

stripChars

stripChars(prefix: string | pl.Expr): pl.Expr

Remove leading and trailing whitespace.

Parameters

prefix: string | pl.Expr
Prefix substring or expression (null means whitespace)

Returns pl.Expr

Example

>>> df = pl.DataFrame({
        os: [
          "#Kali-Linux###",
          "$$$Debian-Linux$",
          null,
          "Ubuntu-Linux    ",
          "  Mac-Sierra",
        ],
        chars: ["#", "$", " ", " ", null],
      })
>>> df.select(col("os").str.stripChars(col("chars")).as("os"))
shape: (5, 1)
     ┌──────────────┐
     │ os           │
     │ ---          │
     │ str          │
     ╞══════════════╡
     │ Kali-Linux   │
     │ Debian-Linux │
     │ null         │
     │ Ubuntu-Linux │
     │ Mac-Sierra   │
     └──────────────┘

stripCharsEnd

stripCharsEnd(prefix: string | pl.Expr): pl.Expr
Remove trailing characters.
Parameters
- prefix: string | pl.Expr
  Prefix substring or expression (null means whitespace)
Returns pl.Expr
See
stripChars
- Defined in polars/lazy/expr/string.ts:543

stripCharsStart

stripCharsStart(prefix: string | pl.Expr): pl.Expr
Remove leading characters.
Parameters
- prefix: string | pl.Expr
  Prefix substring or expression (null means whitespace)
Returns pl.Expr
See
stripChars
- Defined in polars/lazy/expr/string.ts:548

strptime

strptime(datatype: Date, fmt?: string): pl.Expr
Parse a Series of dtype Utf8 to a Date/Datetime Series.
Parameters
- datatype: Date
  Date or Datetime.
- Optionalfmt: string
  formatting syntax. Read more
Returns pl.Expr
Overrides StringFunctions.strptime
- Defined in polars/lazy/expr/string.ts:505
strptime(datatype: Datetime, fmt?: string): pl.Expr
Parse a Series of dtype Utf8 to a Date/Datetime Series.
Parameters
- datatype: Datetime
  Date or Datetime.
- Optionalfmt: string
  formatting syntax. Read more
Returns pl.Expr
Overrides StringFunctions.strptime
- Defined in polars/lazy/expr/string.ts:506
strptime(
    datatype: (
        timeUnit?: TimeUnit | "ms" | "ns" | "us",
        timeZone?: undefined | null | string,
    ) => Datetime,
    fmt?: string,
): pl.Expr
Parse a Series of dtype Utf8 to a Date/Datetime Series.
Parameters
- datatype: (
  timeUnit?: TimeUnit | "ms" | "ns" | "us",
  timeZone?: undefined | null | string,
  ) => Datetime
  Date or Datetime.
  - (
    timeUnit?: TimeUnit | "ms" | "ns" | "us",
    timeZone?: undefined | null | string,
    ): Datetime
    Calendar date and time type
    
    Parameters
    OptionaltimeUnit: TimeUnit | "ms" | "ns" | "us"
    any of 'ms' | 'ns' | 'us'
    
    timeZone: undefined | null | string = null
    timezone string as defined by Intl.DateTimeFormat America/New_York for example.
    
    Returns Datetime
- Optionalfmt: string
  formatting syntax. Read more
Returns pl.Expr
Overrides StringFunctions.strptime
- Defined in polars/lazy/expr/string.ts:507

toLowerCase

toLowerCase(): pl.Expr
Modify the string in Expression to their lowercase equivalent.

Returns pl.Expr
Overrides StringFunctions.toLowerCase
- Defined in polars/lazy/expr/string.ts:333

toUpperCase

toUpperCase(): pl.Expr
Modify the string in Expression to their uppercase equivalent.

Returns pl.Expr
Overrides StringFunctions.toUpperCase
- Defined in polars/lazy/expr/string.ts:335

zFill

zFill(length: number | pl.Expr): pl.Expr

Add leading "0" to a string until string length is reached. If string is longer or equal to given length no modifications will be done

Parameters

length: number | pl.Expr
of the final string

Returns pl.Expr

See

padStart

Example

> df = pl.DataFrame({
...   'foo': [
...       "a",
...       "b",
...       "LONG_WORD",
...       "cow"
...   ]})
> df.select(pl.col('foo').str.justify(3)
shape: (4, 1)
┌──────────┐
│ a        │
│ -------- │
│ str      │
╞══════════╡
│ 00a      │
├╌╌╌╌╌╌╌╌╌╌┤
│ 00b      │
├╌╌╌╌╌╌╌╌╌╌┤
│ LONG_WORD│
├╌╌╌╌╌╌╌╌╌╌┤
│ cow      │
└──────────┘

Interface StringNamespace

Hierarchy

Index

Methods

Methods

concat

Parameters

Returns pl.Expr

Example

contains

Parameters

Returns pl.Expr

Example

decode

Parameters

Returns pl.Expr

Example

Parameters

Returns pl.Expr

Example

encode

Parameters

Returns pl.Expr

Example

endsWith

Parameters

Returns pl.Expr

Example

extract

Parameters

Returns pl.Expr

Example

jsonDecode

Parameters

Returns pl.Expr

Example

jsonPathMatch

Parameters

Returns pl.Expr

See

Example

lengths

Returns pl.Expr

lstrip

Returns pl.Expr

padEnd

Parameters

Returns pl.Expr

Example

padStart

Parameters

Returns pl.Expr

Example

replace

Parameters

Returns pl.Expr

Example

replaceAll

Parameters

Returns pl.Expr

Example

rstrip

Returns pl.Expr

slice

Parameters

Returns pl.Expr

split

Parameters

Optionalinclusive?: boolean

Returns pl.Expr

startsWith

Parameters

Returns pl.Expr

Example

strip

Returns pl.Expr

stripChars

Parameters

Returns pl.Expr

Example

`Optional`inclusive?: boolean