dwijnand

object RefOrNull {
  type Id[A >: Null <: AnyRef] = A
  type No[A >: Null <: AnyRef] = Null
  def nullAs[A] = null.asInstanceOf[A]
  def sideEffect[A](result: A, exprs: Any*): A = result
  def set[A, B](result: A, exprs: Any*): B = result.asInstanceOf[B]
}
import RefOrNull._

final class Data[

dwijnand

#!/usr/bin/env bash
#
# Intercepting the output of 'sbt new' directly fails
# because it asks interactive questions so we can't process
# line by line. An apparent OSX-specific bug in egrep
# fails on lookbehind clauses so we use ag. Capturing
# the interactive output with script succeeds, but script
# uses \r\n to terminate lines so we can't match the
# filename with '.*' or we get
#

dwijnand

The Cabal/Stack Disambiguation Guide

One of the most frequently asked Haskell beginner questions in recent years is:

"Stack or cabal?"

I will helpfully not answer this question. Instead I will hope to eliminate the confusion that many of the askers seem to have about the various different

dwijnand

object NumProblem:
  opaque type Pos <: Int = Int
  opaque type Neg <: Int = Int

  object Pos { def unapply(x: Int): Option[Pos] = if (x > 0) Some(x) else None }
  object Neg { def unapply(x: Int): Option[Neg] = if (x < 0) Some(x) else None }

  (n: Int) match
    case 0      =>
    case Pos(x) =>

dwijnand

object JNumber {
  def apply(value: Int): JNumber = JNumber(value.toInt.toString)
  def apply(value: Integer): JNumber = JNumber(value.toString)
  def apply(value: Byte): JNumber = JNumber(value.toString)
  def apply(value: Short): JNumber = JNumber(value.toString)
  def apply(value: Long): JNumber = JNumber(value.toString)
  def apply(value: BigInt): JNumber = JNumber(value.toString)
  def apply(value: BigDecimal): JNumber = JNumber(value.toString)
  def apply(value: Float): JNumber = JNumber(value.toString)
  def apply(value: Double): JNumber = JNumber(value.toString)

dwijnand

package skolems

import scala.language.implicitConversions

trait Exists[+F[_]] extends Serializable:
  type A
  val value: F[A]

trait Forall[+F[_]] extends Serializable:
  def apply[A]: F[A]