Copyright © 2016-2018 Fantasyland Institute of Learning. All rights reserved.
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
Boolean parameters are a plague, responsible for non-composable, monolithic functions that never quite do enough, and countless programming bugs:
All boolean parameters should be refactored into functions that effect the change otherwise encoded in the parameter.
This Speaker Engagement Agreement ("Agreement") is made and entered into by and between ____________________ ("Speaker"), whose principal place of residence is __________________________________, and ____________________ ("Organizer"), whose primary mailing address is __________________________________, on ___________ ("Effective Date").
WHEREAS, the Speaker has knowledge, experience, and skills of interest to Organizer, and has been invited by the Organizer to present a talk at ____________________ ("Conference"), held on ___________ ("Conference Dates"); and
WHEREAS, the Organizer desires to have Speaker present a talk to an audience invited by Organizer, and the Speaker, to present this talk to said audience, and to other audiences across the Internet;
| package fpmax | |
| import scala.util.Try | |
| import scala.io.StdIn.readLine | |
| object App0 { | |
| def main: Unit = { | |
| println("What is your name?") | |
| val name = readLine() |
Rust is a systems programming language designed for safety, concurrency, and performance. It has gained popularity for its innovative features that prevent memory-related bugs and allow for low-latency, performant, and efficient computation. Understanding Rust can provide new perspectives and approaches to building robust, concurrent, and high-performance applications.
In this 3-day workshop, attendees will receive a beginner-level introduction to Rust. By the end of the course, all participants, regardless of background, will have a solid entry-level foundation in Rust and be able to confidently use it for various real-world programming tasks.
NOTE: Although no familiarity with Scala is required, special attention will be given to the similarities and differences between Scala and Rust.
| package spartans.zipped | |
| object Zipped { | |
| sealed trait Zippable[-A, -B] { | |
| type Out | |
| def zip(left: A, right: B): Out | |
| } | |
| object Zippable extends ZippableLowPriority { | |
| type Out[-A, -B, C] = Zippable[A, B] { type Out = C } |
| object test { | |
| import scalaz.zio._ | |
| type UserID = String | |
| case class UserProfile(name: String) | |
| // The database module: | |
| trait Database { | |
| val database: Database.Service |
| package net.degoes.zio | |
| trait Sql { | |
| type ColumnName | |
| type TableName | |
| sealed trait Table[+A] | |
| /** | |
| * (SELECT *, "foo", table.a + table.b AS sum... FROM table WHERE cond) UNION (SELECT ... FROM table) |
| package spartan.training | |
| object TheMonadProblem { | |
| sealed trait Parser[+A] { self => | |
| def map[B](f: A => B): Parser[B] = self.flatMap(a => Parser.succeed(f(a))) | |
| def flatMap[B](f: A => Parser[B]): Parser[B] = Parser.FlatMap(self, f) | |
| } | |
| object Parser { | |
| def succeed[A](a: A): Parser[A] = Succeed(a) |
| import zio._ | |
| sealed trait Config[+A] { self => | |
| def ++ [B](that: Config[B])(implicit zippable: Zippable[A, B]): Config[zippable.Out] = | |
| Config.Zipped[A, B, zippable.Out](self, that, zippable) | |
| def || [A1 >: A](that: Config[A1]): Config[A1] = Config.Fallback(self, that) | |
| def ?? (label: String): Config[A] = Config.Labelled(self, label) | |