eulerfx

namespace Marvel.Hopac

open System
open Hopac
open Hopac.Extra
open Hopac.Job.Infixes


/// An effectful observer. 
type RxObs<'a> = 'a option -> Job<unit>

eulerfx

namespace Marvel.Hopac

open Hopac
open Hopac.Extra
open Hopac.Job.Infixes
open Hopac.Alt.Infixes

/// Different representation of EagerSeq<'a>
type HopacSeq<'a> = Job<HopacSeqStep<'a>>

eulerfx

There is a great purely functional streaming/IO library in Scala called scalaz-stream. It is itself based upon a Haskell library called machines. They provide powerful abstractions to express compositional effectful computations. These libraries rely on certain type system features in both Scala and Haskell which are unavailable in F# - namely existential types and higher kinds. Higher kinds allow the monad representing the side-effects to be abstracted over. If however we specialize this to a specific monad, we can get around the lack of existentials as well.

Tomas Petricek created a type called asynchronous sequence which provides similar capabilities. The F# AsyncSeq type is declared as follows:

type AsyncSeq<'a> = Async<AsyncSeqInner<'a>>

and AsyncSeqInner<'a> = 
    | Nil
 | Cons of 'a * AsyncSeq&lt;'a&gt;

eulerfx

let jsonStr = """
{
    "itemSize": {
        "width": "hello"
    },
    "tags": ["foo","bar"]
}
"""

let json = JsonValue.Parse jsonStr

eulerfx

type Monoid<'a> = {
    unit : 'a
    op   : 'a -> 'a -> 'a
}

let endo<'a> =
  { unit = id 
    op   = fun (f:'a -> 'a) (g:'a -> 'a) -> f << g }

eulerfx

type MerchantSku = {
    name : string
    price : decimal
}   with 
    static member Name = Lens.create (fun x -> x.name) (fun v x -> { x with name = v})
    static member Price = Lens.create (fun x -> x.price) (fun v x -> { x with price = v})


let sku = { name = "Shaving Cream" ; price = 10m }

eulerfx

type Stream = string
type EventType = string
type ExpectedVersion = int
type EventData = byte[]
type EventMetadata = byte[]
type ResolveLinks = bool
type From = int
type BatchSize = int
type BufferSize = int
type CheckpointStore = (unit -> Async<int option>) * (int -> Async<unit>)

eulerfx

/// port of https://github.com/mausch/Fleece

type ToJsonClass = ToJsonClass

type FromJsonClass = FromJsonClass

type ParseResult<'a> = Choice<'a, string>

module ParseResult =
    

eulerfx

type JsonPath =
    | Top /// The root of the JsonValue.
    | Node of i:int * parent:JsonValue * path:JsonPath /// A node within a JsonValue: a record property or an array item.

type JsonZipper = JsonZipper of current:JsonValue * path:JsonPath


module JsonCursor =
    
    let private expectRecord() = failwith "Invalid cursor state: JsonValue.Record expected!"   

eulerfx

Synchronous

• () -> (() -> a) - sequence (IEnumerable)

with arrows reversed:

• (a -> ()) -> () - observable (IObservable)

Everything is fine and we have duality between pull and push. In particular, () -> a is dual to a -> ().