https://github.com/thautwarm/fstan
Higher abstraction infrastructures in F#(ad-hoc polymorphism, subtypeclassing, monad, hkt...), exactly what we've dreamed about for so long
https://github.com/thautwarm/fstan
functional-programming higher-kinded-types monad monoids subtypeclassing typeclasses
Last synced: 3 months ago
JSON representation
Higher abstraction infrastructures in F#(ad-hoc polymorphism, subtypeclassing, monad, hkt...), exactly what we've dreamed about for so long
- Host: GitHub
- URL: https://github.com/thautwarm/fstan
- Owner: thautwarm
- License: apache-2.0
- Created: 2018-12-26T08:09:10.000Z (almost 7 years ago)
- Default Branch: master
- Last Pushed: 2019-06-02T01:29:04.000Z (over 6 years ago)
- Last Synced: 2025-06-09T06:03:53.251Z (5 months ago)
- Topics: functional-programming, higher-kinded-types, monad, monoids, subtypeclassing, typeclasses
- Language: F#
- Homepage:
- Size: 76.2 KB
- Stars: 43
- Watchers: 5
- Forks: 4
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# FSTan
Exactly a full-featured and practical implementation typeclasses and higher kinded types in F#.
For manuals check [Guide.md](https://github.com/thautwarm/FSTan/blob/master/Guide.md), where you'll be told how to use these concise typeclasses, higher kinded types and constraints.
## Motivation and Features
There are also other similar implementations in FSharp like `Higher` and `FSharpPlus`, but they're not able to provide all the features listed below, which motivate me to create a better one:
- Support instance resolution.
- Support ad-hoc polymorphism.
- Support to create a typeclass and add constraints to it.
- Support subtypeclassing.
- Support to directly access type constructor.
- Support default implementations for typeclass.
- All above operations are quite lightweighted and not implemented in a magic way.
Yes, exactly, it's a what many and I have dreamed about for so long.
## Limitation
1. The performance might hurt in some scenarios, for each the datatype works with
higher kinded types have to be upcasted to an unique abstract class, for instance,
`maybe<'a>` has to be casted to `hkt`.
2. For some builtin datatypes cannot be interfaced with `hkt`, an extra wrapper class is
required to work with higher kined types.
For instance, interface type `listData<'a>` is required for the builtin `List<'a>`.
You can use `wrap` and `unwrap` to transform datatypes from `List<'a>` to `hkt,'a>`, vice versa.
```FSharp
module List' = List
type List'<'a> = List<'a>
type mkList<'L>() =
inherit monad>()
static member wrap<'a> (x : List'<'a>): hkt, 'a> =
{wrap = x} :> _
static member unwrap<'a> (x : hkt, 'a>): List'<'a> =
(x :?> _).wrap
default si.bind<'a, 'b> (m: hkt, 'a>) (k: 'a -> hkt, 'b>): hkt, 'b> =
wrap <| List'.collect (unwrap << k) (unwrap m)
default si.pure'<'a> (a: 'a): hkt, 'a> = wrap <| [a]
interface show> with
member si.show (x: hkt, 'a>) =
let x = unwrap x
x.ToString()
and listData<'L, 'a> =
{wrap : List'<'a>}
interface hkt, 'a>
// create a concrete List type
type ListSig() =
// default implements following type classes:
// - monad (functor and applicative are implemented simultaneously)
// - show
inherit mkList()
type list<'a> = hkt, 'a>
let test() =
let listm: _ list = Do {
let! x = wrap [1, 2, 3]
wrap [x]
}
// listm : resolved to be list
let f (x: int) : string = ""
fmap f listm
// return value is resolved to be list
```
3. Cannot implement instance for datatypes that are not constructed by a type constructor.
For instance, you cannot implement any typeclass for all primitives types like integers, floats and so on, unless you wrap them with an `Identity` type constructor.