TheSeamau5

{-
This is an example of how to test state in Elm.
The idea is that one can model your application as a state machine
with an update function of the type:

    update : action -> state -> state
    
This is very useful in order to test applications
built using the Elm architecture, which looks like this:

TheSeamau5

import Graphics.Collage (..)
import Graphics.Element (..)
import Graphics.Input (..)
import Color (..)
import Signal (..)

import Text
import List
import Mouse

TheSeamau5

import Svg (Svg, circle, svg, g, line, text)
import Svg.Attributes (cx, cy, r, fill, stroke, strokeWidth, x, y, x1, x2, y1, y2, fontSize, style)
import Html
import Html.Attributes as Html

import Signal (Signal, map, foldp)
import DragAndDrop (mouseEvents, MouseEvent(..))
import List

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

TheSeamau5

type alias Bounds = {
  left : Float,
  right : Float,
  top : Float,
  bottom : Float
}

bounds : Bounds
bounds = Bounds 0 0 0 0

TheSeamau5

Communicating Sequential Processes (CSP)

CSP is one of the many ways of reasoning about concurrent systems. It emphasizes on the idea of a channel which enables communication between producers and consumers and where the channel itself is fundamentally decouple from either producers or consumers.

Queues

The easiest way of thinking about a channel is to think about a queue. A queue is very simple, it is a data structure where one may only push data to the end of a queue and may only read data from the front of the queue.

In pseudo-code:

TheSeamau5

interface Numerical a = {
  (+) : a -> a -> a,
  (-) : a -> a -> a,
  (*) : a -> a -> a,
  negate : a -> a,
  abs : a -> a
}

implementation Numerical Float = {
  (+) = Native.Float.add,

TheSeamau5

mapAll : (a -> a -> a) -> Array a -> Array (Array a)
mapAll f array =
  let innerMap tempArray =
    case head tempArray of
      Nothing -> empty
      Just x -> push (map (f x) array) (innerMap (rest tempArray))
  in
    innerMap array

TheSeamau5

import Array (..)
import Text (asText)
import Graphics.Collage (..)
import Color (..)

drawBox box =
  move (box.horizontal.low + boxHalfWidth box, box.vertical.low + boxHalfHeight box) <|
     outlined (solid black) <|
        rect (boxWidth box) (boxHeight box)

TheSeamau5

loop : a -> (a -> Bool) -> (a -> a) -> (a -> b) -> b
loop start condition update return = 
  trampoline <|
    loop' start condition update return


loop' : a -> (a -> Bool) -> (a -> a) -> (a -> b) -> Trampoline b
loop' start condition update return = 
  case condition start of 
    True -> Done (return start)

TheSeamau5

import List (..)
import Random (..)
import Text (asText)

shuffle : List a -> List a
shuffle lt = 
  let len = length lt
      fgen = float 0 1
      lgen = list len fgen
      rlist = fst <| generate lgen (initialSeed 31415)