Lev135

{-# LANGUAGE ApplicativeDo #-}

module Main where

import Data.Void (Void)
import Text.Megaparsec (Parsec, parseTest)
import Text.Megaparsec.Char (char)
import Text.Megaparsec.Char.Lexer (decimal)
import UnordApp (liftApp, runUnord)

Lev135

module LookAhead
  ( Pattern (..),
    ConflictPatterns,
    checkUniquePatSplit,
    checkUniquePatSplit',
  )
where

import Control.Monad (guard, when)
import Data.Bifunctor (Bifunctor (..))

Lev135

{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}

-- | This module contains usage example of suggested `MonadParsecDbg` type class,
-- minimized, but, I hope, demonstrative
--
-- If someone have better solution, I would like to see it
module Main where

Lev135

{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE PartialTypeSignatures #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}
{-# OPTIONS_GHC -Wall #-}
{-# OPTIONS_GHC -Wno-partial-type-signatures #-}

Lev135

{-# LANGUAGE GADTs         #-}
{-# LANGUAGE LambdaCase    #-}
{-# LANGUAGE TupleSections #-}

module Calc (
  Calc, call, runCalc, runCalcM, extractCalls,
  runCalcSortBy, runCalcSortOn, runCalcSort,
  contramapRes, mapInit, traverseInit
) where

Lev135

module Main where

import Data.Either.Extra (maybeToEither)

data Expr
  = Var String
  | Lam String Expr
  | App Expr Expr
  | Lit Int
  | Prim PrimOp Expr Expr

Lev135

module Main where
import Data.Maybe (fromJust)

data Expr
  = Var String
  | Lam String Expr
  | App Expr Expr
  | Lit Int
  | Prim PrimOp Expr Expr
  | Let (String, Expr) Expr

Lev135

import Control.Monad ((>=>))
import Data.Map (Map)
import qualified Data.Map as M
import GHC.Generics (Generic)
import Optics

data MLens m s a = MLens
  { mview :: s -> m a
  , mset  :: a -> s -> m s
  }

Lev135

{-# LANGUAGE RankNTypes #-}

module LensM where

import Control.Applicative (Const(..))
import Data.Functor.Identity (Identity(..))
import Data.Functor.Contravariant (Contravariant)
import Data.Functor.Compose

class Functor f => MfaAms f where

Lev135

Monadic lens

So much has been written about lens and other optics in Haskell that these ideas are likely not very original. However, I'll try.

Initial problem

Let's say we have some recursive data type:

type Record = Map String Value
data Value = I Int | R Record
  deriving (Generic, Show)