cblp

import           Control.Monad.IO.Class (liftIO)
import           Data.Text (Text)
import qualified Data.Text as Text
import           Telegram.Bot.API (Chat (..), ChatType (..), Message (..),
                                   ParseMode (Markdown), Update (..),
                                   defaultTelegramClientEnv)
import           Telegram.Bot.Simple (BotApp (..), BotM, Eff, getEnvToken,
                                      reply, replyMessageParseMode, startBot_,
                                      toReplyMessage, withEffect)
import           Telegram.Bot.Simple.Debug (traceBotDefault)

cblp

{-# LANGUAGE TypeFamilies         #-}
{-# LANGUAGE UndecidableInstances #-}

import           Data.OpenUnion          (Union, liftUnion)
import           Data.Singletons.Prelude (type (++))

-- * Union's Little helpers

type family a \/ b where
  Union xs \/ Union ys = Union (xs ++ ys)

cblp

{-# LANGUAGE ConstraintKinds  #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE TypeFamilies     #-}

class ArithOp op where add, mul :: op

class LogicalOp op where and :: op

class CompareOp op where less, equal :: op

cblp

{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTSyntax        #-}


-- * (G)ADT

data DTree where
  Empty :: DTree
  Node  :: String -> DTree -> DTree -> DTree
  deriving (Show)

cblp

robots.hs:47:36: error:
    • Couldn't match type ‘[Char]’
                     with ‘((a1, b1, [Char]) -> t1) -> t1’
      Expected type: ((a1, b1, [Char]) -> ((a1, b1, [Char]) -> t1) -> t1)
                     -> ((((a1, b1, [Char]) -> t1) -> t1, b1,
                          ((a1, b1, [Char]) -> t1) -> t1)
                         -> ((a1, b1, [Char]) -> t1) -> t1)
                     -> [Char]
        Actual type: ((((a1, b1, [Char]) -> t1) -> t1, b1,
                       ((a1, b1, [Char]) -> t1) -> t1)

cblp

#include <list>
    using std::list;
#include <map>
    using std::map;
#include <set>
    using std::set;
#include <utility>
    using std::pair;

#include <rapidcheck.h>

cblp

{-# LANGUAGE PolyKinds       #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TypeOperators   #-}

module Meta where

import           Control.Monad
import           Language.Haskell.TH

type a // b = a

cblp

{-# LANGUAGE DataKinds           #-}
{-# LANGUAGE GADTs               #-}
{-# LANGUAGE PolyKinds           #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications    #-}
{-# LANGUAGE TypeFamilies        #-}
{-# LANGUAGE TypeOperators       #-}

import           Data.Kind
import           Data.List

cblp

{-# LANGUAGE DisambiguateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE QuasiQuotes #-}
{-# LANGUAGE TemplateHaskell #-}

module A where

import Data.ByteString
import Language.C.Inline as C

cblp

#!/usr/bin/env stack
{-
  stack --resolver=lts-14.10
  script --ghc-options=-Wall --package=megaparsec --package=parser-combinators
-}

import Control.Monad.Combinators ((<|>), between, some)
import Control.Monad.Combinators.Expr (Operator (InfixL), makeExprParser)
import Data.Void (Void)
import Text.Megaparsec (Parsec, eof, errorBundlePretty, parse)