(value as? String)?.let { opr ->
            evalUnaryOp(
                function.name.asString(),
                kind.toCompileTimeType(),
                opr
            )?.let {
                return it.toConstantValueKind().toLiteralExpression(source, it)
            }
        }
        return kind.convertToNumber(value)?.let { opr ->
            evalUnaryOp(

                        psiElements.firstIsInstanceOrNull<PsiField>()?.let {
                            bindings.put(FIELD_FOR_PROPERTY, fir, Type.getType(getBinaryPresentationWithCorrection(it.type)) to it.name)
                        }
                    }
                    fir.getter?.let { getter ->
                        methods.singleOrNull { it.returnType != PsiType.VOID }?.let {

  return request.build()
}

private fun Main.mediaType(): MediaType? {
  val mimeType =
    headers?.let {
      for (header in it) {
        val parts = header.split(':', limit = 2)
        if ("Content-Type".equals(parts[0], ignoreCase = true)) {
          return@let parts[1].trim()
        }
      }
      return@let null
    } ?: "application/x-www-form-urlencoded"

  return mimeType.toMediaTypeOrNull()
}

            is KtBinaryExpression -> {
                handleAsCompoundAssignment(this, unwrappedPsi)?.let { return@with it }
                handleAsFunctionCall(this, unwrappedPsi)
            }
            is KtUnaryExpression -> {
                handleAsIncOrDecOperator(this, unwrappedPsi)?.let { return@with it }
                handleAsFunctionCall(this, unwrappedPsi)
            }

 */
function summaryTable(statistics, title) {
    let preppedStatistics = statistics.filter(s => s.files.length > 0)
        .sort(s => -(s.additions + s.deletions));

    let totalAdditions = Object.values(preppedStatistics).reduce((acc, summary) => acc + summary.additions, 0);
    let totalDeletions = Object.values(preppedStatistics).reduce((acc, summary) => acc + summary.deletions, 0);

 */
function computeStatistics(groupedFiles, fileMetadatas) {
    let totalAdditions = 0;
    let totalDeletions = 0
    let totalChangedFiles = 0;

    let summaries = [...groupedFiles.values()];
    Object.values(summaries).forEach(summary => {
        summary.additions = 0;
        summary.deletions = 0;

        summary.files.forEach(file => {
            let fileMetadata = metadataFor(fileMetadatas, file);

## Use Case

Let's start with an example **use case** and then see how to solve it with this.

Let's imagine that you have some **machine learning models** that you want to use to handle requests. 🤖

The same models are shared among requests, so, it's not one model per request, or one per user or something similar.

        // psiBased
        (symbol.psi?.containingFile as? KtFile)?.let { ktFile ->
            with(analysisSession) {
                return ktFile.getFileSymbol()
            }
        }
        // descriptorBased
        val descriptor = symbol.containingSymbolOrSelf.getDescriptor()
        val ktFile = descriptor?.let(DescriptorToSourceUtils::getContainingFile) ?: return null
        with(analysisSession) {

            substitutor.substitute(returnType),
            receiverType?.let { substitutor.substitute(it) },
            valueParameters.map { valueParameter ->
                KtFe10VariableLikeSignature<KtValueParameterSymbol>(
                    valueParameter.symbol,
                    substitutor.substitute(valueParameter.returnType),
                    valueParameter.receiverType?.let { substitutor.substitute(it) }
                )
            }

Вот некоторые варианты, которые вы можете использовать в качестве такого прокси-сервера:

* Traefik (может обновлять сертификаты)
* Caddy (может обновлять сертификаты)
* Nginx
* HAProxy

## Let's Encrypt (центр сертификации)

До появления Let's Encrypt **сертификаты HTTPS** приходилось покупать у третьих сторон.

Процесс получения такого сертификата был трудоёмким, требовал предоставления подтверждающих документов и сертификаты стоили дорого.