ndtimofeev

{-# LANGUAGE DataKinds, GADTs, DeriveGeneric #-}

import GHC.Generics

data T a where
    MkT1 :: T True
    MkT2 :: T False

data T2 = T2 (T False)
    deriving Generic

ndtimofeev

// core
#include <QObject>
#include <QTimer>
#include <QDebug>

// network
#include <QLocalSocket>
#include <QLocalServer>

// widgets

ndtimofeev

module Control.Monad.Step
    ( Step
    , MonadStep(..)
    , mapStep
    , mapStep_
    , runStepWithMask
    , runStep
    , evalScriptWithMask
    , evalScript )
where

ndtimofeev

{-# LANGUAGE GADTs #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE UnboxedTuples #-}

module Control.Monad.Exception
    ( Exception(..)
    , SomeException( SomeException )
    , StackInfo(..)
    , throw

ndtimofeev

data Linker = Emplty | Dash | Equal | Octothrope
    deriving (Eq, Ord, Show)

data Polygon edge vertex
    = Polygon !vertex !edge !(Polygon edge vertex)
    | Line !vertex !edge !vertex
    deriving (Eq, Ord, Show, Functor, Foldable, Traversable)

data SignumForm = Prefix | Postfix | Binary
    deriving (Eq, Ord, Show)

ndtimofeev

main :: IO ()
main = do
    tid1 <- forkIO $ magicMask $ do
        localTid <- myThread
        tid2     <- forkIO $ do
            threadDelay (42 * 42)
            killThread localTid
        forever $ threadDelay 777

    tid3 <- forkIO $ do

ndtimofeev

{-# LANGUAGE Rank2Types #-}

module Managed where

-- base
import Data.IORef

-- exceptions
import Control.Monad.Catch

ndtimofeev

-- base
import Control.Applicative
import Control.Monad

import Data.Maybe
import Data.Word
import Data.Proxy

import GHC.TypeLits

ndtimofeev

module CoCoCoOutput where

import Control.Exception

import Control.Concurrent.Async
import Control.Concurrent.Chan

import Control.Monad

import Data.Function

ndtimofeev

{-# LANGUAGE ExistentialQuantification #-}

-- base
import Control.Exception
import Control.Concurrent.MVar
import Control.Monad

import Data.IORef

import System.IO.Unsafe