p-pavel

import io.circe.*
import literal.*
import cats.implicits.*
import NamedTuple.NamedTuple
import language.experimental.namedTuples

@main
def greet =
  type Person = (name: String, age: Int)
  val greeting = json"""{"name": "Joe", "age": 42}"""

p-pavel

trait Semigroup[T]:
  type C = T
  extension (a: C) def |+|(b: C): C

trait Monoid[T] extends Semigroup[T]:
  def empty: T

def mkMonoid[T: Semigroup as s](e: T) = 
  new:
    def empty = e

p-pavel

# This is the log of pauses from shitty N5105 Celeron running Karaf OSGi container
# most of the load comes from a component running inside the container that 
# does data acquisition, some simple processing, grouping and straming into
# TSDB (victoria metrics). The app is written in very high level style using 
# fs2/cats.effect without any optimisation attemts altogether
# it does ~ 3000 syscalls per second to obtain data. 
# No memory options at all, no attempts of tuning, vanilla G1 collector
# you can see <2ms pauses once in 40 seconds or so. OpenJDK 22 (GraalVM JIT would 
# help in this case a lot, btw, it's very good in allocation elimination)

p-pavel

//> using scala 3.5.1
//> using options -Wunused:all -deprecation -Xkind-projector -rewrite -source future-migration
//> using dep org.typelevel::algebra:2.12.0
//> using test.dep org.typelevel::discipline-munit:2.0.0
//> using test.dep org.typelevel::algebra-laws:2.12.0

import algebra.laws.LatticeLaws
import algebra.lattice.MeetSemilattice

given MeetSemilattice[String] with

p-pavel

trait PseudoSbt:
  type Setting[+_]
  type Key[+_]
  type Project

  /** context to extract value of type A from Setting[A]*/
  type ValueExtractor 

  /** Location in source file to be used to track definitions*/
  type Location 

p-pavel

//>using lib "org.typelevel::cats-effect:3.5.1"
import cats.effect.*
import cats.implicits.*

object HowToRunJobsInParallel extends IOApp.Simple:
  def jobConstructor(r: Ref[IO, Long])(jobId: Any) = r
    .modify(n => (n + 1, n))
    .flatMap(v => IO.println(s"Job $jobId processed task $v"))
  def run                               =
    for

p-pavel

import compiletime.ops.int.S

type Nat[n <: Int] = 
  n match 
    case 0 => 0
    case S[n] =>  S[n] | Nat[n]

type Octal = Nat[7]

object Registers:

p-pavel

def flipFlopChain: List[Boolean] => List[Boolean] =
  case Nil =>  Nil
  case a :: rest =>
    val a1 = !a
    val rest1 = if a1 then flipFlopChain(rest) else rest
    a1 :: rest1

def chainToString(l: Seq[Boolean]): String =
  String(l.toArray.map { case true => '1'; case false => '0' })

p-pavel

import scala.annotation.targetName
import cats.*
import cats.implicits.*
import cats.data.{StateT, State}


trait CRUD:
  type Obj
  type Identity
  type Criteria

p-pavel

package com.perikov

import cats.*
import cats.implicits.*
import cats.laws.*
import org.scalacheck.Arbitrary
import org.scalacheck.Prop.forAll
import cats.laws.*
import cats.laws.discipline.*