导入单孢体./单子”;

导出类继承单孢体 {
  // 纯 :: a -> 要么 a
  纯 = (值) => {
    返回新 (价值)
  }

  // flatMap :: # 要么 a -> (a -> 要么 b) -> 要么 b
  flatMap = f => 
    这.is左 () ? 
    这样的: 
    f(这.值)

  is左 = () => 这.构造函数.name === '左'
}

导出类左扩展要么 {
  构造函数(值){
    超级();
    这.Value = Value;
  }

  to字符串 () {
    返回“左($ {.值})”
  }
}

导出类正确的扩展了要么 {
  构造函数(值){
    超级();
    这.Value = Value;
  }

  to字符串 () {
    返回的权利($ {.值})”
  }
}

// attempt :: (() -> a) -> M a 
要么.attempt = f => {
    尝试{
      返回 新 正确的(f())
    } catch(e) {
      返回 新 左(e)
    }
}
要么.纯 = (新 左(null)).纯

从monad导入monad

类(单轴):
  # 纯 :: a -> 要么 a
  @staticmethod
  def纯(价值):
    返回正确的(值)

  # flat_map :: # 要么 a -> (a -> 要么 b) -> 要么 b
  Def flat_map (自我, f):
    如果自我.is_left:
      回归自我
    其他:
      返回f(自我.值)

类左():
  Def __init__(自我, 值):
    自我.Value = Value
    自我.is_left = True

类正确():
  Def __init__(自我, 值):
    自我.Value = Value
自我.is_left = False

require_relative”./单轴的

class 要么 < 单孢体

  Attr_accessor:is_left, value

  # 纯 :: a -> 要么 a
  def自我.纯(值)
    正确的.新(值)
  结束

  # 纯 :: a -> 要么 a
  def纯(值)
    自我.class.纯(值)
  结束

  # flat_map :: # 要么 a -> (a -> 要么 b) -> 要么 b
  def flat_map (f)
    如果is_left
      自我
    其他的
      f.调用(值)
    结束
  结束
结束

class 左 < 要么
  def初始化(值)
    @Value = Value
    @is_left = true
  结束
结束

class 正确的 < 要么
  def初始化(值)
    @Value = Value
    @is_left = false
  结束
结束

进口的基础

enum 要么 {
  例左(一个)
  情况下正确的(B)
  static func 纯(_ value: C) -> 要么 {
    返回 要么.(价值)
  }
  
  func flatMap(_ f: (B) -> 要么) -> 要么 {
    切换自{
    情况下 .左(让x):
      返回 要么.左(x)
    情况下 .正确的(让x):
      返回f (x)
    }
  }
  
  func map(f: (B) -> C) -> 要么 {
    回归自我.flatMap { 要么.纯(f(0)美元)}
  }
}

包的单子

密封特性My要么[+E， +A] {
  def flatMap[EE >: E, B](f: A => My要么[EE, B]): My要么[EE, B] =
    单子(My要么 (EE, ?]].flatMap(这)(f)

  def map[EE >: E, B](f: A => B): My要么[EE, B] =
    单子(My要么 (EE, ?]].map () (f)
  
}
情况下类My左[E](E: E)扩展了My要么[E, Nothing]
情况下类My正确的[A](A: A)扩展了My要么[Nothing, A]

// ...

隐式def my要么单孢体[E] = 新 单孢体[My要么]; ?]] {
  def纯 [A](A: A) = My正确的(A)

  def flatMap[A, B](ma: My要么[E, A])(f: A => My要么[E, B]): My要么[E, B] = ma match {
    情况下 My左(a) => My左(a)
    情况下 My正确的(b) => f(b)
  }
}

导入单孢体./单子”;
import {要么, 左, 正确的} from './ ';
导入{none, 一些}./选项”;

