Joseph Price joprice

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

Here is a fast explanation on this study for Freek to improve compile-time:

https://github.com/ProjectSeptemberInc/freek/blob/optim/cop/src/main/scala/CoproductK.scala#L14-L34

In Freek, Higher-Kinded Coproduct was based on Shapeless HList/Coproduct representation like:

sealed trait CoproductK[A] extends Product with Serializable

sealed trait CNilK[A] extends CoproductK[A]

	(* An experiment with implementing early return in F#. Initial examples work, but I do not know whether it is really correct! *)

	/// A computation which runs to completion and produces 'r or returns an 'a early, short-circuiting some steps.
	type R<'a,'r> =
	private
	\| Done of 'r
	\| EarlyReturn of 'a
	\| Zero
	\| Effect of (unit -> R<'a,'r>)

	import SwiftUI

	struct ContentView: View {
	@State var path: [String] = []

	func navigationButton(value: String) -> some View {
	NavigationButton {
	path.append(value)
	} label: {
	Text("NavigationButton")

	#! /bin/bash -e
	#
	# clean up everything in CACHE_DIR last accessed more than DAYS days ago.
	# also removes files with bogus timestamps in the future.
	#
	# -----------------------------------------------------------------------
	# Copyright 2021 Todd Derr ([email protected])
	#
	# Licensed under the Apache License, Version 2.0 (the "License");
	# you may not use this file except in compliance with the License.

	// The engine interface and helpers

	type IEngine<'a,'b> =
	abstract member Capacity : int // Does not depend on 'a or 'b; just an example
	// Some other stuff here possible depending on 'a and 'b

	/// A function which works on any engine polymorphically and returns a result of type 'r'. Needed because
	/// F# does not support higher-ranked types (not the same as HKT!) in regular functions. This does work in members.
	type EngineFunction<'r> =
	abstract member Apply : IEngine<'a,'b> -> 'r

	import scala.util.Try

	object PathSerializer {

	trait SerDe[A] {
	// By using a path dependent type, we can be sure can deserialize without wrapping in Try
	type Serialized
	def ser(a: A): Serialized
	def deser(s: Serialized): A
	// If we convert to a generic type, in this case String, we forget if we can really deserialize

	//
	// PSPDFFastEnumeration.h
	// PSPDFFoundation
	//
	// PSPDFKit is the leading cross-platform solution for integrating PDFs into your apps: https://pspdfkit.com.
	// Try it today using our free PDF Viewer app: https://pdfviewer.io/
	//
	// This file is MIT licensed.

	@protocol PSPDFFastEnumeration <NSFastEnumeration>

	import scala.concurrent.Future
	import scala.concurrent.ExecutionContext.Implicits.global
	import java.util.Date
	import java.text.SimpleDateFormat
	import fs2._

	// id and gender should really be more strongly-typed, but
	// this is just a demo...
	case class Person(id: Int,
	firstName: String,

	(*
	We don't really care about the data constructors here
	but they are needed, cf:
	https://sympa.inria.fr/sympa/arc/caml-list/2013-10/msg00190.html
	*)
	type zero = Zero
	type 'a succ = Succ

	(*
	[] has length 0