Book of Yampa

https://yampa-book.readthedocs.io/en/latest/
Admin
The Book of Yampa is a comprehensive guide and tutorial for learning and using the Yampa functional...
Tokens:46,203
Snippets:135
Trust Score:8.3
Update:1 year ago
Show doc for...
Tokens:
Raw
### Yampa Quickstart Example

Source: https://yampa-book.readthedocs.io/en/latest/yampa

A basic example demonstrating how to run a Yampa simulation with initial state and events.

```Haskell
runReader (embed (yourSF "init") [NoEvent, NoEvent, Event ()]) 1.0
```

--------------------------------

### Haskell Environment Setup with Ghcup

Source: https://yampa-book.readthedocs.io/en/latest/intro

This command initiates the graphical user interface for ghcup, a tool for managing Haskell installations. It's used to install specific GHC versions and other Haskell tooling.

```Shell
ghcup tui
```

--------------------------------

### Running the MyReactimate Example

Source: https://yampa-book.readthedocs.io/en/latest/reactimate

Instructions on how to compile and run the 'myreactimate0.hs' example using Cabal.

```Shell
>>> cabal repl myreactimate0 --ghci-options '+RTS --io-manager=native -RTS'
>>> main

```

--------------------------------

### Running the example

Source: https://yampa-book.readthedocs.io/en/latest/reactimate

Instructions on how to load and run the provided Haskell code examples using Cabal and GHCi.

```bash
cabal repl myreactimateB --ghci-options '+RTS --io-manager=native -RTS'
main

```

--------------------------------

### System Package Installation for Yampa

Source: https://yampa-book.readthedocs.io/en/latest/intro

This command installs necessary system packages required for building and running Yampa examples. It specifies versions for libgmp and libffi, which might be crucial for compatibility with specific Haskell compiler versions.

```Shell
apt install build-essential curl libffi-dev libffi7 libgmp3-dev libgmp10 libncurses-dev libncurses5 libtinfo5 # using libgmp3-dev instead of libgmp-dev and libffi7 instead of libffi6
```

--------------------------------

### Running the Updated MyReactimate Example

Source: https://yampa-book.readthedocs.io/en/latest/reactimate

Instructions for compiling and running the 'myreactimate1.hs' example using Cabal.

```Shell
>>> cabal repl myreactimate1 #--ghci-options '+RTS --io-manager=native -RTS'
>>> main

```

--------------------------------

### Running Haskell Examples

Source: https://yampa-book.readthedocs.io/en/latest/embed

Instructions on how to load and run the provided Haskell code examples using Cabal.

```bash
>>> cabal repl readert
>>> main
```

--------------------------------

### Yampa Reactor Example

Source: https://yampa-book.readthedocs.io/en/latest/_downloads/0fe8484188c324752c71438ed46cb214/reactimate

Demonstrates the core Yampa reactor pattern, integrating input, output, and a signal function. It uses IORefs for state management and handles time differences for signal processing. The example includes a basic signal function that integrates time.

```haskell
#{-# LANGUAGE Arrows #-}

import Control.Concurrent (threadDelay)
import Data.Functor.Identity
import Data.IORef
import Data.Time.Clock
import FRP.BearRiver

inputInit :: IO String
inputInit = do
  pure "inputInit" -- use this if input doesn't produce anything

input :: IORef UTCTime -> UTCTime -> Bool -> IO (DTime, Maybe String)
input dtRef tInit _ = do
  now <- getCurrentTime
  prev <- readIORef dtRef
  writeIORef dtRef now
  let dt = realToFrac $ diffUTCTime now prev  -- delta time
  let at = realToFrac $ diffUTCTime now tInit -- absolute time
  return (dt, Just (show now)) -- usually you would want to use device inputs or resource media here but let's produce some input strings from time

sf :: Monad m => SF m String String
sf = proc nowStr -> do
  t <- integral -< 1.0 :: Double
  returnA -< " integral: " ++ show t ++ " now: " ++ nowStr

output :: Bool -> String -> IO Bool
output _ out = do
  putStrLn out
  threadDelay secs -- DON'T USE IT LIKE THIS IN A REAL GAME LOOP
  return False
  where secs = 1000 * 1000 -- pico seconds

main = do
  putStrLn "Warning: On Windows threadDelay only works without io-manager=native options!"
  putStrLn "Time progress in about 1sec (+ some processor time) steps. Interrupt with [Control-C]!"
  t <- getCurrentTime
  dtRef <- newIORef t

  reactimate inputInit (input dtRef) output sf

  putStrLn "...end"

-- > start...
-- > now: 2021-09-12 09:42:57.1321897 UTC integral: 0.0
-- > now: 2021-09-12 09:42:58.1421375 UTC integral: 1.0099473
-- > now: 2021-09-12 09:42:59.1492352 UTC integral: 2.0170455
-- > Interrupted.

```

