| //configure custom sbt prompt | |
| ThisBuild / shellPrompt := { state => | |
| val extracted = Project.extract(state) | |
| import extracted._ | |
| /* COLOR DEFS | |
| * for ansi color codes refer to http://www.calmar.ws/vim/color-output.png | |
| * and to https://misc.flogisoft.com/bash/tip_colors_and_formatting | |
| */ | |
| type Color = Byte |
This is a companion code sample to go with the Tezos is now an asset tokenization platform article on Medium from The Cryptonomic Aperiodical. As always, to test this code get infrastructure access from Nautilus Cloud.
The code included here demonstrates token deployment and management workflows. It does not have an example for burn(), but that is also available in the API.
This is a companion code sample to go with the Tezos is now an asset tokenization platform article on Medium from The Cryptonomic Aperiodical. As always, to test this code get infrastructure access from Nautilus Cloud.
The code included here demonstrates token deployment and management workflows. It does not have an example for burn(), but that is also available in the API.
| import shapeless._ | |
| trait Flatten[I, O <: HList] { | |
| def apply(i: I): O | |
| } | |
| trait FlattenLow { | |
| implicit def otherFlatten[I] = new Flatten[I, I :: HNil] { | |
| def apply(i: I) = i :: HNil | |
| } |
| window n ls = filter ((n == ) . length) $ transpose . take n . tails $ ls | |
| match_on_element _ _ [] = false | |
| match_on_element 0 p x :: xs = p x | |
| match_on_element i p x :: xs = match_on_elmement (i-1) p xs | |
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
My working setup is specific:
Tageless Final interpreters are an alternative to the traditional Algebraic Data Type (and generalized ADT) based implementation of the interpreter pattern. This document presents the Tageless Final approach with Scala, and shows how Dotty with it's recently added implicits functions makes the approach even more appealing. All examples are direct translations of their Haskell version presented in the Typed Tagless Final Interpreters: Lecture Notes (section 2).
The interpreter pattern has recently received a lot of attention in the Scala community. A lot of efforts have been invested in trying to address the biggest shortcomings of ADT/GADT based solutions: extensibility. One can first look at cats' Inject typeclass for an implementation of [Data Type à la Carte](http://www.cs.ru.nl/~W.Swierstra/Publications/DataTypesA
| //refers to http://eed3si9n.com/herding-cats/stacking-future-and-either.html | |
| def isFriends1(user1: Long, user2: Long) | |
| (implicit ec: ExecutionContext): Future[Either[Error, Boolean]] = | |
| for { | |
| a <- followers(user1) | |
| b <- followers(user2) | |
| } yield for { | |
| x <- a.right | |
| y <- b.right |
The policy is keep-majority, new instances are started one by one, on redeploy newest instances are downed first (YOUNGEST_FIRST)
N1, N2, N3N+)N+ is acked by all the nodes, so the Leader (L) is about to set the node to UP
I hereby claim:
To claim this, I am signing this object: