dminuoso

usages = lines
  .map(&:split)
  .group_by(&loginL)
  .map(&toUsage)
  .sort_by(&:trafficOut)
  .reverse

dminuoso

  def self.writer_path(*args)
    -> (paths,val, obj) {
      obj.deep_dup.tap { |o| o.dig(*paths) = val }
    }.curry[*args]
  end

dminuoso

class Hash
  def self.setter(*args)
    -> (paths, val, obj) {
      obj.deep_dup.tap do |o|
        *dir, final = paths
        if dir.empty?
          o.store(final, val)
        else
          o.dig(*dir).store(final, val)
        end

dminuoso

# Identity functor that does not give any additional structure
Identity = Struct.new(:value) do
  def fmap(func = nil, &blk)
    f = func || blk;
    Identity.new(f.call(self.value))
  end
end

# Const Functor that preserves its content
Const = Struct.new(:value) do

dminuoso

const composeP2 = (f, g) => (val) => g(val).then((next) => f(next));
const composeP = (...funcs) => funcs.reverse().reduce(composeP2);

dminuoso

Identity = Struct.new(:value) do
  def fmap(*args)
    -> (func) {
      Identity.new(func.call(self.value))
    }.curry[*args]
  end
end

Const = Struct.new(:value) do
  def fmap(*args)

dminuoso

const idIfEq = (a, b) => a === b ? a : null
moves.find((row) => row.reduce(idIfEq))

dminuoso

module M
  X = 1
end
Object.include M


A = String
puts A::X
X = 23

dminuoso

combine1 :: (a -> a) -> State [a] ()
combine1 op = do
    a <- pop
    push $ op a

combine2 :: (a -> a -> a) -> State [a] ()
combine2 op = do
    a <- pop
    b <- pop
    push op a b

dminuoso

module ContT where

import Control.Monad.Trans.Class

newtype ContT r m a = ContT { runContT :: (a -> m r) -> m r }

instance Functor (ContT r m) where
    fmap f (ContT cv) = ContT $ \c ->
        cv (c . f)