Functional programming in Go (fp-go)

From the beginning when golang was released i always faced couple of missing bits:

• Generics
• Functional programming

Then golang v1.18 came out with generics.
This suddenly unlocked a lot of new ways of writing code in golang.
In detail now it's possible to easily write generic functions that help you to write code in a more functional way.

For this purpose i started an open source project that aims to fill this remaining gap of the language.

repeale / fp-go

fp-go is a collection of Functional Programming helpers powered by Golang 1.18+ generics.

fp-go

Fp-go is a collection of Functional Programming helpers powered by Golang 1.18+ generics.

Inspired by

• fp-ts

Contents

• Install
• Features
  • Currying
  • Variations
• Helpers
  • Every
  • Filter
  • Flat
  • FlatMap
  • Map
  • Reduce
  • Some
  • Compose
  • Pipe
  • Curry
• Structs
  • Option
  • Either

Install

Requires go 1.18+

go get github.com/repeale/fp-go

Features

• Currying
• Variations

Currying

By default! Data last!

func isPositive(x int) bool {
    return x > 0
}

func main() {
    filterPositive := fp.Filter(isPositive)
    numbers := []int{1, 2, 3, 4, 5}

    positives := filterPositive(numbers)
}

Variations

Variations allows you to get different parameters in the callback function so that you get only only what is really needed.

Default
WithIndex
WithSlice

Default

Only the current item is available:

fp.Map[int, string](func(x int) { ... })

WithIndex

Current…

View on GitHub

The project is already in a good shape that allows you to write good functional code. But it's still under development and i'm looking for help to expand the collection of helpers.

Here you could find the list of Helpers with examples.

Couple of core pillars of the library:

• Currying
• Variations

Currying

By default, data are always at last. This allow to write upfront reusable code that can run with the actual data only when needed.

// Example with Map helper

func int64toInt(x int64) string {
    return strconv.FormatInt(x, 10)
}

// ...

data := []int64{1, 2, 3}

fp.Map(int64toInt)(data)

// => []string{"1", "2", "3", "4"}

Variations

Each helper come with variations. This allow you to use the right implementation for your use case without having to deal with unused code. The full doc could be found here .

// Available variations

// Default
fp.Map[int, string](func(x int) { ... })

// *WithIndex
fp.MapWithIndex[int, string](func(x int, i int) { ... })

// *WithSlice
fp.MapWithSlice[int, string](func(x int, i int, xs: []int) { ... })

Looking forward for contributors, feedbacks and more new features to come i really hope you will enjoy using this package!