bens

import           Control.Monad.Trans.State.Strict
import           Control.Monad.Trans.Class
import           Test.Tasty                       (TestTree, defaultMain, testGroup)
import           Test.Tasty.QuickCheck            (testProperty)
import           Test.QuickCheck

import           Data.Machine
import           Data.Machine.Fanout
import           Data.Machine.Lift

bens

module Main (main) where

import           Control.Monad            (void)
import           Control.Monad.Identity
import           Criterion.Main
import qualified Data.Conduit             as C
import qualified Data.Conduit.Combinators as CC
import qualified Data.Conduit.List        as C
import qualified Data.Machine             as M
import qualified Data.Machine.Fanout      as BenS

bens

{-# LANGUAGE DeriveFunctor             #-}
{-# LANGUAGE ExistentialQuantification #-}

import Data.Semigroup

example :: Validation [String] Int Int
example = do
  x <- (+) <$> validation ["not even"] even
           <*> validation ["not positive"] (0 <)
  y <- validation ["not divisible by four"] (\a -> a `mod` 4 == 0)

bens

module Main (main) where

import Control.Applicative       (optional)
import Control.Monad             (replicateM)
import Control.Monad.Trans.State (State, runState, state)
import Data.List                 (sortOn)
import Data.Maybe                (isJust)
import Data.Ord                  (Down(Down))
import System.Environment        (getArgs)
import System.Random             (RandomGen, getStdGen, randomR, setStdGen)

bens

module Main (main) where

import Control.Concurrent (threadDelay)
import Control.Exception (catch, throwIO)
import Control.Monad (when, forM_)
import Control.Monad.IO.Class (MonadIO, liftIO)
import Control.Monad.Trans.Writer
import Control.Monad.Trans.Class (lift)
import Data.Machine.Concurrent
import Data.Time.Clock (UTCTime, addUTCTime, diffUTCTime, getCurrentTime)

bens

module typecheck where

data Type = Int | Type ==> Type

data AST
  = Lit Int
  | Var Type String
  | App Type AST AST
  | Lam Type String AST

bens

make/config.mk:
---
DDC_FLOW_USE_LINEAR_SOLVER = 1
=================================================================================================================
$ make war
...
(181.0/380) test/ddc-regress/core/04-Flow/80-Rate/30-Map2/Test.dcx                           std   run      success (138.3ms)

-- Output Differs  -------------------------------------------------------------
   expected file: test/ddc-regress/core/04-Flow/80-Rate/30-Map2/Test.stdout.check

bens

module filter where

open import Data.Bool           using (Bool; true; false)
open import Data.List           using (List; []; _∷_)
open import Data.Nat            using (ℕ; suc; _≤_; z≤n; s≤s; _≟_)
open import Data.Nat.Properties using (≤-trans)
open import Data.Nat.Show       using (show)
open import Data.Product        using (Σ-syntax; _×_; _,_)
open import Data.String         using (String)
open import Data.Vec            using (Vec;  []; _∷_)

bens

fmod LAMBDA is pr NAT . pr QID .

    *** User-level lambda expressions, using named binders.
    sorts Expr EName .
    subsort Nat EName < Expr .
    subsort Qid < EName .
    op __     : Expr  Expr -> Expr [ctor] .
    op [\_._] : EName Expr -> Expr [ctor] .
    op let_:=_in_ : EName Expr Expr -> Expr .
    eq let X := A in B = [\ X . B ] A .

bens

const std = @import("std");
const c = @cImport(@cInclude("SDL2/SDL.h"));

const SDLError = error{
    FailedInit,
    FailedCreatingWindow,
    FailedGettingEvent,
    FailedDraw,
    FailedScreenUpdate,
};