L-TChen

{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE TypeSynonymInstances #-}
{-# LANGUAGE FlexibleInstances #-}
module JSON_RPC where 

import ReadExcept

L-TChen

{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGe FlexibleContexts #-}
{-# LANGUAGE MultiParamTypeClasses #-}

module ReadExcept (
  module ReadExcept
  , module Control.Monad.Reader
  , module Control.Monad.Except
  , module Control.Monad.Identity
  ) where

L-TChen

{-# LANGUAGE UnicodeSyntax   #-}
{-# LANGUAGE TupleSections   #-}

module Caesar where
import Data.Map (Map, fromList, fromListWith, unionWith)
import Data.Char 
import Data.List
import Data.Function

encode ∷ Int → String → String 

L-TChen

{-# LANGUAGE FlexibleContexts, BangPatterns #-}

import Data.IntMap.Strict
import Data.Maybe
import Data.Function
import Control.Monad.Identity
import Control.Monad.State.Lazy hiding (fix)

import Prelude hiding (lookup)

L-TChen

{-# LANGUAGE TypeFamilies, DataKinds, KindSignatures, GADTs #-}
{- TypeFamilies is required to define type-level functions -}

data Nat = Zero | Succ Nat 

data Fin :: Nat -> * where 
  FZero :: Fin ('Succ n)
  FSucc :: Fin n -> Fin ('Succ n)

data Vector (a :: *) :: Nat -> * where

L-TChen

{-# LANGUAGE FlexibleContexts, FlexibleInstances #-}
{-# LANGUAGE TypeInType , ScopedTypeVariables , TypeFamilies, TypeOperators #-} 
{-# LANGUAGE GADTs, StandaloneDeriving #-}
{-# LANGUAGE Safe #-}

module Unification where

import Data.Kind
import Prelude hiding ((++))

L-TChen

{-# LANGUAGE DeriveGeneric #-}

{- Building a tree based on its bfs result. -}   
module BFS where

import Test.QuickCheck hiding ((><))
import GHC.Generics
import Generic.Random
import Data.Sequence (Seq (..), singleton, (><)) 

L-TChen

{-# LANGUAGE ViewPatterns #-}
{-# LANGUAGE PatternSynonyms #-}

import Data.Vector as V

pattern Empty :: Vector a
pattern Empty <- (V.null -> True) where Empty = V.empty 

uncons :: Vector a -> Maybe (a, Vector a)
uncons Empty = Nothing

L-TChen

{-# LANGUAGE TypeApplications #-}
import Test.QuickCheck
import Data.List (sort)

selectOrigin k = (!! k) . sort 

select :: (Ord a) => Int -> [a] -> a
select k (x:xs) = case compare k n of
  LT -> select k ys 
  EQ -> x

L-TChen

{-# LANGUAGE ViewPatterns, PatternSynonyms #-}

module Deque where 

import Text.Read
import Data.Bifunctor
import Prelude hiding (length, init, tail, last, head) 
import qualified Prelude as P
                  
data Deque a =