concatenated := []byte("<ParentID>/<DaughterID>")
result := uuid.NewSHA1(uuid.Nil, concatenated)

Method.POST / "users" -> handler { (req: Request) =>
    for {
        u <- req.body.to[User].orElseFail(Response.badRequest)
        r <- UserRepo
            .register(u)
            .mapBoth(
                _ => Response.internalServerError(s"Failed to register the user: $u"),
                user => Response(body = Body.from(user))
            )
    } yield r
}

post<UsersResource> {
    either {
        val user = receiveCatching<User>().bind().user
        UserRepo
            .register(user)
            .bind().user
    }
    .respond(HttpStatusCode.Created)
}

test("Can register user") {
    for {
        client <- ZIO.service[Client]
        _      <- TestServer.addRoutes(UserRoutes())
        port   <- ZIO.serviceWith[Server](_.port)
        url    = URL.root.port(port)
        createResponse <- client(
            Request.post(url / "users", Body.from[User](testUser))
        )
        result <- getResponse.body.to[User]
    } yield assertTrue(result == testUser)
}.provideSome[Client with Driver with UserRepo](
    TestServer.layer,
    Scope.default,
    InmemoryUserRepo.layer
)

"Can register user" {
    withServer {
        val response =
            post(UsersResource()) {
                contentType(ContentType.Application.Json)
                setBody(testUser))
            }

        with(response.body<User>().user) {
            assert(username == testUser.Name)
            assert(email == testUser.Email)
        }
    }
}

let v = vec![1, 2, 3];

func unitInFact() bool {
    for {} // Бесконечный цикл
}

if sig.results.Len() > 0 && !check.isTerminating(body, "") {
    check.error(atPos(body.Rbrace), MissingReturn, "missing return")
}

case *ast.ForStmt:
    if s.Cond == nil && !hasBreak(s.Body, label, true) {
        return true
    }
}

Если сигнатура функции объявляет возвращаемые параметры, список операторов в теле функции должен заканчиваться terminating statements

Definition is_even (n : nat) := exists k, n = 2 * k.

Lemma two_is_even : is_even 2.
Proof. exists 1. reflexivity. Qed.

Inductive permission := 
  | Unique          (* Эксклюзивный доступ (аналог &mut T) *)
  | SharedReadWrite (* Чтение и запись *)
  | SharedReadOnly  (* Только чтение (аналог &T) *)
  | Disabled.       (* Доступ запрещен *)

Inductive access_kind := 
  | AccessRead      (* Запрос на чтение *)
  | AccessWrite.    (* Запрос на запись *)

Definition grants (perm: permission) (access: access_kind) : bool :=
  match perm, access with
  | Disabled, _ => false          (* Все операции запрещены *)
  | SharedReadOnly, AccessWrite => false  (* Запись запрещена *)
  | _, _ => true                 (* Во всех остальных случаях разрешено *)
  end.

let pair x y = (x, y)

val pair : 'a -> 'b -> 'a * 'b

let swap (x, y) = (y, x)

val swap : 'a * 'b -> 'b * 'a

dockerfile {
    from("openjdk:21-jdk-slim")
    workdir("/app")

    +"Копируем JAR-файл в Docker-образ"
    copy {
        source = "app.jar"
        destination = "/app/app.jar"
    }

    cmd("java", "-jar", "app.jar")
}

+"Загружаем активы"
val assetPath =
 when (System.getenv("MODE")) {
  "local" -> "/first_100_assets.zip"
  "staging" -> "/compressed_assets.zip"
  else -> "/full_assets.zip"
 }

select * from user
where vibe = 'cheel'
 and status = 'active'

User  
.select { (User.vibe eq "cheel")  
 and (User.status eq "active") }

type stdioSession struct {
    pendingRequests map[int64]chan *samplingResponse // Хэш-таблица запросов
    pendingMu       sync.RWMutex                    // Мьютекс для доступа
    requestID       atomic.Int64                    // Атомарный счётчик
}

s.pendingMu.Lock()
s.pendingRequests[id] = responseChan
s.pendingMu.Unlock()

private val pendingRequests = ConcurrentHashMap<Long, Channel<SamplingResponse>>()
private val requestId = AtomicLong(0)

pendingRequests[id] = responseChannel // Не нужны явные блокировки

go func() {
    response := s.server.HandleMessage(ctx, rawMessage)
    if err := s.writeResponse(response, writer); err != nil {
        s.errLogger.Printf("Error: %v", err)
    }
}()

scope.launch {
    val response = server.handleMessage(rawMessage)
    writeChannel.send(response)  // Потокобезопасная отправка
}

-- Тип с модальностью §, ограничивающей рекурсию
data § a = § a

-- Функция сложения с контролем глубины
add :: §Int -> §Int -> §Int
add (§x) (§y) = §(x + y)

-- Рекурсивная функция с ограничением через типы
factorial :: Int -> §Int
factorial 0 = §1
factorial n = §(n * un§ (factorial (n-1)))  -- un§ "снимает" модальность