Daniel Pous Montardit Softsapiens

Getting Started in Scala

This is my attempt to give Scala newcomers a quick-and-easy rundown to the prerequisite steps they need to a) try Scala, and b) get a standard project up and running on their machine. I'm not going to talk about the language at all; there are plenty of better resources a google search away. This is just focused on the prerequisite tooling and machine setup. I will not be assuming you have any background in JVM languages. So if you're coming from Python, Ruby, JavaScript, Haskell, or anywhere… I hope to present the information you need without assuming anything.

Disclaimer It has been over a decade since I was new to Scala, and when I was new to Scala, I was coming from a Java and Ruby background. This has probably caused me to unknowingly make some assumptions. Please feel free to call me out in comments/tweets!

One assumption I'm knowingly making is that you're on a Unix-like platform. Sorry, Windows users.

Getting the JVM

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

	/**
	* In classic Scala implementation of hierarchies of Category theory laws (scalaz/cats), the dependency between
	* different laws is encoded using inheritance (https://github.com/typelevel/cats/blob/master/core/src/main/scala/cats/Monad.scala#L14)
	*
	* This approach creates well-known issues: for example, a Monad is able to _derive_ an Applicative.
	* So sometimes, you don't have the Applicative you want but the one derived from the Monad or it doesn't
	* compile because you have 2 Applicatives in your implicit scope.
	*
	* Alois Cochard has proposed a new model to represent that in (scato project)[https://github.com/aloiscochard/scato] or
	* (scalaz/8.0.x)[https://github.com/scalaz/scalaz/blob/series/8.0.x/base/src/main/scala/typeclass/Monad.scala] branch.

	{-# LANGUAGE OverloadedStrings #-}

	module Main where

	import Network.Wai (pathInfo, Request, requestMethod, Response, responseLBS, ResponseReceived)
	import Network.Wai.Handler.Warp (run)
	import Network.HTTP.Types (status200, status401)

	-- note: type Application = Request -> (Response -> IO ResponseReceived) -> IO ResponseReceived
	application :: Request -> (Response -> IO ResponseReceived) -> IO ResponseReceived


	// Basic shapeless-style HList
	sealed trait HList

	sealed trait HNil extends HList {
	def ::[H](h : H) = Test.::(h, this)
	}
	final case object HNil extends HNil

	final case class ::[+H, +T <: HList](head : H, tail : T) extends HList

	{-# LANGUAGE BangPatterns #-}
	{-# LANGUAGE DeriveFunctor #-}
	{-# LANGUAGE LambdaCase #-}
	{-# LANGUAGE RankNTypes #-}
	{-# LANGUAGE RecordWildCards #-}

	import Control.Comonad
	import Control.Comonad.Cofree
	import Control.Monad
	import Control.Monad.ST

	{-# language DeriveGeneric #-}
	{-# language TypeFamilies #-}
	{-# language TypeOperators #-}
	{-# language PatternSynonyms #-}

	import Data.Text
	import qualified GHC.Generics as GHC
	import Generics.SOP
	import Text.Read

	module Logic

	-- Connective is a fancy word for operator.
	namespace Connectives

	-- Truth: Also known as the "unit" type, (there is only one truth in value,
	-- literally).
	-- Scala: type Truth = Unit
	-- Haskell: type Truth = ()
	Truth : Type

	/**
	* Created by ariwaranosai on 16/8/28.
	*
	*/

	import ST._

	case class World[S]()

	case class ST[S, A](f: World[S] => (World[S], A)) {