wuct

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let a = Arc::new(Mutex::new(0));
    let b = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    {
        let a = Arc::clone(&a);

wuct

class Nat (a :: Nat) 
  where toInt :: NProxy a → Int

instance natZero :: Nat Zero 
  where toInt _ = 0
instance natSucc :: Nat n ⇒ Nat (Succ n) 
  where toInt _ = 1 + toInt (NProxy :: NProxy n)

newtype Vec (n :: Nat) a = Vec (Array a) 

wuct

foreign import kind Nat
foreign import kind Boolean

foreign import data Zero :: Nat
foreign import data Succ :: Nat → Nat
foreign import data True :: Boolean
foreign import data False :: Boolean

data NProxy (a :: Nat) = NProxy
data BProxy (b :: Boolean) = BProxy

wuct

data Zero
data Succ n

type Two = Succ (Succ Zero)
type Three = Succ (Succ (Succ Zero))

data True
data False

class IsEven n b

wuct

data Nat = Succ Nat | Zero

isEven :: Nat → Boolean
isEven Zero = true
isEven (Succ n) = isOdd n

isOdd :: Nat → Boolean
isOdd Zero = false
isOdd (Succ n) = isEven n

wuct

module Main where

import Prelude
import Effect (Effect)
import Effect.Class.Console (log)

class Printf r 
  where printf :: String -> r  

instance printfString :: Printf String 

wuct

module Main where

import Prelude
import Data.Tuple (Tuple(..), snd)
import Data.Monoid (class Monoid, mempty)
import Control.Monad.Eff.Console (logShow)
import TryPureScript (render, withConsole)

newtype State s a = State (s -> Tuple a s)

wuct

module Main where

import Prelude
import Data.Tuple (Tuple(..), snd)
import Data.Monoid (class Monoid, mempty)
import Control.Monad.Eff.Console (logShow)
import TryPureScript (render, withConsole)

newtype Writer w a = Writer (Tuple a w)

wuct

module Main where

import Prelude

import Control.Monad.Reader.Class
import Control.Monad.Eff.Console (logShow)
import TryPureScript 

newtype Reader r a = Reader (r -> a)

wuct

liftedAdd :: forall f a. Apply f => Semiring a => f a -> f a -> f a
liftedAdd = lift2 (+)

combineMaybe :: forall a f. Applicative f => Maybe (f a) -> f (Maybe a)
combineMaybe Nothing = pure Nothing
combineMaybe (Just f) = Just <$> f