kosmikus

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
module MapDict where

import Generics.SOP
import Generics.SOP.Dict

kosmikus

{-# LANGUAGE AllowAmbiguousTypes, ConstraintKinds, RankNTypes, ScopedTypeVariables #-}
module CompTest where

import Generics.SOP
import Generics.SOP.Constraint

-- hcmap :: (HAp h, AllN (Prod h) c xs) => proxy c -> (forall a . c a => f a -> f' a) -> h f xs -> h f' xs
-- hcollapse :: (HCollapse h, SListIN h xs) => h (K a) xs -> CollapseTo h a

hcmapQ ::

kosmikus

{-# LANGUAGE RankNTypes, TypeFamilies, ConstraintKinds #-}

type family F x where
  F () = Int
  F x  = Char

class Foo x where
  foo :: x -> F x

f :: (c (), Foo b) => proxy c -> (forall a . c a => a -> b) -> F b

kosmikus

{-# LANGUAGE FlexibleContexts, TypeApplications, PolyKinds, ScopedTypeVariables, GADTs #-}
{-# LANGUAGE DeriveGeneric #-}
module GShow where

import Data.List (intersperse)
import Generics.SOP
import qualified GHC.Generics as GHC

gshow ::
  (Generic a, HasDatatypeInfo a, All2 Show (Code a)) => a -> String

kosmikus

{-# LANGUAGE RankNTypes, ScopedTypeVariables, DataKinds, PolyKinds, TypeOperators #-}
{-# LANGUAGE TypeFamilies #-}

import Generics.SOP

type family Map (f :: k -> l) (xs :: [k]) :: [l]
type instance Map _f '[]       = '[]
type instance Map  f (x ': xs) = f x ': Map f xs

toNPI :: NP f xs -> NP I (Map f xs)

kosmikus

{-# LANGUAGE DataKinds, OverloadedStrings #-}
module Servant.Caldav where

import Servant.API

data CaldavMethod =
    PROPFIND
  | PROPPATCH
  | MKCOL
  | MKCALENDAR

kosmikus

{-# LANGUAGE DataKinds, TypeFamilies, FlexibleContexts, ScopedTypeVariables, TypeOperators, DefaultSignatures  #-}
{-# LANGUAGE OverloadedStrings, DeriveGeneric #-}
module HasqlSOP where

import Data.Functor.Contravariant
import qualified Data.Map as M
import Data.Text
import Generics.SOP
import qualified GHC.Generics as GHC
import qualified Hasql.Encoders as E

kosmikus

{-# LANGUAGE DataKinds, TypeOperators, DeriveGeneric #-}
{-# LANGUAGE TypeFamilies, UndecidableInstances #-}
{-# LANGUAGE FlexibleInstances, ScopedTypeVariables, FlexibleContexts #-}
{-# LANGUAGE DefaultSignatures, MultiParamTypeClasses #-}
module Test where

import Data.Proxy
import qualified GHC.Generics as GHC
import Generics.SOP
import Servant.API

kosmikus

Keybase proof

I hereby claim:

• I am kosmikus on github.
• I am kosmikus (https://keybase.io/kosmikus) on keybase.
• I have a public key ASAf0yz_-3NnqKIrZ-dwMG2s2RY0JZgXKy5pg9m2eoXr3Qo

To claim this, I am signing this object:

kosmikus

{-# LANGUAGE TypeInType, TypeFamilies, FlexibleInstances #-}

import GHC.Types

type family F (a :: Type) :: Type

class C a where
  type D (a :: Type) :: F a

instance (F a ~ Bool) => C a where