graninas

module Main where

import Control.Monad.State
import Control.Monad
import System.Random

type Name = String
data Context = Context { ctxNextId :: State Context Int
                       , ctxNextName :: State Context Name }

graninas

-- file PathFind/Dijkstra.hs
module PathFind.Dijkstra (findPath) where
findPath = undefined

-- file PathFind/AStar.hs
module PathFind.AStar (findPath) where
findPath = undefined

-- file PathFind.hs
module PathFind (findPath, dijkstra, aStar) where

graninas

{-# LANGUAGE TemplateHaskell, Rank2Types #-}

module Main where

import Control.Lens
import Control.Monad.State

import Data.Monoid
import Data.List as L (insert, isInfixOf)

graninas

takeFork :: TVar Fork -> STM ()
takeFork tvFork = do
    fork <- readTVar tvFork
    case fork of
        InUse -> retry
        Free -> writeTVar tvFork InUse

makeDiningPhilosopher :: TVar Fork -> TVar Fork -> STM (TVar Philosopher)
makeDiningPhilosopher leftFork rightFork = do
    takeFork leftFork

graninas

Software Transactional Memory in C++: pure functional approach (Tutorial)

In this article I’ll tell you about my pure functional library for Software Transactional Memory (STM) that I’ve built in C++. I adopted some advanced functional programming concepts that make it composable and convenient to use. Its implementation is rather small and robust, which differentiates the library from competitors. Let’s discuss what STM is and how to use it.

• Intro
• Links
• Software Transactional Memory
• STM basics
• Composable transactions
• Dining Philosophers: The task

graninas

Building network actors with Node Framework

Article topics:

• What is Node Framework?
• Sample nodes
• Node Framework languages structure
  • Core languages
  • Framework languages
• Node Framework design and architecture

graninas

Bio TODO

graninas

Поэзия хаскеллистов

• Сольные произведения
  • Alister Crawley (@acrawley)
  • Aleksey (astynax) Pirogov (@astynax)
  • Алексей Худяков (@PineappleZombie)
  • Alexander Granin (@graninas)
  • Слава (@t91x0)
  • Andrey (@swamp_agr)
  • Danila Iakovlev (@LuckAttractor)

graninas

Weak type deduction

auto, lambdas -> std::function

auto m1 = newTVar(10);                                                // ok
auto m2 = stm::bind<TVarInt, TVarInt>(m1, [](const auto& tvar)        // ok, full bind type specified
{
    auto mm1 = writeTVar(tvar, 20);
 return sequence(mm1, pure(tvar));

graninas

#include <iostream>

constexpr int sum (int a, int b)
{
	return a + b;
}

constexpr int ediv (int a, int b)
{