Oleg Grenrus phadej

## bar-Bar.hs
{-# LANGUAGE TemplateHaskell #-}
module Bar where

import System.Process (readProcess)
import Control.Monad.IO.Class (liftIO)
import Language.Haskell.TH.Syntax (lift)

fooBar :: String
fooBar = $(liftIO (readProcess "foo" [] "") >>= lift)

## ModelTest.hs
modelTest
    :: forall a b f g c.
    ( c a, c b
    , QC.Arbitrary (f b), Eq (g a)
    , Show (f a), Show (f b), Show (g a), Show (g b)
    , Functor f, Functor g
    )
    => (b -> a)
    -> Proxy c
    -> TestName

## ExceptST.hs
-- this is so wrong.
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE DerivingStrategies, GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MagicHash, UnboxedTuples #-}
{-# LANGUAGE ScopedTypeVariables #-}
module ExceptST (
    ExceptST, runExceptST, liftST, throwExceptST,
    -- * examples
    allNonNegative,
    ) where

## Unification.hs
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# OPTIONS_GHC -Wall #-}
module Unification where

import Control.Monad (ap, forM, forM_)
import Data.Foldable (toList)

import Data.Map.Strict (Map)
import qualified Data.Map.Strict as Map

## TypeMap.hs
{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE RankNTypes #-}

## CabalPlanConvert.hs
class Convert p c | p -> c, c -> p where
    toCabal   :: p -> c
    fromCabal :: c -> p

instance Convert P.Ver C.Version where
    toCabal (P.Ver vs) = C.mkVersion vs
    fromCabal v        = P.Ver (C.versionNumbers v)

instance Convert P.PkgName C.PackageName where
    toCabal (P.PkgName n) = C.mkPackageName (T.unpack n)

## Inline.hs
{-# OPTIONS_GHC -funfolding-creation-threshold=2 #-}
module Inline (inlineFoo, inlinableFoo, exposeFoo, normalFoo) where

import System.IO.Unsafe (unsafePerformIO)

{-

data IfaceUnfolding
  = IfCoreUnfold Bool IfaceExpr -- True <=> INLINABLE, False <=> regular unfolding
                                -- Possibly could eliminate the Bool here, the information

## BoolBoolBool.agda
{-# OPTIONS --safe --cubical #-}
module BoolBoolBool where

open import Cubical.Core.Everything

open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Function using (_∘_)
open import Cubical.Foundations.Isomorphism

## IEnum.hs
{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE EmptyCase #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE InstanceSigs #-}
{-# LANGUAGE PolyKinds #-}

## Range.hs
-- http://www.pcg-random.org/posts/bounded-rands.html
{-# LANGUAGE CPP, BangPatterns #-}
module Main where

import Data.Bits
import Data.Word (Word32, Word64)
import Data.List (unfoldr)

import qualified System.Random as R
import qualified System.Random.SplitMix32 as SM