Today I've just seen this article which described the relevance of SOLID principle in F# development-F# and Design principles  SOLIDAnd while addressing the last one - Dependency inversion principle, the author said:From a functional point of view, these containers and injection concepts can be solved with a simple higher order function, or hole-in-the-middle type pattern which are built right into the language.But he didn't explain it further. So, my question is, how is the dependency inversion related to higher order functions?
How is dependency inversion related to higher-order functions?
functional programming;solid
Dependency Inversion in OOP means that you code against an interface which is then provided by an implementation in an object.Languages that support higher language functions can often solve simple dependency inversion problems by passing behaviour as a function instead of an object which implements an interface in the OO-sense.In such languages, the function's signature can become the interface and a function is passed in instead of a traditional object to provide the desired behaviour. The hole in the middle pattern is a good example for this.It let's you achieve the same result with less code and more expressiveness, as you don't need to implement a whole class that conforms to an (OOP) interface to provide the desired behaviour for the caller. Instead, you can just pass a simple function definition. In short: Code is often easier to maintain, more expressive and more flexible when one uses higher order functions.An example in C#Traditional approach:public IEnumerable<Customer> FilterCustomers(IFilter<Customer> filter, IEnumerable<Customers> customers){    foreach(var customer in customers)    {        if(filter.Matches(customer))        {            yield return customer;        }    }}//now you've got to implement all these filtersclass CustomerNameFilter : IFilter<Customer> /*...*/class CustomerBirthdayFilter : IFilter<Customer> /*...*///the invocation looks like thisvar filteredDataByName = FilterCustomers(new CustomerNameFilter(SomeName), customers);var filteredDataBybirthDay = FilterCustomers(new CustomerBirthdayFilter(SomeDate), customers);With higher order functions:public IEnumerable<Customer> FilterCustomers(Func<Customer, bool> filter, IEnumerable<Customers> customers){    foreach(var customer in customers)    {        if(filter(customer))        {            yield return customer;        }    }}Now the implementation and invocation become less cumbersome. We don't need to supply an IFilter implementation anymore. We don't need to implement classes for the filters anymore.var filteredDataByName = FilterCustomers(x => x.Name.Equals(CustomerName), customers);var filteredDataByBirthday = FilterCustomers(x => x.Birthday == SomeDateTime, customers);Of course, this can already be done by LinQ in C#. I just used this example to illustrate that it's easier and more flexible to use higher order functions instead of objects which implement an interface.