Philip Schwarz

functional programming scala fp haskell monad flatmap fold recursion map functor left fold folding right fold foldright composition foldleft java foldr for comprehension monoid unit bind foldl kleisli composition function composition side effect séquence applicative list category theory option iterate mathematical induction semigroup cats traverse io monad pure function pure refactoring foldmap applicative functor effectful function iteration left scan scan tail recursion richard bird graham hutton foldable fp in scala scalaz join fish operator effectful filter combinatorial-puzzle n-queens graphics streams recursive datatype recursive function structural induction side-effecting game of life option monad adt algebraic data type scala 3 identity sicp return flatten effect infinite list iterating scanning right scan fold right fold left accumulator trick tail-recursion cats effect polyglot fp will kurt impure function product type point state monad paul chiusano functional effect abstraction combinators martin fowler robert martin kleisli syntactic sugar oo sieve of eratosthenes prime numbers algorithms sealed interface scheme imperative programming combinatorial recursive algorithm lazy eager call-by-name call-by-value performance complexity sergei winitzki induction runar bjarnason alejandro serrano mena list monad identity monad scott wlaschin f# enum sum type martin odersky type classes strict monad composition combine assignment structure and interpretation of computer programs referential transparency typeclass ap composite domain driven design associativity procedural programming raymond smullyan polymorphism monad transformer design structured programming tdd natural transformation functor laws type constructor programming stream lambda calculus lists natural numbers data oriented programming haskell curry combinatorial logic uncle bob gerald jay sussman harold abelson asd: ppp clean code drawing device coordinate logical coordinate frame panel canvas axes coordinates device logical computer graphics oop sealed trait case class text block record improving the design of code code javascript reduce permutations foldm filterm mapm clojure imperative functional programming intercalate intersperse withfilter guard functional-programming scala-3 monadplus list-comprehension do-expression for-comprehension immediate mode retained mode sierpinski sierpinski triangle space leak innermost-reduction outermost reduction evaluation order redex strictness nonstrict lazy evaluation sfoldl foldl' initial segments inits fibonacci tupling loop sequences scanright scanleft scanr scanl nil cons reverse big o notation duality theorems of fold 훩-notation asymptotic analysis duality theorems unison combinator kleisli arrow monadic law of associativity none some functional data structure opaque type f sharp enumeration ddd or type and type extension methods unison language *> <*> validation applicative right-shark right-bird validation state traversable implicits subtype polymorphism compose >=> swap functor composition future fpis mutation lisp substitution model sam halliday higher kinded types apply writer monad design patterns monad laws point-free stye test driven development mappend ocp open closed principle homomorphism kleisli category effectful computation coupling single responsibility principle cohesión kent beck inheritance lambda java 8 traversefilter factorial monadic triad triad iterative algorithm monoidal functions parallelisable collection parallelisable operation parallel collections parallel sequential aggregate reduceleft genuine sieve unfaithful sieve faithful sieve infinite lists java 19 or and mathematical expression brian goetz coproduct sealed class record type pattern matching algebraic data types courage truth potential human purpose pursuit of meaning ethical axiom evil good expediency meaning jordan peterson robert c. martin call-by-need memoized lazy val def val empty-paren method parameterless method uniform access principle square triangle ad-hoc polymorphism class-based polymorphism alternation-based polymorphism liskov substitution principle lsp object-oriented programming expression problem java 17 multiline string jdk17 immutable mutable immutability mutability sequential-access random-access iterable seq listbuffer arraybuffer arraylist linkedlist buffer array collections tree accumulate io actions program structure flowchart impure functions pure functions functional core imperative shell combinatorial-problem prolog logic programming sorting algorithm quicksort doodle divide-and-conquer self-similarity introduction to fp using haskell the science of functional programming mathematical definition formula definition applicative style function functor io applicative list applicative maybe applicative io functor list functor maybe functor function applicative palindrome fmap functor identity law option adt identity function code kata trampolining trampoline monadic code continuation scala language unison abilities ability algebraic effect monadic effect monadic composition block notation do notation binding variable statement imperative program effect composition reader monad functor law algebraic type system dotty givens append-only codebase never broken codebase always live codebase easy renaming cached test results no builds scream operator julie moronuki chris martin effect zoo either io reader writer monadic immutable data type side effecting exception latency try capability symmetry subtype subclassing object oriented programming pimp my library pattern extends syntax class summoner context bound ad hoc polymorphism type class lambda expression closure function literal function expression anonymous function lambda function being without vanity happiness bertrand russell backward composition forward composition non-strict functions strict functions bottom by-name by-value non-strict extreme programming explained red-green-refactor cycle simple design test-driven-development kentbeck extreme programming xp class cohesion math static methods class methods encumbrance mixed-domain cohesion logical cohesion coincidental cohesion object singleton utility >>= nested monads applicative composition monad trait comprehension concatenate tie interceptor hkts semigroupk monoidk option monoid endomonoid smells shotgun surgery divergent change cohesion srp bad smells in code typeclass coherence monoid canonicity monoid laws identity element zero mempty monoid dual environment model abelson sussman inculpability purity totality determinism fp for mortals with scalaz generic code hkt apply3 apply2 map3 map2 for embellished function alvin alexander bartosz milewski universal abstraction composite design pattern mark seemann humane code clean coders science tractatus logico-philosophicus wittgenstein philosophy logic gang of four christopher alexander composite pattern metis pattern language right identity monadic laws left identity hipster code domain modelling combinator birds to mock a mocking bird blackbird combinatory logic tacit code pointful style dynamic polymorphism dependecy inversion object oriented implicit functions kleisli triples better design diagnostics true design qualities design smells code goodness principles functional decomposition testing edsger wybe dijkstra naturality condition endofunctor lifting design smell agile design isomorphism compositionality effects simple io monad fp functional programming scala fp scala foldleft foldright reduce logic monoid functional programming scala demorgan srp fp combinators clojure functional programming refactoring code smell coupling cohesion oaoo dry once and only once xp extreme programming srp single responsibility principle lambda expressions higher order functions expedia worldwide engineering first class functions open closed principle ocp dip lsp software design class inheritance interface inheritance style smalltalk patterns allen holub sandi metz principle open-closed ocp open-closed bertrand meyer software design pri functions functional strams