A modern programming language that makes developers happier.

kotlinlang

is there a nicer way to write this:
```    fun convertMaybe(record: Record?): DataObject? {
        return if (record != null) converter.buildDataObject(record) else null
    }```

why does it pass record/this into the method?

It’s the same as: `record?.let { converter.buildDataObject(it) }`

the bound method reference syntax (converter::buildDataObject) and the lambda are both functions of type `(Record)-&gt;DatObject` and basically mean the same thing.

Consider an extension function:
```fun Record.toDataObject(): DataObject = converter.buildDataObject(this)

val record: Record? = TODO("either null or not null")
val dataObject: DataObject? = record?.toDataObject()```
Like `let`, allows you to use standard null safe calls to avoid ugly if/else logic, but sometimes in a more readable way. And means that the signature of your method is nice and simple - neither takes nor returns null, so doesn’t need a special name.

The idiomatic name for such an extension function might be `convertOrNull`

unless it is already obvious that a null can result

I disagree that `convertOrNull` would be an idiomatic name for the extension function. It is neither called on a null type nor does it return a null type; the null safe call means that if the record is null the extension function is not called at all.

I would use `toDataObject` as describing what the conversion results in returning; this fits with e.g. `fun &lt;T&gt; Array&lt;out T&gt;.toList(): List&lt;T&gt;`  in the stdlib.

the extension function would be lexical scoped? so is only available within the class where i define the extention fun?

To have access to your converter value, yes