Functions with generic parameter types

by

Overloading is typically the bugaboo of type-inferenced languages (at least when, like F#, the type system isn’t powerful enough to contain type-classes). There are a number of choices you have in F#:

  • Use overloading on methods (members of a type), in which case overloading works much like as in other .Net languages (you can ad-hoc overload members, provided calls can be distinguished by the number/type of parameters)
  • Use “inline”, “^”, and static member constraints for ad-hoc overloading on functions (this is what most of the various math operators that need to work on int/float/etc.; the syntax here is weird, this is little-used apart from the F# library)
  • Simulate type classes by passing an extra dictionary-of-operations parameter (this is what INumeric does in one of the F# PowerPack libraries to generalize various Math algorithms for arbitrary user-defined types)
  • Fall back to dynamic typing (pass in an ‘obj’ parameter, do a dynamic type test, throw a runtime exception for bad type)

For your particular example, I would probably just use method overloading:

type MathOps =
    static member sqrt_int(x:int) = x |> float |> sqrt |> int
    static member sqrt_int(x:int64) = x |> float |> sqrt |> int64

let x = MathOps.sqrt_int 9
let y = MathOps.sqrt_int 100L

More Related Contents:

  1. Generic higher order function
  2. How to write a function for generic numbers?
  3. Does F# have generic arithmetic support?
  4. How do I write this member constraint in F#?
  5. Why doesn’t the example compile, aka how does (co-, contra-, and in-) variance work?
  6. Why can’t the C# constructor infer type?
  7. Why does a generic method inside a trait require trait object to be sized?
  8. C# 3.0 generic type inference – passing a delegate as a function parameter
  9. TypeScript: self-referencing return type for static methods in inheriting classes
  10. Matching a generic parameter to an associated type in an impl
  11. Generic Functions in Go
  12. Generic repository in ASP.NET Core without having a separate AddScoped line per table in Startup.cs?
  13. F# generics / function overloading syntax
  14. Why can’t `&(?Sized + Trait)` be cast to `&dyn Trait`?
  15. Why can’t I add a blanket impl on a trait with a type parameter?
  16. Generics: Why can’t the compiler infer the type arguments in this case?
  17. How can I make a generic type optional?
  18. What does the question mark mean in a type parameter bound?
  19. Calling a static method from a generic constraint Dart
  20. Generic NSOperation subclass loses NSOperation functionality
  21. Iterable cannot confirm generic T in function
  22. Collections.emptyList() returns a List?
  23. How to get generic parameter class in Kotlin
  24. Swift equivalent for MIN and MAX macros
  25. Why is F#’s type inference so fickle?
  26. How to get actual type arguments of a reified generic parameter in Kotlin?
  27. Writing a generic function that takes an iterable container as parameter in Rust
  28. Cannot use Java 8 method with lambda arguments without specifying type arguments
  29. What is the cited problem with using generic type parameters in trait objects?
  30. How to call a named constructor from a generic function in Dart/Flutter

Leave a Comment