Course

CS-210: Functional programming

Lectures in this course (70)

Exceptional Monads

Covers exceptions in Scala, handling them with try/catch and scala.util.Try, and discusses whether Try is a monad.

Structural Induction on Trees

Introduces structural induction on trees, demonstrating with IntSets and their laws.

Lazy Lists: Delayed Evaluation and Efficient Computation

Covers Lazy Lists, delaying computation for efficiency in combinatorial search.

Lazy Evaluation

Explores lazy evaluation in functional programming, focusing on Scala's implementation of lazy lists.

Computing with Infinite Sequences

Introduces lazy lists for computing infinite sequences like prime numbers.

Water Pouring Problem: Strategy and Code

Covers the Water Pouring Problem strategy and Scala code implementation.

Contextual abstraction: Functional Programming

Explores contextual abstraction in programming through function parameters and implicit parameters to reduce boilerplate code.

Type-Directed Programming: Using Clauses

Covers using clauses, context bounds, given instances, and implicit parameter resolution in Scala.

Type Classes: Basics and Implementation

Covers the basics of type classes in Scala, implementation examples, and advantages over class extension.

Abstract algebra and type classes

Covers abstract algebra concepts using type classes in Scala, including defining monoids, generalizing reduce functions, and typeclass laws.

Context Passing: Execution Contexts

Covers context passing vs type classes, execution contexts, tamper-proofing, and the importance of specificity in Scala.

Implicit Function Types

Explores implicit function types and their application in a conference management system, discussing the trade-off between types and terms in implicit parameters.

Functions and state

Explores functions, state, rewriting, and stateful objects in programming.

Identity and Change

Explores how assignments affect the equivalence between expressions in programming.

Loops: Control Statements and Functions

Covers modeling control statements with functions in Scala, including while loops, repeat loops, and for-loops translation.

Discrete Event Simulation

Covers discrete event simulation using digital circuits, base components, complex components, and simulation implementation.

Imperative Event Handling: The Observer Pattern

Introduces the widely used Observer Pattern for views to react to model changes, with examples of Publisher, Subscriber, and a Consolidator.

Functional Reactive Programming

Covers the basics of Functional Reactive Programming, including signal aggregation, fundamental operations, constant and variable signals, and signal interpretation.

A Simple FRP Implementation

Covers the simple implementation of Signals and Vars in functional reactive programming, including dependency maintenance and implicit function types.

Functional Reactive Programming Basics

Covers the basics of functional reactive programming, including APIs, implementation details, creating signals, and evaluating signals.