Ivano Pagano ivanopagano

Easy Scala Publication

The following describes how you can publish artifacts for any sbt project using the GitHub Package Registry and the sbt-github-packages plugin.

Step 1: Create a GitHub Token

In your GitHub account, go to Settings > Developer settings > Personal access tokens, then click on Generate new token (or click here). Fill in some sort of meaningful name (I chose Dev) and click on the write:packages checkbox:

This post is a collection of links about John De Goes that show some clear patterns of behavior:

De Goes defending white supremacists and misogynists.
De Goes attacking critics and accusing them (especially women) of lying.
De Goes engaging in targeted harassment, either directly (@druconfessions) or indirectly (e.g. via ClarkHat, a LambdaConf sponsor).

Despite all of the information in this post being publicly available and widely known, De Goes is frequently invited to Scala conferences to speak. The following are a few of his conference appearances in 2019:

Using with Sublime

I successfully enabled the metals lsp server to work with sublime text 3

I didn't actually need to write any lsp client, since I'm using the standard LSP Package

Setup

My working setup is specific:

macOS HIgh Sierra
Sublime 3 on Dev channel build 3160

Rich Already Answered That!

A list of commonly asked questions, design decisions, reasons why Clojure is the way it is as they were answered directly by Rich (even when from many years ago, those answers are pretty much valid today!). Feel free to point friends and colleagues here next time they ask (again). Answers are pasted verbatim (I've made small adjustments for readibility, but never changed a sentence) from mailing lists, articles, chats.

How to use:

The link in the table of content jumps at the copy of the answer on this page.
The link on the answer itself points back at the original post.

	{-# LANGUAGE LambdaCase #-}
	{-# LANGUAGE FunctionalDependencies #-}
	{-# LANGUAGE MultiParamTypeClasses #-}

	module Graph where

	import Control.Comonad

	-- we need to separate `a` and `b` because `a` is covariant while `b` is contravariant => this is actually a profuctor
	data PointedGraph moves b a = PointedGraph

	package org.daron.html

	import cats.syntax.either._
	import cats.syntax.flatMap._
	import cats.syntax.functor._
	import com.softwaremill.sttp.{SttpBackend, _}
	import io.chrisdavenport.log4cats.Logger

	trait HttpClient[F[_]] {
	def getPageSource(uri: java.net.URI): F[String]

	package fpmax

	import scala.util.Try
	import scala.io.StdIn.readLine

	object App0 {
	def main: Unit = {
	println("What is your name?")

	val name = readLine()

	val (recycleQueue, recycleSource) =
	Source
	.queue[SoilStateReading](100, OverflowStrategy.dropTail)
	.prefixAndTail(0)
	.map(_._2)
	.toMat(Sink.head)(Keep.both)
	.run()
	StreamConverters.fromInputStream(() => this.getClass.getClassLoader.getResourceAsStream("sensors.log"))
	.via(SoilStateReading.csvParser)
	.merge(Source.fromFutureSource(recycleSource))

	-- \| A “flushing” 'stream', with an additional coalgebra for flushing the
	-- remaining values after the input has been consumed. This also allows us to
	-- generalize the output away from lists.
	fstream
	:: (Cursive t (XNor a), Cursive u f, Corecursive u f, Traversable f)
	=> Coalgebra f b -> (b -> a -> b) -> Coalgebra f b -> b -> t -> u
	fstream ψ g ψ' = go
	where
	go c x =
	let fb = ψ c


	import slick.codegen.SourceCodeGenerator
	import slick.jdbc.JdbcProfile
	import slick.model.Model

	import scala.concurrent.{Await, ExecutionContext}
	import scala.concurrent.duration.Duration

	object SourceCodeGenerator {