FizzBuzz in F# with functional programming

Question

Learning F#, created a somewhat elaborate fizzbuzz-builder implementation to see if I'm starting to "get" F# and thinking functionally:

type FBCase = FBCase of (int * string)

let makeFBCase num = FBCase (num, "")

let unpackFBCase case =
    match case with
    | FBCase (num, str) when str = "" -> num |> string
    | FBCase (_, str) -> str

let fbBuilder (num) (str:string) input =
    match input with
    | FBCase (x, y) when x % num = 0 -> FBCase (x, y+str)
    | _ -> input

let createFBFunc input = fbBuilder (fst input) (snd input)

let createFBPipeline inputList =
    inputList
    |> List.map createFBFunc
    |> List.reduce (>>)

let createFBPattern inputList =
    makeFBCase
    >> (inputList |> createFBPipeline)
    >> unpackFBCase

let fizzBuzz = createFBPattern [(3, "Fizz"); (5, "Buzz")]

let fizzBuzzBaz = createFBPattern [(3, "Fizz"); (5, "Buzz"); (7, "Baz")]

let fizzBuzzBazQuux = createFBPattern [(3, "Fizz"); (5, "Buzz"); (7, "Baz"); (11, "Quux")]

[1..100]
    |> List.iter (fizzBuzz >> printfn "%A")
[1..100]
    |> List.iter (fizzBuzzBaz >> printfn "%A")
[1..100]
    |> List.iter (fizzBuzzBazQuux >> printfn "%A")

Where is it obvious that I'm not thinking functionally? What could I change to make a more idiomatic F#-style program? (Note that I don't really "get" monads or workflows yet, although I'm aware they exist).

Answer 1

I think it all seems quite functional. So nothing to argue about there. I like your use of List.reduce (>>).

---

Instead of the use of the union type FBCase, I would use the tuples directly in a way like this (some of the functions then may need a renaming):

let makeFBCase num = 
    (num, "")

let unpackFBCase (num, txt) =
    match txt with
    | "" -> num |> string
    | _ -> txt

// Instead of input I use the tuple (num, text) to make it possible to call the elements directly
let fbBuilder (denom, str) (num, txt) =
    match num % denom with
    | 0 -> (num, txt + str)
    | _ -> (num, txt)

let createFBPipeline inputList =
    inputList |> List.map fbBuilder |> List.reduce (>>)

let createFBPattern inputList =
    makeFBCase >> (inputList |> createFBPipeline) >> unpackFBCase

let fizzBuzz = createFBPattern [(3, "Fizz"); (5, "Buzz")]

let fizzBuzzBaz = createFBPattern [(3, "Fizz"); (5, "Buzz"); (7, "Baz")]

let fizzBuzzBazQuux = createFBPattern [(3, "Fizz"); (5, "Buzz"); (7, "Baz"); (11, "Quux")]

In this way I don't think you lose any clarity.

---

Although your efforts show a good understanding of details of functional programming, I think you make it all too complicated. The overall task is to map a list of integers to either the integer itself or a text in respect to one or more predicates. That can be done like this:

let fizzBuzz fizzBuzzes data =
    let checkFizzBuzzes value = 
        let result = fizzBuzzes |> List.fold (fun acc (num, txt) -> if value % num = 0 then sprintf "%s%s" acc txt else acc) ""
        match result with
        | "" -> value |> string
        | _ -> result

    data |> List.map checkFizzBuzzes

let data = [1..30]
data |> fizzBuzz [ (3, "Fizz"); (5, "Buzz"); (7, "Baz"); (11, "Quux") ] |> List.iter (printf "%s ")