--------------------------------

### Cabal Commands for Yampa Spring Example

Source: https://yampa-book.readthedocs.io/en/latest/yampa

Provides instructions on how to load and run the Yampa spring simulation example using Cabal. It specifies the necessary command to enter the GHCi environment with specific runtime system options for IO management.

```text
>>> cabal repl spring # --ghci-options '+RTS --io-manager=native -RTS'
>>> main

```

--------------------------------

### Install Sphinx and Dependencies

Source: https://yampa-book.readthedocs.io/en/latest/contribute

These commands install Python 3, pip, and the necessary Sphinx packages (sphinx, sphinx-rtd-theme, sphinx-comments) required for building the documentation.

```bash
apt install python3 python3-pip
```

```bash
pip install sphinx sphinx-rtd-theme sphinx-comments
```

--------------------------------

### Yampa Embedding Quickstart Examples

Source: https://yampa-book.readthedocs.io/en/latest/embed

Demonstrates basic embedding of Yampa functionalities. It shows how to count inputs, run computations within a ReaderT monad transformer, and directly embed functions for stream processing.

```haskell
do
let yourMSF = count
ls <- embed yourMSF ["input0", "input1", "input2"]
print ls
```

```haskell
do
let yourSF = integral
dt = 1/60
ls <- runReaderT (embed yourSF $ replicate 10 123.0) dt
print ls
```

```haskell
do
let yourSF = integral
dt = 1/60
ls <- embed (runReaderS_ yourSF dt) $ replicate 10 123.0
print ls
```

--------------------------------

### Yampa FRP Basic Example

Source: https://yampa-book.readthedocs.io/en/latest/_downloads/0631495c2c03af3da3124ee46fd62c84/input

A fundamental Yampa FRP example demonstrating input handling, signal processing, and output. It uses IORef for time tracking and processes character input to control a signal function. The example shows how to integrate FRP with IO actions like reading from stdin and printing to stdout.

```Haskell
#!/usr/bin/env runghc
{-# LANGUAGE Arrows #-}

import Data.Functor.Identity
import Data.IORef
import Data.Time.Clock
import FRP.BearRiver
import Numeric
import System.IO ( stdin, hSetBuffering, BufferMode(NoBuffering) )

inputInit :: IO (Char, String)
inputInit = do
  pure ('\x00', "inputInit")

input :: IORef UTCTime -> UTCTime -> a -> IO (DTime, Maybe (Char, String))
input dtRef tInit _ = do
  c <- getChar

  now <- getCurrentTime
  prev <- readIORef dtRef
  writeIORef dtRef now
  let dt = realToFrac $ diffUTCTime now prev  -- delta time
  let at = realToFrac $ diffUTCTime now tInit -- absolute time
  pure (dt, Just (c, show now))

sf :: SF Identity (Char, String) (Bool, String)
sf = proc (input, nowStr) -> do
  t <- integral -< 1.0 :: Double
  let out = "integral: " ++ showFFloat (Just 2) t "" ++ " now: " ++ nowStr
  returnA -< (input == 'q', out)

output :: a -> (Bool, String) -> IO Bool
output _ (quit, out) = do
  putStrLn out
  pure quit

main = do
  putStrLn "Repeatedly press any key or [Q] to quit!"

  hSetBuffering stdin NoBuffering
  t <- getCurrentTime
  dtRef <- newIORef t

  reactimate inputInit (input dtRef t) output sf

  putStrLn "...end"

```

--------------------------------

### Compilation and Execution Instructions

Source: https://yampa-book.readthedocs.io/en/latest/yampa

Provides command-line instructions for compiling and running the Haskell examples using Cabal. It includes options for setting GHCi flags.

```bash
>>> cabal repl animation # --ghci-options '+RTS --io-manager=native -RTS'
>>> main

>>> cabal repl objmove # --ghci-options '+RTS --io-manager=native -RTS'
>>> main

```

--------------------------------

### Yampa Project Examples

Source: https://yampa-book.readthedocs.io/en/latest/links

A list of GitHub repositories showcasing projects built with Yampa, demonstrating various applications and use cases of the library.

```Haskell
https://github.com/ivanperez-keera/SpaceInvaders
https://github.com/ivanperez-keera/haskanoid
https://github.com/walseb/The_Bearriver_Arcade
https://hackage.haskell.org/package/pang-a-lambda-0.2.0.0/src/
https://github.com/madjestic/e1338
https://github.com/Jyothsnasrinivas/eta-android-2048
https://github.com/madjestic/Haskell-OpenGL-Tutorial/tree/master/MandelbrotYampa
```

