qnikst

#include "Cmm.h"

#define W_TO_SHORT(x) %lobits32(x)


crc16u {
    /* R1 uint32_t input, 
       R2 uint16_t data, 
       R3 Int size */
    I32 c;

qnikst

import Criterion.Main

import System.Environment
import qualified Data.Vector.Unboxed as V

magicHere :: Int -> Int
magicHere n = V.sum (V.take n p1)
  where
    p1 = V.unfoldr (\(c,s) -> let k = c+s in k `seq` Just (k,(c+1,k))) (0,1) 

qnikst

import Criterion.Main

import System.Environment
import qualified Data.Vector.Unboxed as V

magicHere :: Int -> Int
magicHere n = V.sum (V.take n p1)
  where
    p1 = V.unfoldr (\(c,s) -> let k = c+s in k `seq` Just (k,(c+1,k))) (0,1) 

qnikst

У меня возникла следующая задача, не по работе,
а обучения ради, в результате которой возник 
вопрос, а как правильно писать tying the knot
алгоритмы. (Сама задача решена, теперь остаётся вопрос как это сделать красиво)

Задача:
Полная задача это подсчёт очков в го, но она
разбита на подзадачи.
Текущая задача: Дана сетка в R^n, в узлах сетки или
стенка или пустое место, нужно на каждом пустом

qnikst

{-# LANGUAGE Rank2Types #-}

import Data.Function
import Control.Monad

data M m a = M a

instance Monad (M m) where
  return = M
  (M a) >>= f = f a

qnikst

type IsoKey  = Int
-- | Serialized element
data ElementS = ElementS Int [IsoKey] 

data Element = Element Int [Isotope] deriving  (Show)
data Isotope = Isotope IsoKey Element deriving (Show) -- payload

to :: [ElementS] -> [Element] 
to es = let result = map (\(ElementS z keys) -> Element z (map (\k -> Isotope k (un help k)) keys)) es
	    help   = zip es result 

qnikst

main = withSocketsDo $
    eventChan <- newChan
    tm <- newTimerIO
    forever $
      bracket (createNetwork tm chan)
              (threadKill) $ waitTimer tm >> resetTimer tm
  where
    createNet tm chan =  bracket (connect) (sClose) (network tm chan)
    connect = do
      addrinfos <- getAddrInfo Nothing (Just "") (Just "3000")

qnikst

import           Control.Monad.State (StateT)
import qualified Control.Monad.State as State
import           Data.Map (Map)
import qualified Data.Map as Map
import           Data.IORef (IORef)
import qualified Data.IORef as IORef

data AbstractKVS m k v = AbstractKVS 
  { kvsPut :: k -> v -> m ()
  , kvsGet :: k -> m (Maybe v)

qnikst

{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FunctionalDependencies #-}

qnikst

{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FunctionalDependencies #-}