aitoroses

module type Functor = {
  type t('a);
  let map: (t('a), 'a => 'b) => t('b);
};

module type Monad = {
  type t('a);
  let return: 'a => t('a);
  let flatMap: (t('a), 'a => t('b)) => t('b);

aitoroses

Dependency Injection in Functional Programming

There exist several DI frameworks / libraries in the Scala ecosystem. But the more functional code you write the more you'll realize there's no need to use any of them.

A few of the most claimed benefits are the following:

• Dependency Injection.
• Life cycle management.
• Dependency graph rewriting.

aitoroses

type Env
  = { hello :: String }

newtype AppM a
  = AppM (ReaderT Env Aff a)

runAppM ∷ Env → AppM ~> Aff
runAppM env (AppM m) = runReaderT m env

aitoroses

// this is the background code...

// listen for our browerAction to be clicked
chrome.browserAction.onClicked.addListener(function (tab) {
	// for the current tab, inject the "inject.js" file & execute it
	chrome.tabs.executeScript(tab.ib, {
		file: 'inject.js'
	});
});

aitoroses

module Main where

import Prelude

import Control.Monad.Reader (Reader, runReader, ReaderT(..), runReaderT, ask, class MonadAsk)
import Effect (Effect)
import Effect.Class (class MonadEffect, liftEffect)
import Effect.Console (log)

---------------------------------------------------------

aitoroses

module AsyncEx
open System

type Async<'a> with
  member this.ToObservable() =
    { new IObservable<_> with
        member x.Subscribe(o) =
          if o = null then nullArg "observer"
          let cts = new System.Threading.CancellationTokenSource()
          let invoked = ref 0

aitoroses

namespace ReaderM

type ReaderM<'d,'out> = 
    'd -> 'out

module Reader =

    // basic operations

    let run dep (rm : ReaderM<_,_>) =

aitoroses

module Arg = {
  type arg(_) =
    | Arg(argument('a)): arg('a)
  and argument('a) =
    | Scalar({
        name: option(string),
        description: option(string),
        validator: 'a => bool,
      })
  and arglist(_, _) =

aitoroses

module Eff: {
  type t('t, 'a);
  let make: (unit => 'a) => t('t, 'a);
  let run: t('t, 'a) => 'a;
  let map: (t('t, 'a), 'a => 'b) => t('t, 'b);
  let join: t('t, t('t, 'a)) => t('t, 'a);
  let bind: (t('t, 'a), 'a => t('t, 'b)) => t('t, 'b);
} = {
  type t('t, 'a) = unit => 'a;
  let make: (unit => 'a) => t('t, 'a) = m => m;

aitoroses

(* Purely functional I/O in Ocaml via the Free monad.
 * by Ricky Elrod <relrod@haskell.org>.
 *
 * This is free and unencumbered software released into the public domain.
 *
 * Anyone is free to copy, modify, publish, use, compile, sell, or
 * distribute this software, either in source code form or as a compiled
 * binary, for any purpose, commercial or non-commercial, and by any
 * means.
 *