--------------------------------

### GHCi Command for Windows

Source: https://yampa-book.readthedocs.io/en/latest/reactimate

Provides the GHCi command to run the reactimate example on Windows, specifically addressing potential issues with native IO managers by including the necessary RTS options.

```Shell
>>> cabal repl reactimate --ghci-options '+RTS --io-manager=native -RTS'
```

--------------------------------

### Troubleshoot pip Installation

Source: https://yampa-book.readthedocs.io/en/latest/contribute

This command addresses a potential issue where pip might not be installed, ensuring it is available for package management.

```bash
apt install python3-pip
```

--------------------------------

### Full Game Loop Example with Real-Time Deltas

Source: https://yampa-book.readthedocs.io/en/latest/reactimate

A more complete example demonstrating a game loop using `reactimate` with real-time deltas. It includes handling time differences, producing output strings based on time, and using `threadDelay` for timing. Note: `threadDelay` usage here is simplified and not recommended for real game loops.

```Haskell
#{-# LANGUAGE Arrows #-}

importControl.Concurrent(threadDelay)
importData.Functor.Identity
importData.IORef
importData.Time.Clock
importFRP.BearRiver

inputInit::IOString
inputInit=do
pure"inputInit"-- use this if input doesn't produce anything

input::IORefUTCTime->UTCTime->Bool->IO(DTime,MaybeString)
inputdtReftInit_=do
now<-getCurrentTime
prev<-readIORefdtRef
writeIORefdtRefnow
letdt=realToFrac$diffUTCTimenowprev-- delta time
letat=realToFrac$diffUTCTimenowtInit-- absolute time
return(dt,Just(shownow))-- usually you would want to use device inputs or resource media here but let's produce some input strings from time

sf::Monadm=>SFmStringString
sf=procnowStr->do
	t<-integral-<1.0::Double
	returnA-<" integral: "++showt++" now: "++nowStr

output::Bool->String->IOBool
output_out=do
putStrLnout
threadDelaysecs-- DON'T USE IT LIKE THIS IN A REAL GAME LOOP
returnFalse
wheresecs=1000*1000-- pico seconds

main=do
putStrLn"Warning: On Windows threadDelay only works without io-manager=native options!"
putStrLn"Time progress in about 1sec (+ some processor time) steps. Interrupt with [Control-C]!"
t<-getCurrentTime
dtRef<-newIOReft

reactimateinputInit(inputdtReft)outputsf

putStrLn"...end"

-- > start...
-- > now: 2021-09-12 09:42:57.1321897 UTC integral: 0.0
-- > now: 2021-09-12 09:42:58.1421375 UTC integral: 1.0099473
-- > now: 2021-09-12 09:42:59.1492352 UTC integral: 2.0170455
-- > Interrupted.
```

--------------------------------

### Haskell FRP Input and Processing Example

Source: https://yampa-book.readthedocs.io/en/latest/_downloads/b65b84272befaa17b6681dfca28543bb/state

Demonstrates how to handle character input, track time, and process input values using Yampa's SF (Signal Function) abstraction. It includes functions for initializing input, reading input with time delta, processing signals, and outputting results.

```haskell
{-# LANGUAGE Arrows #}

import FRP.BearRiver
import Data.IORef
import Data.Time.Clock
import Data.Functor.Identity
import Numeric
import System.IO
import Data.Char

inputInit :: IO Char
inputInit = do
  pure '\x00'

input :: IORef UTCTime -> a -> IO (DTime, Maybe Char)
input dtRef _ = do
  c <- getChar

  now <- getCurrentTime
  prev <- readIORef dtRef
  writeIORef dtRef now
  let dt = realToFrac $ diffUTCTime now prev  -- delta time
  pure (dt, Just c)

process :: SF Identity Char (Bool, String, String)
process = proc i -> do
  t <- time -< ()

  let n = if isDigit i then digitToInt i else 0
  c <- sumS -< fromIntegral n :: Double -- required for VectorSpace
  -- c <- feedback 0 (arr feedbackAdd) -< n
  -- c <- stateful 0 statefulAdd -< n
  -- let nE = if isDigit i then Event (digitToInt i) else NoEvent
  -- c <- accumHoldBy accumAdd 0 -< nE

  returnA -< (i == 'q', showFFloat (Just 2) t "", show c)
    where
      -- feedbackAdd (accu, new) = dup (accu + new)
      -- statefulAdd accu new = accu + new
      -- accumAdd new accu = accu + new
      -- stateful :: Monad m => b -> (a -> b -> b) -> SF m a b
      -- stateful bInit f = proc a -> do
      --   b' <- feedback bInit (arr ((a, b) -> dup $ f a b)) -< a
      --   returnA -< b'

output :: a -> (Bool, String, String) -> IO Bool
output _ (quit, timeStr, countStr) = do
  putStrLn $ "time: " ++ timeStr ++ " counter: " ++ countStr
  pure quit

main = do
  putStrLn "Enter some chars to tick, digits to add or quit with [Q]!"
  hSetBuffering stdin NoBuffering
  t <- getCurrentTime
  dtRef <- newIORef t

  reactimate inputInit (input dtRef) output process

  putStrLn "...end"

```

