Scala3

It is much better to think in terms of nested Sets of type-tagged structured values. With proper universal nesting almost everything can be abstracted as such a value. Objects may have fields and methods, traits may have types, fields, methods and other traits, which may have types, methods and other traits… At a higher level, modules and whole packages are such “values” too.

Scala 3 import system hints at this universality, allowing one to import everything from everything almost uniformly. This is a consequence of a proper design, and proper modeling based on just Sets and (Second Order) Logic.

Scala 3 got a lot of principle-guided unification from being a cool collection of ad-hook design decisions. It is by far the best-designed language out there, especially compared to Java or C++.

• cs - artifact manager
• amm - advanced REPL

The Compiler, sbt and amm

cs setup

Language-server, linter, formater

cs install bloop metals scalafix scalafmt

cs update

Launch the REPL

cs launch ammonite --scala 3.2.1

import straight from Maven

import $ivy.`com.typesafe.akka:akka-stream_3:2.7.0`

The Giga Chad Odersky and the team are using VSCode, so it almost always works. Vim and Emacs require some effort.

Be aware of which sbt binary is in your $PATH, which version is specified in project/build.properties and which version has been installed by cs. Usually there is a version mismatch.

Older Vim plugins check by calling scalac, so make sure there is no Scala2 scalac binary in the $PATH. By default Scala3 calls the compiler scala3-compiler.

Since cs is the modern tool of choice, make sure your $HOME/.local/share/coursier/bin/ is in the $PATH

scalafmt needs to specify a dialect in the .scalafmt.conf.

Refinement of implicits (of implicit contexts) by using a common mathematical jargon.

The general principle of a context is that one does not have to always mention some properties or attributes.

Conceptually similar to partial application, so one does not have to pass it all around.

An implicit value can be “inferred” by the compiler or selected explicitly among many.

Most of them are over-“engineered” and bloated, without any effort of making the abstractions minimal and “just right” (optimal). Such “natural selection” (of gradual refinement and reduction to a local optimum) takes decades (like Common Lisp, Ocaml stdlib or Haskell’s prelude).

Most of corporate code are of low-effort, and mostly “copying” of imperative implementations from one another.

• zio2 - functional style I/O
• cats - some standard type-classes for common algebraic structures.
• akka - the supposedly done right basic building blocks. Use it.
• The Twitter stack (still Scala 2)
• Kafka - steams
• Spark - the killer-app (still Scala 2)

package s3.payload

import akka.http.scaladsl.model.Uri

import java.net.URLEncoder
import java.io.UnsupportedEncodingException

import scala.sys.process.*

import s3.keys.{getSecretKey, privateKeyFile}

// We shall use their (Binance's) terminology consistently
// hoping that they use it consistently too

// They call this /Singed Payload/

// functions for constructing Signed Payloads

// local type aliases
type QueryString  = String
type DigestSHA256 = String

// This extension can be imported from this module
extension (uri: Uri)
  def withSignature: Uri =
    uri.rawQueryString match
      case Some(s) =>
        uri.withRawQueryString(addSignature(s), Uri.ParsingMode.Strict)
      case None => uri

  def addSignature(s: QueryString): QueryString =
    s ++ f"?signature=${digest(s)}"

def digest(q: QueryString): DigestSHA256 =
  val sk = getSecretKey
  val a =
    f"bash -c \"echo -n '${q}' | openssl dgst -sha256 -hmac '${sk}'\""
      .!!
      .split(' ')
      .map(_.trim)
  a(1)

import akka.http.scaladsl.model.*

import org.scalatest._
import flatspec._
import matchers._

class PayloadSpec extends AnyFlatSpec with should.Matchers {
  "A signed URI" should "be constructed" in {
    val p =
      "symbol=LTCBTC&side=BUY&type=LIMIT&timeInForce=GTC&quantity=1&price=0.1&recvWindow=5000&timestamp=1499827319559"
    val d =
      "c8db56825ae71d6d79447849e617115f4a920fa2acdcab2b053c4b2838bd6b71"

    import s3.binance.uri
    import s3.payload.withSignature

    val uri1 = uri
      .withRawQueryString(p, Uri.ParsingMode.Strict)
      .withSignature

    uri1.toString should endWith(d)
  }
}