fp-go Pipe and Flow

import F "github.com/IBM/fp-go/v2/function"

// PipeN threads a value through N functions
result := F.Pipe3(initialValue, step1, step2, step3)

// FlowN returns func(T0) TN
pipeline := F.Flow3(step1, step2, step3)
result := pipeline(initialValue)

// WRONG — var is allocated even if never called
var processUser = F.Flow2(getName, strings.ToUpper)

// CORRECT — zero cost until called; also more composable
func processUser() func(User) string {
    return F.Flow2(getName, strings.ToUpper)
}

// WRONG — explicit argument
func isAdult(u User) bool { return getAge(u) > 18 }

// CORRECT — point-free, returns typed Predicate
func isAdult() P.Predicate[User] {
    return F.Flow2(getAge, N.MoreThan(18))
}

import (
    F "github.com/IBM/fp-go/v2/function"
    N "github.com/IBM/fp-go/v2/number"
    P "github.com/IBM/fp-go/v2/predicate"
    EM "github.com/IBM/fp-go/v2/endomorphism"
    A "github.com/IBM/fp-go/v2/array"
)

// Predicate — point-free using N.MoreThan
func isAdult() P.Predicate[User] {
    return F.Flow2(getAge, N.MoreThan(18))
}

// Endomorphism — self-transformation
func doubleAll() EM.Endomorphism[[]int] {
    return A.Map[int, int](N.Mul(2))
}

N.MoreThan(18)   // func(int) bool   — x > 18
N.LessThan(100)  // func(int) bool   — x < 100
N.Mul(2)         // func(int) int    — x * 2
N.Add(1)         // func(int) int    — x + 1

// WRONG — forces reader monad on a pure computation
func adultNames(users []User) RD.Reader[Env, string] {
    return F.Pipe1(
        RD.Of[Env](users),
        RD.Map[Env](pureTransform),
    )
}

// CORRECT — pure; no environment needed
func adultNames() func([]User) string {
    return F.Flow2(
        A.FilterMap(toAdultName()),
        A.Intercalate(S.Monoid)(","),
    )
}

import (
    F "github.com/IBM/fp-go/v2/function"
    A "github.com/IBM/fp-go/v2/array"
    O "github.com/IBM/fp-go/v2/option"
    N "github.com/IBM/fp-go/v2/number"
    P "github.com/IBM/fp-go/v2/predicate"
    S "github.com/IBM/fp-go/v2/string"
)

// isAdult — point-free predicate
func isAdult() P.Predicate[User] {
    return F.Flow2(getAge, N.MoreThan(18))
}

// toAdultName — User -> Option[string]: Some(name) if adult, None otherwise
func toAdultName() func(User) O.Option[string] {
    return F.Flow2(
        O.FromPredicate(isAdult()),  // User -> Option[User]
        O.Map(getName),              // Option[User] -> Option[string]
    )
}

// adultNames — pure pipeline, no reader monad needed
func adultNames() func([]User) string {
    return F.Flow2(
        A.FilterMap(toAdultName()),       // []User -> []string
        A.Intercalate(S.Monoid)(","),     // []string -> string
    )
}

import (
    F  "github.com/IBM/fp-go/v2/function"
    RD "github.com/IBM/fp-go/v2/reader"
)

type Env struct {
    Users map[string]User
}

// Leaf accessor (or a generated lens' .Get)
func getUsers(e Env) map[string]User { return e.Users }

// lookupUser is curried: func(id string) func(map[string]User) User

// Kleisli arrow: string -> Reader[Env, User], built from a pure projection
func fetchUser(id string) RD.Reader[Env, User] {
    return RD.Asks(F.Flow2(getUsers, lookupUser(id)))
}

// reader.Map inside Flow — no env name, clean point-free.
// NOTE: RD.Map returns an Operator over Reader values, so the PRECEDING step in the
// Flow must already produce a Reader. A plain func([]User) []string composed with
// RD.Map does not type-check.
func renderUsers() func(string) RD.Reader[Env, string] {
    return F.Flow2(
        fetchTeam,                   // string -> Reader[Env, []User]
        RD.Map[Env](F.Flow2(         // Reader[Env, []User] -> Reader[Env, string]
            A.Map(getName),
            A.Intercalate(S.Monoid)(","),
        )),
    )
}

// Pipe with reader monad — env access required
func enrichedUser(id string) RD.Reader[Env, EnrichedUser] {
    return F.Pipe3(
        fetchUser(id),
        RD.Chain(fetchProfile),
        RD.Chain(fetchPermissions),
        RD.Map[Env](combineToEnriched),
    )
}

import (
    F  "github.com/IBM/fp-go/v2/function"
    L  "github.com/IBM/fp-go/v2/optics/lens"
    RD "github.com/IBM/fp-go/v2/reader"
)

// Lenses — generated (`// fp-go:Lens`) or built once with L.MakeLens.
// lens.Set already has the setter shape func(T) func(S) S — no hand-written setters.
var (
    userIDLens = L.MakeLens(
        func(s RequestState) string { return s.UserID },
        func(s RequestState, v string) RequestState { s.UserID = v; return s },
    )
    profileLens = L.MakeLens(
        func(s RequestState) Profile { return s.Profile },
        func(s RequestState, v Profile) RequestState { s.Profile = v; return s },
    )
    permsLens = L.MakeLens(
        func(s RequestState) Perms { return s.Perms },
        func(s RequestState, v Perms) RequestState { s.Perms = v; return s },
    )
)

// Kleisli arrows — named functions, never inline:
//   fetchProfile: func(userID string) Reader[Env, Profile]
//   fetchPerms:   func(p Profile)     Reader[Env, Perms]

// Pipeline — returned as a function, not a var
func buildRequestState(userID string) RD.Reader[Env, RequestState] {
    return F.Pipe3(
        RD.Do[Env](RequestState{}),
        RD.LetTo[Env](userIDLens.Set, userID),
        RD.Bind(profileLens.Set, F.Flow2(userIDLens.Get, fetchProfile)),
        RD.Bind(permsLens.Set, F.Flow2(profileLens.Get, fetchPerms)),
    )
}