tel

{-# LANGUAGE GADTs #-}

module Lib where

import qualified Data.HashMap.Lazy as M
import Data.Hashable
import Data.Typeable

-- this is what we know about all things from Java
data Val where

tel

import scala.language.higherKinds

object Lenses {

  trait Profunctor[P[_, _]] {
    def dimap[A, B, C, D](f: C => A, g: B => D)(p: P[A, B]): P[C, D]
  }

  object Profunctor {

tel

package com.jspha.maia

import scala.language.higherKinds
import shapeless._
import shapeless.ops.hlist.Mapped

trait Maia {

  trait Api {
    type Fields <: HList

tel

-- Example code

example :: (Context m, MonadLog m, AreaDao m) => [Actor] -> m ()
example list = 
  forM list $ \actor -> do
    logInfo $ "Actor being read: " ++ actorCode actor
    areaList <- getArea actor
    case areaList of
      [] -> return () -- do nothing
      (area : _) -> do

tel

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeOperators #-}

tel

Indentation sensitive parser combinators

An indentation sensitive parser combinator language is one that helps you express ideas like "this parse only succeeds if it's within the current indentation block". The concept is somewhat small and elegant and is implemented in a few libraries. In this writeup, I will use examples from indents.

Background and goal

The direct goal will be to write the sameOrIndented parser combinator with a type

tel

package jspha.comms

import scala.language.higherKinds

sealed trait Quantity {
  type T[_]
}

object Singular extends Quantity { self =>
  case class T[A](v: A) extends Quantity.Set[A] {

tel

// Given an interface like

sealed trait Mult 
sealed trait One extends Mult
sealed trait ZeroOrOne extends Mult
sealed trait Many extends Mult

case class NoParam()

tel

import scala.language.implicitConversions

class Nimber(val value: BigInt) extends AnyVal {
  def size: Int = {
    val bitSize =
      if (value == 1) 0
      else if (value <= 3) 1
      else value.bitLength - 1
    val logBits =

tel

import scala.language.higherKinds
import scala.language.implicitConversions

trait Pt[C[_[_, _]], S, T, A, B] {
  def apply[~>[_, _]](ex: C[~>])(p: A ~> B): S ~> T
}

trait Profunctor[~>[_, _]] {
  def dimap[X, Y, A, B](f: X => A, g: B => Y)(p: A ~> B): X ~> Y