darkfrog26

@scala {
	object Example {
		@java {
			public void main(String[] args) {
				...
			}
		}
		
		val json = @json {
			one: 1,

darkfrog26

import cats.effect.{Deferred, IO}

import java.util.concurrent.ConcurrentHashMap

trait WorkCache[Key, Result] {
  private val map = new ConcurrentHashMap[Key, Deferred[IO, Result]]

  protected def persisted(key: Key): IO[Option[Result]]

  protected def work(key: Key): IO[Result]

darkfrog26

import cats.effect.IO
import cats.effect.unsafe.implicits.global

import scala.concurrent.duration._

object Maintenance {
  def schedule(schedule: FiniteDuration,
               initialDelay: Option[FiniteDuration] = None)
              (action: IO[TaskResult]): MaintenanceTask = {
    var normalSchedule = schedule

darkfrog26

package live.prepared

import cats.data.EitherT
import cats.effect._
import cats.implicits._
import fabric.parse.Json
import fabric.rw._
import fs2.Chunk
import org.http4s._
import org.http4s.dsl.Http4sDsl

darkfrog26

import 'package:flutter/material.dart';
import 'package:get/get.dart';

class Screen {
  final String key;
  final Nav? nav;
  final Widget Function() createWidget;

  Screen({
    required this.key,

darkfrog26

import 'package:flutter/material.dart';
import 'package:get/get.dart';

void main() {
  runApp(MyApp());
}

class MyNavModel {
  static final Map<String, MyNavModel> urls = {};
  final IconData icon;

darkfrog26

/*
Allows me to write MUnit tests like:

"Such and such" should {
  "do something" in {
    value should be(123)
  }
}

*/

darkfrog26

  inline def fromMapElems[A <: Product, T <: Tuple, L <: Tuple](map: Map[String, Value], index: Int, arr: Array[Any]): Unit = {
    inline erasedValue[T] match
      case _: (hd *: tl) =>
        inline erasedValue[L] match
          case _: (hdLabel *: tlLabels) =>
            import fabric.rw.given
            val hdLabelValue = constValue[hdLabel].asInstanceOf[String]
            val hdValueOption = map.get(hdLabelValue)
            val hdWritable = summonInline[Writer[hd]]
            val valueOption = hdWritable.map(_.write(hdValue))

darkfrog26

package hierarchical.rw

import hierarchical.*
import hierarchical.rw.*

import scala.deriving.*
import scala.compiletime.*

trait CompileRW {
  implicit val stringR: Readable[String] = stringRW

darkfrog26

import java.util.concurrent.ConcurrentLinkedQueue
import scala.concurrent.duration.FiniteDuration
import scala.concurrent.{ExecutionContext, Future, TimeoutException}
import scala.util.{Failure, Success}

trait ParallelIterator[T] extends Iterator[T] { iterator =>
  private val buffer = new ConcurrentLinkedQueue[T]
  private var finished = false
  private var failure: Option[Throwable] = None