strobe strobe

Exposing a directory on the host machine to an LXC container

Log into the container and create an empty directory, this will be the mount point
Log out and stop the container.
Open to your container's config file
- For regular LXC containers: /var/lib/lxc/mycontainer/config
- For unprivileged LXC containers: $HOME/.local/share/lxc/mycontainer/config
Add a new line above the lxc.mount directive, that follows the format below. Substitute proper paths as necessary:
- lxc.mount.entry = /path/to/folder/on/host /path/to/mount/point none bind 0 0

Both of these paths are relative to the host machine.

Category theory jargon cheat sheet

A primer/refresher on the category theory concepts that most commonly crop up in conversations about Scala or FP. (Because it's embarassing when I forget this stuff!)

I'll be assuming Scalaz imports in code samples, and some of the code may be pseudo-Scala.

Functor

A functor is something that supports map.

Content of this gist was move to repo https://github.com/rabbitonweb/emacs_ensime_guide (for you to use and fork :) )

How to go through json object and change values with Circe in Scala

Small gist with some demo trait that shows an example on how to loop through json object and change values with circe in Scala.

Code example you can find below at circe-loop-json-object-example.scala.

The input JSON for test is kinda in in DynamoDB dump format:

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

	class ChatRoom(roomId: Int, actorSystem: ActorSystem) {

	private[this] val chatRoomActor = actorSystem.actorOf(Props(classOf[ChatRoomActor], roomId))

	def websocketFlow(user: String): Flow[Message, Message, _] = ???

	def sendMessage(message: ChatMessage): Unit = chatRoomActor ! message

	}

	import _root_.bintray.Bintray

	enablePlugins(JavaAppPackaging, JDebPackaging)

	name := "my-project"

	maintainer := "My name <[email protected]>"

	packageSummary := "Super package"

	yum install gcc make ncurses-devel giflib-devel libjpeg-devel libtiff-devel
	wget http://ftp.twaren.net/Unix/GNU/gnu/emacs/emacs-25.1.tar.xz
	tar xJf emacs-*
	cd emacs-*
	./configure --without-x --without-selinux
	make && make install

	sealed trait Task[A] {
	import Task._

	final def flatMap[B](f: A => Task[B]): Task[B] = Suspend(this, f)

	final def map[B](f: A => B): Task[B] = this match {
	case Suspend(inner, suspension) =>
	Suspend(inner, suspension andThen { _ map f })

	case Async(body) =>

	import cats.data.Kleisli
	import cats.implicits._
	import cats.{Applicative, FlatMap, Functor, Monad, Monoid, ~>}

	final case class Cofree[F[_], A](head: A, tail: F[Cofree[F, A]]) {
	def map[B](f: A => B)(implicit F: Functor[F]): Cofree[F, B] =
	Cofree(f(head), F.map(tail)(_.map(f)))
	def zip[B](other: Cofree[F, B])(implicit F: Applicative[F]): Cofree[F, (A, B)] =
	Cofree((head, other.head), (tail \|@\| other.tail).map(_ zip _))