xgrommx

module LensExample where

import Prelude

import Data.Array (filter)
import Data.Generic.Rep (class Generic)
import Data.Generic.Rep.Show (genericShow)
import Data.Lens (Traversal, traversed, wander, (.~), (^..), (+~))
import Data.Traversable (traverse)
import Effect (Effect)

xgrommx

data Append t = Append t t
derive instance functorAppend :: Functor Append
type Semigroup' r = (append :: V.FProxy Append | r)
newtype Semigroup t = Semigroup (V.VariantF (Semigroup' ()) t)

derive instance functorSemigroup :: Functor Semigroup

_append = SProxy :: SProxy "append"

append :: forall a. Algebra Semigroup a => a -> a -> a

xgrommx

newtype Circle = Circle { circleRadius :: Number, circleCenter :: Tuple Number Number }

derive instance genericCircle :: Generic Circle _

instance showCircle :: Show Circle where
  show c = genericShow c

instance eqCircle :: Eq Circle where
  eq x y = genericEq x y

xgrommx

type MuV t = Mu (VariantF t)

inv :: forall a b f s. RowCons s (FProxy f) a b 
        => IsSymbol s 
        => Functor f 
        => SProxy s 
        -> f (Mu (VariantF b)) 
        -> Mu (VariantF b)
inv x = In <<< (inj x)

xgrommx

-- | A “flushing” 'stream', with an additional coalgebra for flushing the
--   remaining values after the input has been consumed. This also allows us to
--   generalize the output away from lists.
fstream
  :: (Cursive t (XNor a), Cursive u f, Corecursive u f, Traversable f)
  => Coalgebra f b -> (b -> a -> b) -> Coalgebra f b -> b -> t -> u
fstream ψ g ψ' = go
  where
    go c x = 
      let fb = ψ c

xgrommx

module Tree where

import Control.Monad.Writer
import Data.Bifoldable
import Data.Bifunctor
import Data.Bitraversable
import Data.Foldable
import Data.Generic
import Data.Monoid
import Data.Monoid.Additive

xgrommx

{-#LANGUAGE BangPatterns #-}  
import GHC.Magic 
import Data.IORef
import Control.Monad 
import Control.Monad.Trans

data Stream a m r = Yield a (Stream a m r) | Done r | Delay (() -> m (Stream a m r))

instance Functor m => Functor (Stream a m) where
  fmap f (Done r) = Done (f r)

xgrommx

{-# LANGUAGE StandaloneDeriving, DataKinds, PolyKinds, GADTs, RankNTypes, TypeOperators, FlexibleContexts, TypeFamilies, KindSignatures #-}

-- http://www.timphilipwilliams.com/posts/2013-01-16-fixing-gadts.html

module HRecursionSchemes where

import Control.Applicative
import Data.Functor.Identity
import Data.Functor.Const
import Text.PrettyPrint.Leijen hiding ((<>))

xgrommx

{-#LANGUAGE DataKinds #-}
{-#LANGUAGE DeriveDataTypeable #-}
{-#LANGUAGE DeriveFoldable #-}
{-#LANGUAGE DeriveFunctor #-}
{-#LANGUAGE DeriveGeneric #-}
{-#LANGUAGE DeriveTraversable #-}
{-#LANGUAGE GADTs #-}
{-#LANGUAGE GeneralizedNewtypeDeriving #-}
{-#LANGUAGE KindSignatures #-}
{-#LANGUAGE TypeFamilies #-}

xgrommx

{-# LANGUAGE RankNTypes, ScopedTypeVariables, DeriveTraversable, PatternSynonyms, UndecidableInstances, FlexibleInstances, ViewPatterns, InstanceSigs #-}

module Fix where

import Control.Monad (ap, join, (<=<))
import Control.Applicative (empty, Alternative, (<|>))
import Control.Arrow
import Data.Functor.Compose

-- Free f a = Mu x. a + f x