johnhungerford

sealed trait Bool
object Bool:
    sealed trait True extends Bool
    sealed trait False extends Bool
    
sealed trait Nat
object Nat:
    sealed trait _0 extends Nat
    sealed trait Succ[N <: Nat] extends Nat

maropu

Spark session available as 'spark'.
Welcome to
      ____              __
     / __/__  ___ _____/ /__
    _\ \/ _ \/ _ `/ __/  '_/
   /___/ .__/\_,_/_/ /_/\_\   version 3.2.0-SNAPSHOT
      /_/
         
Using Scala version 2.12.10 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_181)
Type in expressions to have them evaluated.

kamilkloch

import scala.reflect.ClassTag

object Bottom extends App {

  class C[T](implicit ev: reflect.ClassTag[T]) {
    def ct: reflect.ClassTag[T] = ev
  }
  class X[U, -T]

  object X {

luqui

{-# LANGUAGE RankNTypes, TypeApplications #-}

-- We give a constructive proof that any natural transformation that uses
-- a type switch in its implementation can also be implemented without the type switch,
-- as long as the domain functor is finitely Traversable (and the argument can easily
-- be modified to drop the finiteness property).

-- We do this by providing a function `opaquify` which takes an n.t. which may do 
-- type switches, and returns an equivalent n.t. which does not. 

kamilkloch

import scala.reflect.ClassTag

object DefaultType extends App {

  case class AttributeMeasure[T](name: String)(implicit ev: reflect.ClassTag[T]) {
    def ct: ClassTag[T] = ev
  }

  /** This almost works, except for the case:
    * {{{

SethTisue

in Scala 2, they don't chain 😇, even if we try to give the compiler an assist

can we make them chain in Dotty? 😈

let's try it!

first let's set up sbt:

% cat project/plugins.sbt

BalmungSan

Polymorphism in Scala

This document aims to show and compare three alternatives for achieving polymorphism in Scala.

• Subtyping, common in object-oriented languages like Java.
• Duck typing, common in dynamically typed languages like Python.
• Typeclasses, common in functional languages like Haskell.

Additionally, when implementing the typeclass pattern in Scala,

AndyShiue

I think I’ve figured out most parts of the cubical type theory papers; I’m going to take a shot to explain it informally in the format of Q&As. I prefer using syntax or terminologies that fit better rather than the more standard ones.

Q: What is cubical type theory?

A: It’s a type theory giving homotopy type theory its computational meaning.

Q: What is homotopy type theory then?

A: It’s traditional type theory (which refers to Martin-Löf type theory in this Q&A) augmented with higher inductive types and the univalence axiom.

claudinei-daitx

import org.apache.spark.SparkConf
import org.apache.spark.sql.SparkSession

//create a spark session who works with Kryo.
object SparkSessionKryo {
    def getSparkSession: SparkSession = {
        val spark = SparkSession
            .builder
            .appName("my spark application name")
            .config(getConfig)

Jasper-M

import scala.language.experimental.macros
import scala.reflect.macros.whitebox.Context

trait HasCompanion[A] {
  type Type
  def companion: Type
}
object HasCompanion {
  type Aux[A,C] = HasCompanion[A] { type Type = C }
  def apply[A](implicit hc: HasCompanion[A]): hc.type = hc