All Aboard The Scala-to-PureScript Express!

All Aboard the Scala-
to-PureScript
Express!
John A. De Goes

What's Wrong with Scala?
Nothing... Scala Makes FP Possible

PureScript Makes FP Easy
• Syntax optimized for function deﬁnition & application
• Polymorphic functions
• Rank-n types
• Higher-kinded type inference
• Constraint inference
• Polymorphic row types (records, effects)
• Effect system for high performance, good reasoning

PureScript Is Just Like Scala!
• Strict, not lazy
• Good mapping of primitives to JVM
• Integer -> int, java.lang.Integer
• Number -> ﬂoat, java.lang.Float
• String -> String1
• Boolean -> boolean, java.lang.Boolean
• Array a -> Java array
• Java-compatible FFI
• Import types
• Import (static) functions
• No story for methods
• Wrap, baby, wrap!
In Fact, The Core of Scala is... PureScript!
1
Not [Char] like Haskell!

PureScript Tour
Comments
// Single-line
/* Multi-line */
/** Scala doc */
-- Single-line
(* Multi-line *)
-- | PureScript doc

PureScript Tour
Literals
val bool = true -- Boolean
val int = 2 -- Integer
val float = 2.2 -- Float
val char = 'C' -- Char
val string = "foo" -- String
val tuple = (1, 2) -- Tuple2
let bool = true -- Boolean
let int = 2 -- Int
let float = 2.2 -- Number
let char = 'C' -- Char
let string = "foo" -- String
let array = [1, 2] -- Array Int
let record = {a: 1} -- Record

PureScript Tour
Local Variables (Let)
val dsquared = d * d
val distance = Math.sqrt(dsquared)
distance * 0.5
let
dsquared = d * d
distance = sqrt distance
in
distance * 0.5

PureScript Tour
Local Variables (Where)
halfDistance d = distance * 0.5
where
dsquared = d * d
distance = sqrt distance

PureScript Tour
Data: Products
case class Person(name: String, age: Int)
|
Type constructor
// Implicit data constructor:
// object Person { def apply(name: String, age: Int): Person = new Person(name, age) }
data Person = Person String Int
| |
Type Constructor Data Constructor

PureScript Tour
Data: Products w/Records
val sherlock = Person("Sherlock Holmes", 42)
let sherlock = Person "Sherlock Holmes" 42

PureScript Tour
Data: Products w/Records
data Person = Person {name :: String, age :: Int}
let sherlock = Person {name: "Sherlock Holmes", age: 42}

PureScript Tour
Data: Sums
sealed trait Option[A]
final case class Some[A](value: A) extends Option[A]
final case class None[A]() extends Option[A]
data Option a = Some a | None

PureScript Tour
Data: Sums
val somePerson: Option[Person] = Some(sherlock)
let somePerson = Some sherlock

PureScript Tour
Pattern Matching: Products
val name = sherlock match {
case Person(name, age) => name
}
let name = case sherlock of
Person name age -> name

PureScript Tour
Pattern Matching: Records
let name = case sherlock of
Person {name: n, age: a} -> n

PureScript Tour
Pattern Matching: Sums
val name = somePerson match {
case Some(Person(name, _)) => name
case None() => "Mary Smith"
}
let name = case somePerson of
Some (Person name _) -> name
None -> "Mary Smith"

PureScript Tour
Pattern Matching: Sums (w/Records)
let name = case somePerson of
Some (Person {name: name}) -> name
None -> "Mary Smith"

PureScript Tour
Types: Signatures (Definitions)
val nameExtractor : Person => String = _.name
nameExtractor :: Person -> String
nameExtractor (Person name _) = name

PureScript Tour
Types: Signatures (Inline)
val i = 3
(i * (2 : Int)) + 5

PureScript Tour
Types: Signatures (Inline)
let i = 3 in (i * (2 :: Int)) + 5

PureScript Tour
Types: Aliases
type Result[A] = Either[Error, A]
type Email = String
type Function[A, B] = A => B
type Result a = Either Error a
type Email = String
type Function a b = a -> b

PureScript Tour
Types: Records
type Person = { name :: String, age :: Int }

PureScript Tour
Types: Arrays
let intArray = [1, 2, 3] -- Array Int

PureScript Tour
Function Definition: Monomorphic
val squareIt : Float => Float = (x: Float) => x * x
squareIt :: Number -> Number
squareIt x = x * x

PureScript Tour
Function Definition: Monomorphic (Lambdas)
squareIt = x -> x * x

PureScript Tour
Function Definition: Polymorphic
def second[A, B](tuple: (A, B)): B = tuple._2
second :: forall a b. Tuple a b -> b
second (Tuple _ b) = b

PureScript Tour
Function Definition: Higher Arity
def fullName(firstName: String, lastName: String): String = firstName + " " + lastName
val result = fullName("John", "Doe")
fullName :: String -> String -> String
fullName first last = first <> " " <> last
result = fullName "John" "Doe"

PureScript Tour
Function Definition: Higher Arity
myFunction :: a -> b -> c -> d -> e
-- Equivalent to:
myFunction :: a -> (b -> (c -> (d -> e)))

PureScript Tour
Function Application: Monomorphic
val squareIt : Float => Float = (x: Float) => x * x
squareIt(2.2)
squareIt = x -> x * x
result = squareIt 2.2

PureScript Tour
Packages / Modules
package collections.immutable.list
// ...
module Collections.Immutable.List where
-- ...

PureScript Tour
Imports
package collections.immutable.list
import scalaz.(IList)
module Collections.Immutable.List where
-- No wildcard
import Data.Tuple(Tuple(..))

PureScript Tour
Exports
package object utils {
public def second[A, B](tuple: (A, B)) B = tuple._2
}
module Util (second) where
import Data.Tuple(Tuple(..))
second :: forall a b. Tuple a b -> b
second (Tuple _ b) = b

PureScript Tour
Type Classes
trait Semigroup[A] {
def append(a1: A, a2: A): A
}
implicit val StringSemigroup: Semigroup[String] {
def append(a1: String, a2: String): String = a1 + a2
}
class Semigroup a where
append :: a -> a -> a
instance stringSemigroup :: Semigroup String where
append a1 a2 = a1 <> a2

PureScript Tour
(Sync|Async) Effects
println("What is your name?")
val name = readLine()
println("Hello, " + name "!")
prints = do
println "What is your name?"
name <- readLine
println ("Hello, " <> name <> "!")

PureScript Tour
Effects
• No need to understand the monadic basis to get started
• Utilizes PureScript's polymorphic row types
• Different types of effects are labeled differently in a row of
effects
• Fine-grained effect tracking without performance overhead

All Aboard The Scala-to-PureScript Express!

More Related Content

What's hot (20)

Similar to All Aboard The Scala-to-PureScript Express! (20)

More from John De Goes (16)

Recently uploaded (20)

All Aboard The Scala-to-PureScript Express!