mizunashi-mana

{-# LANGUAGE GADTs #-}

module Control.ExceptionUtil where

import Control.Exception

data TrySelection a where
  TrySelection :: Exception e => (e -> a) -> TrySelection a

trySelectionBuilder :: [TrySelection a] -> SomeException -> Maybe a

mizunashi-mana

footnote ^aaa.

mizunashi-mana

{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE StandaloneDeriving #-}

module MayBreakDerivingVia where

import Control.Monad.Trans.Reader

newtype T m a = T (Int -> m a)

mizunashi-mana

{-# LANGUAGE MagicHash #-}

module Main where

import Unsafe.Coerce
import GHC.Exts


data CompactD = CA | CB | CC
  deriving (Show)

mizunashi-mana

module TestSpace.NotSpaceAsciiString where

import Test.QuickCheck.Arbitrary
import Test.QuickCheck.Gen
import Data.Coerce
import Data.Char (isSpace)


newtype NotSpace = NotSpace Char
  deriving (Eq, Ord, Show)

mizunashi-mana

{-# LANGUAGE BangPatterns #-}

module Main where

import Criterion.Main
import Control.DeepSeq
import Data.Foldable

{-
Result:

mizunashi-mana

{-# LANGUAGE LambdaCase #-}

module Bench.StateVSIORef where

import Data.IORef
import Data.IORef.Unboxed
import Control.Monad.State.Strict


n :: Int

mizunashi-mana

{-# LANGUAGE LambdaCase #-}

module Bench.StateVSIORef where

import Data.IORef
import Control.Monad.State.Strict


n :: Int
n = 2 ^ (31 :: Int)

mizunashi-mana

module Bench.StateVSIORef where

import Data.IORef
import Control.Monad.State.Strict


n :: Int
n = 10000 * 10000

rotate :: [a] -> [a]

mizunashi-mana

module NaiveParser where

import           Control.Monad
import           Data.Maybe    (fromMaybe)

import           Text.ParserCombinators.Parsec

data Block =  List [Block] | ListItem String
    deriving Show