An alternative way of accessing the past

[ivanperez-keera]

Did we ever explore the possibility of looking into the past of a stream with a function with a signature like the following?

import           Copilot.Language
import           Prelude          hiding ((++))
import qualified Prelude

at :: Typed a
   => a        -- ^ Default value for times before zero
   -> Stream a -- ^ Stream to look into
   -> Int      -- ^ Number of steps to look back
   -> Stream a
at def s n
  | n Prelude.> 0  = error "You cannot look into the future"
  | n Prelude.== 0 = s
  | n Prelude.< 0  = replicate (negate n) def ++ s

It could use used as follows:

example :: Stream Bool
example = [True] ++ false

example1 :: Stream Bool
example1 = at False example (-1)

I wonder if there would be any benefit to making at take a KnownNat (wrapped in something). I just would not want users to have to write Proxy in their expressions, or type expressions explicitly.

We could also provide:

at' :: (Default a, Typed a)
    => Stream a -- ^ Stream to look into
    -> Int      -- ^ Number of steps to look back
    -> Stream a
at' s n
  | n Prelude.> 0  = error "You cannot look into the future"
  | n Prelude.== 0 = s
  | n Prelude.< 0  = replicate (negate n) def ++ s

and users could write:

example1 :: Stream Bool
example1 = at example (-1)

or:

example1 :: Stream Bool
example1 = example `at'` (-1)

or define an operator (for example, (#!), and I'm picking a random name) as a synonym for at' so that users can write:

example1 :: Stream Bool
example1 = example #! (-1)

[ivanperez-keera]

Positive numbers would be equivalent to a drop, of course, if we change the implementation of at':

It would provide a uniform, and I'd argue more natural, way of accessing streams:

 example #! (-1) -- look back into the past
 example #! 1    -- look into the future, only valid if example knows enough about its own future