Pelle Krøgholt pellekrogholt

Expressive Metaprogramming for Scala 3

Overview

Scala 3 introduces a new macro system that replaces the experimental Scala 2 system with one that should avoid unsoundness, be simpler to use, and simpler for the compiler team to evolve and maintain.

Perhaps the most significant feature missing from Scala 3 today is the lack of support

Ad-hoc polymorphism with the typeclass pattern

from Wikipedia: "Ad hoc polymorphism is a dispatch mechanism: control moving through one named function is dispatched to various other functions without having to specify the exact function being called. Overloading allows multiple functions taking different types to be defined with the same name; the compiler or interpreter automatically ensures that the right function is called. This way, functions appending lists of integers, lists of strings, lists of real numbers, and so on could be written, and all be called append—and the right append function would be called based on the type of lists being appended. This differs from parametric polymorphism, in which the function would need to be written

Scala Case class, Companion object, Apply method and more

Let’s take a look at some examples:

Example1:

object Tests extends App {
  println(Rating("PG",13))
  println(Rating.apply("PG",13)) //This is equivalent, so you don't need to explicitly call apply
}

Download Audio from YouTube

-i - ignore errors

-c - continue

-t - use video title as file name

--extract-audio - extract audio track

Thread Pools

Thread pools on the JVM should usually be divided into the following three categories:

CPU-bound
Blocking IO
Non-blocking IO polling

Each of these categories has a different optimal configuration and usage pattern.

Pattern file: /etc/logstash/patterns/nginx Logstash shipper: /etc/logstash/conf.d/shipper.conf

Nginx http log module: http://nginx.org/en/docs/http/ngx_http_log_module.html

	//> using scala 3.3

	import scala.util.{Failure, NotGiven, Success, Try, boundary}
	import boundary.{Label, break}
	import scala.annotation.targetName

	/**
	* Proof of concept implementation of a syntax similar to Kotlin and
	* typescript. Within the context provided by [[getEither]], you can call
	* `?` on any optional/failable type (currently supports [[Option]],

	import zio.prelude.Newtype

	import cats.Contravariant
	import cats.Functor
	import cats.syntax.contravariant.*
	import cats.syntax.functor.*

	import io.circe.*
	import io.circe.syntax.*
	import io.circe.parser.decode

	// Unhappy with the default behavior of a particular datatype?
	// You can override it as you wish, you must write a Diff and merge for the datatype you wish to override

	final case class Address(
	streetNumber: Int,
	streetName: String,
	city: String,
	country: String
	)

	import * as React from 'react';
	import {
	Field as FormField,
	InjectedFormProps,
	reduxForm,
	} from 'redux-form';

	interface CustomProps {
	customText: string;
	}