Post History

How to write a function that only accepts a list of `Error string` `Results` in F# on the level of types?

For example, given a `mergeErrors` function where input is always a list of `Error string`s,


```fsharp
let es = [ Error 1; Error 2; Error 3 ]

let mergeErrors<'a> (errors: Result<'a,int> list) : Result<'a,int list> =
    errors
    |> List.map (function | Error e -> e)
    |> Error

mergeErrors (es: Result<int,int> list)
//=> Error [1; 2; 3]
```

this will always blow up during runtime. Was wondering if there is a way to force failure to compile time?

---

### Context

In my script, there is a `Result<'a, string> seq seq` type where each constituent `Result<'a, string> seq` needs to be flattened:

+ if there are `Error`s, then `Ok`s can be discarded, and an `Error concatenatedStrings` should be returned
+ if all is `Ok`, then they are merged depending of the shape of `'a`

My naive solution is to

```fsharp
let filterError (row: Result<'a, string> seq) =
    row 
    |> Seq.filter (function
        | Error _ -> true 
        | _       -> false)
    
let mergeErrors inputFromFilterError =
    // ...

```

This is almost surely the wrong approach (and found the F# For Fun and Profit's ["Map and Bind and Apply, Oh my!" series][1] while researching for an answer), but I'm still curious.


  [1]: https://fsharpforfunandprofit.com/posts/elevated-world-4/#series-contents