msakai

module Bug where

import Control.Monad.Primitive
import qualified Data.HashTable.ST.Basic as H

data Symbol a = Symbol

data Node s a = Node

data Rule s a = Rule (Node s a)

msakai

module CohensKappa where

import Data.Hashable
import qualified Data.HashMap.Strict as HashMap

-- | Cohen's kappa coefficient (κ)
--
-- https://en.wikipedia.org/wiki/Cohen%27s_kappa
cohensKappa :: (Hashable c, Fractional a) => [(c,c)] -> a
cohensKappa xs = (po - pe) / (1 - pe)

msakai

from typing import Literal, Optional, Tuple, overload

@overload
def f(with_extra_info: Literal[False]) -> Tuple[int, int]: ...

@overload
def f(with_extra_info: Literal[True]) -> Tuple[int, int, str]: ...

# This overload is necessafy for type checking the last `f(with_extra_info)`.
@overload

msakai

{-# OPTIONS_GHC -Wall #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
-- https://en.wikipedia.org/wiki/Okapi_BM25
module OkapiBM25
  ( Database
  , mkDatabase
  , query
  ) where

msakai

import psycopg2


dsn = "postgresql://user:password@localhost:5432/"
db_name = "test_db"

conn = psycopg2.connect(dsn)
try:
    conn.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)
    with conn.cursor() as cur:

msakai

import Control.Monad
import Turtle

main :: IO ()
main = sh $
  forM_ [(1::Int)..2] $ \i -> do
    j <- select [(1::Int)..3]
    liftIO $ print (i, j)

{-

msakai

{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
module QueryInterface where

-- Maybe (GHC.Exts.DictBox a)
data QueryIntefaceResult a where

msakai

{-# OPTIONS_GHC -Wall #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  RWLock
-- Copyright   :  (c) Masahiro Sakai 2023
-- License     :  BSD-3-Clause
--
-- Simple implement of various variants of RWLocks.
--

msakai

{-# OPTIONS_GHC -Wall #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  FairLock
-- Copyright   :  (c) Masahiro Sakai 2023
-- License     :  BSD-3-Clause
--
-- Simple Lock implemented using STM.
-- When multiple threads are blocked on a Lock, they are woken up in FIFO order.

msakai

module Main (main) where

import Control.Concurrent.Async
import Control.Concurrent
import Control.Exception
import Control.Monad
import Data.IORef
import Foreign.C
import System.Random.MWC