--------------------------------

### Echo Command Example (Bash/Ghci)

Source: https://yampa-book.readthedocs.io/en/latest/contribute

Demonstrates the use of the 'echo' command with doctext syntax, suitable for both bash and ghci environments. This format is preferred for its ease of copying and pasting.

```bash
>>> echo hello world
# hello world

```

```ghci
>>> echo hello world
# hello world

```

--------------------------------

### Yampa Basic SF Example

Source: https://yampa-book.readthedocs.io/en/latest/_downloads/6a7d258a4f71af26d1808f65499feb90/myreactimate1

Demonstrates a simple Signal Function (SF) in Yampa that sums a constant value over time. It shows how to define an SF, use `proc` for declarative definition, and integrate with `BearRiver.sumS`.

```haskell
#{-# LANGUAGE Arrows, ScopedTypeVariables #-}

import Control.Monad.Trans.MSF.Reader
import Data.Functor.Identity
import Data.MonadicStreamFunction
import FRP.BearRiver hiding (reactimate)
import System.IO

input :: IO (Double, Char)
input = do
  i <- getChar
  pure (dt, i)
  where dt = 1.0

process :: SF Identity Char String -- this is an BearRiver.SF now, not a Dunai.MSF
process = proc i -> do
  t <- sumS -< 1.0 :: Double -- using BearRiver.sumS here!
  returnA -< show t

output :: String -> IO ()
output o = putStrLn o

myreactimate :: forall a b. IO (Double, a) -> (b -> IO ()) -> SF Identity a b -> IO ()
myreactimate sense actuate sf = reactimate $ senseSF >>> sfIO >>> actuateSF
  where
    senseSF :: MSF IO () (Double, a)
    senseSF = constM sense
    actuateSF :: MSF IO b ()
    actuateSF = arrM actuate
    sfIO :: MSF IO (Double, a) b
    sfIO = morphS (pure . runIdentity) (runReaderS sf)

main :: IO ()
main = do
  putStrLn "Press any key to get custom process counts and [Control-C] to interrupt!"
  hSetBuffering stdin NoBuffering
  myreactimate input output process

```

--------------------------------

### ReaderT Example: Counting with Environment Access

Source: https://yampa-book.readthedocs.io/en/latest/embed

Demonstrates a ReaderT-based MSF that counts values and accesses environment data using 'ask'. It shows how to run this MSF with a specific environment.

```haskell
countReaderT::Monadm=>MSF(ReaderTIntm)()Int
countReaderT=count>>>arrM(\x->(x*)<$>ask)
```

```haskell
main::IO()
main=do
ls<-runReaderT(embedcountReaderT[(),(),()])5
printls
```

--------------------------------

### Old Yampa Examples and Related Projects

Source: https://yampa-book.readthedocs.io/en/latest/links

Links to older Yampa projects and research papers that discuss Yampa's application in areas like simulations and n-body problems.

```Haskell
https://github.com/pedromartins/cuboid
https://www.youtube.com/watch?v=-IpE0CyHK7Q
https://github.com/helsinki-frp/yampy-cube
https://github.com/werk/YampaShooter
http://www.cs.yale.edu/homes/piskac/papers/2017FinkbeinerETALTORCS.pdf
https://stackoverflow.com/questions/68589984
https://stackoverflow.com/questions/65609361
```

--------------------------------

### Minimal Reactimate Implementation

Source: https://yampa-book.readthedocs.io/en/latest/reactimate

A minimal implementation of `reactimate` that produces 1.0-second time deltas. This example serves as a basic deterministic simulation and demonstrates the structure of a `reactimate` program.

```Haskell
main=do
reactimateinputInitinputoutputtime
where
inputInit=pure()
input_=pure(1.0,Just())
output_o=printo>>pureFalse
-- > 1.0
-- > 2.0
-- > 3.0
-- > ...
-- > Interrupted.
```
Tokens:
Raw