Barnabás Oláh stsatlantis

kubectl multi-version brews

Applicability

The instructions below apply to older versions of Homebrew which still provide switch capability.

For current Homebrew, you'll likely need to keep Versions around, and build locally. Here's my versions repository https://github.com/rdump/homebrew-versions

MacPorts is now keeping versioned installations available as well, by default.

If you want to learn Scala, I’d suggest:

Install IntelliJ + Scala Plugin
Don’t do the Coursera courses yet.
Don’t do the “red book” Functional Programming in Scala yet.
Do: http://underscore.io/books/
- Essential Scala
- Essential Play
- Essential Slick
Do Scala for the Impatient: https://www.amazon.com/Scala-Impatient-Cay-S-Horstmann/dp/0321774094
The Neophyte’s Guide to Scala http://danielwestheide.com/scala/neophytes.html

Applied Functional Programming with Scala - Notes

1. Mastering Functions

A function is a mapping from one set, called a domain, to another set, called the codomain. A function associates every element in the domain with exactly one element in the codomain. In Scala, both domain and codomain are types.

val square : Int => Int = x => x * x

EDIT: This gist has been promoted and is now a blog post.

Kinda-Curried Type Parameters

Scala methods can have multiple lists of value parameters but only one list of type parameters, which is occasionally irritating when some are inferable and others are not. Consider this method which has two type parameters, one inferable and one not.

import scalaz._, Scalaz._

	import java.nio.file.{ Files, Path, Paths }

	import cats.effect.{ ContextShift, IO }
	import org.http4s.{ HttpRoutes, Request }
	import sttp.tapir.Endpoint
	import sttp.tapir.redoc.http4s.RedocHttp4s
	import sttp.tapir.openapi.circe.yaml._
	import sttp.tapir.docs.openapi._

	object DocUtils {

	[
	{
	"map":{
	"round_wins":{
	"1":"ct_win_elimination",
	"2":"ct_win_elimination",
	"3":"t_win_elimination",
	"4":"t_win_elimination",
	"5":"ct_win_defuse",
	"6":"ct_win_elimination",

	object Main extends App {
	AvoidLosingGenericType.run()
	AvoidMatchingOnGenericTypeParams.run()
	TypeableExample.run()
	TypeTagExample.run()
	}

	class Funky[A, B](val foo: A, val bar: B) {
	override def toString: String = s"Funky($foo, $bar)"
	}

	7 4 3 9 5 1 6 8 2
	1 6 2 4 8 7 3 9 5
	9 5 8 6 3 2 7 1 4
	2 1 9 8 7 3 5 4 6
	3 7 4 5 6 9 1 2 8
	5 8 6 1 2 4 9 7 3
	4 9 5 2 1 6 8 3 7
	8 2 7 3 9 5 4 6 1
	6 3 1 7 4 8 2 5 9

	*.class
	*.log

	# sbt specific
	.cache/
	.history/
	.lib/
	dist/*
	target/
	lib_managed/

	package slicks.docs.dao

	import scala.slick.driver.PostgresDriver.simple._
	import scala.slick.driver._


	trait Profile {
	val profile: JdbcProfile
	}