Search content

Series: From F# to Clojure

Read the From F# to Clojure articles in order.

  1. Part 1
    3 min read

    From F# to Clojure > 1: Forms and the REPL

    A practical bridge from F# to Clojure, translating familiar functional ideas while learning Lisp syntax, dynamic values, and the REPL.

  2. Part 2
    2 min read

    From F# to Clojure > 2: Immutable Data Without Static Types

    Translate F# records, lists, maps, and immutable updates into Clojure's persistent collections and data-oriented style.

  3. Part 3
    2 min read

    From F# to Clojure > 3: Functions, Bindings, and Destructuring

    Carry F# function composition into Clojure while adapting to explicit parameter vectors, local bindings, and map destructuring.

  4. Part 4
    3 min read

    From F# to Clojure > 4: Sequence Pipelines

    Translate F# collection pipelines into Clojure's sequence functions, lazy values, and thread-last macro.

  5. Part 5
    3 min read

    From F# to Clojure > 5: Namespaces and REPL-Driven Development

    Move from F# projects and modules to Clojure namespaces, classpaths, Vars, and a live REPL-driven development loop.

  6. Part 6
    3 min read

    From F# to Clojure > 6: From Discriminated Unions to Open Polymorphism

    Compare F# discriminated unions and interfaces with Clojure protocols, records, and data-driven multimethod dispatch.

  7. Part 7
    3 min read

    From F# to Clojure > 7: State and Concurrency

    Move from F# reference cells and synchronization to Clojure's explicit identity model with atoms, refs, and transactions.

  8. Part 8
    2 min read

    From F# to Clojure > 8: From Pipelines to Transducers

    Take the F# pipeline instinct further by separating Clojure transformations from their input, output, and reduction context.

  9. Part 9
    3 min read

    From F# to Clojure > 9: From Quotations to Macros

    Contrast F# quotations with Clojure's code-as-data model, then build safe macros with quoting, splicing, and hygienic names.