List/Generator

Main.purs

module Main where

import Prelude
import Data.Array as Array
import Data.Lazy as L
import Partial.Unsafe (unsafePartial)

newtype Producer f a = Producer (f (Step f a))

data Step f a = Cons a (Producer f a) | Nil

class Suspend f where
  suspend :: forall a. (Unit -> a) -> f a
  force :: forall a. f a -> a
  
instance suspendFunction :: Suspend (Function Unit) where
  suspend = identity
  force k = k unit
  
instance suspendLazy :: Suspend L.Lazy where
  suspend = L.defer
  force = L.force
  
type Generator = Producer (Function Unit)

type List = Producer L.Lazy

fromArray :: forall f. Suspend f => Array ~> Producer f
fromArray arr = go 0
  where
  go ix = Producer $ suspend \_ ->
    if ix == Array.length arr then
      Nil
    else
      unsafePartial $ Cons (Array.unsafeIndex arr ix) (go (ix + 1))
      
view :: forall f. Suspend f => Producer f ~> Step f
view (Producer f) = force f