导出类未来扩展单孢体 {
  // 构造函数 :: ((要么 err a -> void) -> void) -> 未来 (要么 err a)
  构造函数(f) {
    超级();
    这.订阅用户= [];
    这.Cache = none;
    f(这.回调)
  }

  // callback :: 要么 err a -> void
  callback = (值) => {
    这.缓存= 新 一些(值)
    而(这.用户.长度){
      Const订阅者=此.用户.转变();
      订户(值)
    }
  }

  // subscribe :: (要么 err a -> void) -> void
  subscribe = (订阅者) => 
    (这.Cache ===无 ? 这.用户.Push(订阅者):订阅者(此).缓存.值))

  to承诺 = () => 新 承诺(
    (resolve, reject) =>
      这.订阅(val => val.is左 () ? 拒绝(val.值):解析(val.值))
  )

  // 纯 :: a -> 未来 a
  纯净=未来.纯

  // flatMap :: (a -> 未来 b) -> 未来 b
  flatMap = f =>
    新未来(
      cb => 这.订阅(value => value.is左 () ? Cb (值): f(值).值).订阅(cb))
    )
}

未来.异步 = (nodeFunction， ...args) => {
  返回 新未来(cb => 
    nodeFunction (...args, (err, data) => err ? cb(新 左(err)): cb(新 正确的(data)))
  );
}

未来.纯 = value => 新未来(cb => cb(要么.纯(值)))

// 遍历 :: [a] -> (a -> 未来 b) -> 未来 [b]
未来.遍历 = 列表 => f =>
  列表.减少(
    (acc, elem) => acc.flatMap(values => f(elem).地图(value => [...值,值])), 
    未来.纯([])
  )

从monad导入monad
从选项导入nil，一些
from either import either, 左, 正确的
从functools导入reduce
进口线程

类未来(单轴):
  # __init__ :: ((要么 err a -> void) -> void) -> 未来 (要么 err a)
  Def __init__(自我, f):
    自我.订阅者= []
    自我.缓存= nil
    自我.信号量=线程.Bounded信号量 (1)
    f(自我.回调)

  # 纯 :: a -> 未来 a
  @staticmethod
  def纯(价值):
    返回未来(lambda cb: cb.纯(值)))

  defexec (f, cb):
    试一试:
      数据= f()
      cb(右)(数据)
    Exception as err:
      cb(左(err))

  Def exec_on_thread(f, cb):
    穿线.线程(=未来的目标.执行，参数=[f, cb])
    t.开始 ()

  def异步(f):
    返回未来(lambda cb:未来.exec_on_thread (f, cb))

  # flat_map :: (a -> 未来 b) -> 未来 b
  Def flat_map (自我, f):
    返回未来(
      Lambda cb: 自我.订阅(
        Lambda值:cb(值) 如果(值).f(value . left.值).订阅(cb)
      )
    )

  # 遍历 :: [a] -> (a -> 未来 b) -> 未来 [b]
  def导线(加勒比海盗):
    返回lambda f:
      Lambda acc, elem: acc.flat_map (
        Lambda值:f(elem).地图(
          Lambda值:values + [value]
        )
      )， 加勒比海盗，未来.纯([]))

  # callback :: 要么 err a -> void
  Def callback(自我, 值):
    自我.信号量.获得()
    自我.缓存= 一些(值)
    而(len(自我.用户) > 0):
      Sub = 自我.用户.流行(0)
      穿线.线程(目标=子,arg游戏=(值))
      t.开始 ()
    自我.信号量.释放 ()
  
  # subscribe :: (要么 err a -> void) -> void
  Def 订阅(自我, 订阅者):
    自我.信号量.获得()
    如果(自我.缓存.定义):
      自我.信号量.释放 ()
      订户(自我.缓存.值)
    其他:
      自我.用户.追加(用户)
自我.信号量.释放 ()

require_relative”./单轴的
require_relative”./不是的
require_relative”./选项”

class 未来 < 单孢体
  Attr_accessor:订阅者，:缓存，:信号量

  # initialize :: ((要么 err a -> void) -> void) -> 未来 (要么 err a)
  def初始化(f)
    @订阅者= []
    @缓存= 没有美元
    @信号量 =队列.新
    @信号量.推动(零)
    f.调用(方法(回调))
  结束

  # 纯 :: a -> 未来 a
  def自我.纯(值)
    未来.新(-> (cb) { cb.电话(.纯(值))})
  结束

  def自我.异步(f * args)
    未来.新(-> (cb) {
      线程.新{
        开始
          cb.电话(右.新(f.电话(* args)))
        rescue => e
          cb.电话(左.新(e))
        结束  
      }
    })
  结束

  # 纯 :: a -> 未来 a
  def纯(值)
    自我.class.纯(值)
  结束

  # flat_map :: (a -> 未来 b) -> 未来 b
  def flat_map (f)
    未来.新(-> (cb) { 
      订阅(-> (值) {
        如果(值.is_left)
          cb.调用(值) 
        其他的
          f.调用(值.值).订阅(cb)
        结束
      }) 
    })
  结束

  # 遍历 :: [a] -> (a -> 未来 b) -> 未来 [b]
  def自我.遍历(加勒比海盗)
    加勒比海盗.减少(未来.Pure ([])) do |acc, elem|
      acc.flat_map (-> (values) {
        f.调用(elem).地图(-> (值) { values + [value] })
      })
    结束
  结束

  # callback :: 要么 err a -> void
  def回调(值)
    信号量.流行
    自我.缓存= 一些.新(值)
    而(用户.count > 0)
      Sub = 自我.用户.转变
      线程.新{
        sub.调用(值)
      }
    结束
    信号量.推动(零)
  结束
  
  # subscribe :: (要么 err a -> void) -> void
  def订阅(用户)
    信号量.流行
    如果(自我.缓存.定义)
      信号量.推动(零)
      订阅者.调用(缓存.值)
    其他的
      自我.用户.推动(用户)
      信号量.推动(零)
    结束
  结束
结束

进口的基础

let background = DispatchQueue(label: "background"， attributes: .并发)

class 未来 {
  typealias 回调 = (要么) -> Void
  
  var 用户: Array<回调> = Array<回调>()
  var 缓存: Maybe<要么> = .没有一个
  var 信号量 = Dispatch信号量(值为1)

  lazy var callback: callback = {value in
    自我.信号量.wait ()
    自我.缓存= .一些(值)
    当(自我.用户.count > 0) {
      让订阅者=自己.用户.流行Last ()
      background.异步{
        订阅者?(值)
      }
    }
    自我.信号量.信号()
  }
  
  init(_ f: @escaping (@escaping 回调) -> Void) {
    f(自我.回调)
  }
  
  函数c订阅(_ cb: @逃避回调){
    自我.信号量.wait ()
    切换缓存{
    情况下 .没有:
      用户.追加(cb)
      自我.信号量.信号()
    情况下 .一些(让价值):
      自我.信号量.信号()
      cb(值)
    }
  }
  
  static func 纯(_ value: B) -> 未来 {
    回到未来 { $0(要么.纯(值))}
  }
  
  func flatMap(_ f: @escaping (A) -> 未来) -> 未来 {
    回到未来 { [weak 自我] cb in
      Guard let 这 = 自我 其他的 {返回}
      这.中订阅{值
        开关值{
        情况下 .左(让犯错):
          cb(要么.左(err))
        情况下 .正确的(让x):
          f(x).订阅(cb)
        }
      }
    }
  }
  
  func map(_ f: @escaping (A) -> B) -> 未来 {
    回归自我.flatMap { 未来.纯(f(0)美元)}
  }
  
  static func 遍历(_ 列表: Array, _ f: @escaping (A) -> 未来) -> 未来> {
    返回列表.减少(未来>.纯(Array())) { (acc: 未来>, elem: A) in
      返回acc.flatMap{元素在
        返回f (elem).映射{val in
          返回元素+ [val]
        }
      }
    }
  }
}