a9400db · elk · git.iko.soy

libraries/Automaton.elm+16−32

compare with master

unifiedsplit

@@ -40,20 +40,26 @@ pure : (a -> b) -> Automaton a b

40pure f = Step (\x -> (pure f, f x))

41

42-- Create an automaton with state. Requires an initial state and a step

43−-- function to step the state forward.

43+-- function to step the state forward. For example, an automaton that counted

44+-- how many steps it has taken would look like this:

45+--

46+-- count = state 0 (\\_ c -> c+1)

47+--

48+-- It is a stateful automaton. The initial state is zero, and the step function

49+-- increments the state on every step.

44−init : b -> (a -> b -> b) -> Automaton a b

50+state : b -> (a -> b -> b) -> Automaton a b

45−init s f = Step (\x -> let s' = f x s

51+state s f = Step (\x -> let s' = f x s

46− in (init s' f, s'))

52+ in (state s' f, s'))

47

53

48-- Create an automaton with hidden state. Requires an initial state and a

54-- Create an automaton with hidden state. Requires an initial state and a

49-- step function to step the state forward and produce an output.

55-- step function to step the state forward and produce an output.

50−init' : s -> (a -> s -> (s,b)) -> Automaton a b

56+hiddenState : s -> (a -> s -> (s,b)) -> Automaton a b

51−init' s f = Step (\x -> let (s',out) = f x s

57+hiddenState s f = Step (\x -> let (s',out) = f x s

52− in (init' s' f, out))

58+ in (hiddenState s' f, out))

53

59

54-- Count the number of steps taken.

60-- Count the number of steps taken.

55count : Automaton a Int

61count : Automaton a Int

56−count = init 0 (\_ c -> c + 1)

62+count = state 0 (\_ c -> c + 1)

57

63

58type Queue t = ([t],[t])

64type Queue t = ([t],[t])

59empty = ([],[])

65empty = ([],[])

@@ -64,7 +70,7 @@ dequeue q = case q of

64 (en,hd::tl) -> Just (hd, (en,tl))

70 (en,hd::tl) -> Just (hd, (en,tl))

65

71

66-- Computes the running average of the last `n` inputs.

72-- Computes the running average of the last `n` inputs.

67−average : Int -> Automaton (Number a) (Number a)

73+average : Int -> Automaton Float Float

68average k =

74average k =

69 let step n (ns,len,sum) =

75 let step n (ns,len,sum) =

70 if len == k then stepFull n (ns,len,sum)

76 if len == k then stepFull n (ns,len,sum)

@@ -74,30 +80,8 @@ average k =

74 Nothing -> ((ns,len,sum), 0)

80 Nothing -> ((ns,len,sum), 0)

75 Just (m,ns') -> let sum' = sum + n - m

81 Just (m,ns') -> let sum' = sum + n - m

76 in ((enqueue n ns', len, sum'), sum' / len)

82 in ((enqueue n ns', len, sum'), sum' / len)

77− in init' (empty,0,0) step

83+ in hiddenState (empty,0,0) step

78

84

79−{-- TODO(evancz): move this code to the Form library so people can find it.

80−

81−data DragState = Listen | Ignore | DragFrom (Int,Int)

82−

83−vecSub (x1,y1) (x2,y2) = (x1-x2,y1-y2)

84−

85−stepDrag (press,pos) (ds,form) =

86− let wrap ds' = (form, (ds',form)) in

87− case ds of

88− Listen -> wrap (if | not press -> Listen

89− | pos `isWithin` form -> DragFrom pos

90− | otherwise -> Ignore)

91− Ignore -> wrap (if press then Ignore else Listen)

92− DragFrom p0 ->

93− if press then (uncurry move (vecSub pos p0) form, (DragFrom p0, form))

94− else (let form' = uncurry move (vecSub pos p0) form in

95− (form', (Listen,form')))

96−

97−-- Create a draggable form that can be dynamically created and added to a scene.

98−draggable : Form -> Automaton (Bool,(Int,Int)) Form

99−draggable form = init' (Listen,form) stepDrag

100−--}

101

85

102{-- TODO(evancz): See the following papers for ideas on how to make this

86{-- TODO(evancz): See the following papers for ideas on how to make this

103library faster and better:

87library faster and better:

libraries/Color.elm+12−4

@@ -81,9 +81,17 @@ data Gradient

81 = Linear (Float,Float) (Float,Float) [(Float,Color)]

82 | Radial (Float,Float) Float (Float,Float) Float [(Float,Color)]

83

84−linear : (Number a, Number a) ->

84+-- Create a linear gradient. Takes a start and end point and then a series

85+-- of “color stops” that indicate how to interpolate between

86+-- the start and end points. See [this example](/edit/examples/Elements/LinearGradient.elm) for

87+-- a more visual explanation.

85− (Number a, Number a) -> [(Float,Color)] -> Gradient

88+linear : (Number a, Number a) -> (Number a, Number a) -> [(Float,Color)] -> Gradient

86linear = Linear

89linear = Linear

87−radial : (Number a,Number a) -> Number a ->

90+

91+-- Create a radial gradient. First takes a start point and inner radius.

92+-- Then takes an end point and outer radius. It then takes a series

93+-- of “color stops” that indicate how to interpolate between

94+-- the inner and outer circles. See [this example](/edit/examples/Elements/RadialGradient.elm) for

95+-- a more visual explanation.

88− (Number a,Number a) -> Number a -> [(Float,Color)] -> Gradient

96+radial : (Number a,Number a) -> Number a -> (Number a,Number a) -> Number a -> [(Float,Color)] -> Gradient

89radial = Radial

97radial = Radial

libraries/Graphics/Collage.elm+2−2

@@ -103,8 +103,8 @@ rotate t f = { f | theta <- f.theta + t }

103scale : Float -> Form -> Form

104scale s f = { f | scale <- f.scale * s }

105

106−move : Float -> Float -> Form -> Form

106+move : (Float,Float) -> Form -> Form

107−move x y f = { f | x <- f.x + x, y <- f.y + y }

107+move (x,y) f = { f | x <- f.x + x, y <- f.y + y }

108

109moveX : Float -> Form -> Form

110moveX x f = { f | x <- f.x + x }

libraries/Keyboard.elm+1−1

@@ -49,4 +49,4 @@ enter = N.isDown 13

49keysDown : Signal [KeyCode]

50

51-- The latest key that has been pressed.

52−lastKey : Signal KeyCode

52+lastPressed : Signal KeyCode

libraries/Matrix2D.elm+1−1

@@ -7,7 +7,7 @@ identity : Matrix

7

8transform : Float -> Float -> Float -> Float -> Float -> Float -> Matrix -> Matrix

9rotate : Float -> Matrix -> Matrix

10−move : Float -> Float -> Matrix -> Matrix

10+move : (Float,Float) -> Matrix -> Matrix

11scale : Float -> Matrix -> Matrix

12scaleX : Float -> Matrix -> Matrix

13scaleY : Float -> Matrix -> Matrix

libraries/Native/Matrix2D.js+4−2

@@ -28,7 +28,9 @@ Elm.Native.Matrix2D = function(elm) {

28 return new A([m11*c + m12*s, -m11*s + m12*c, m[2],

29 m21*c + m22*s, -m21*s + m22*c, m[5]]);

30 }

31− function move(x,y,m) {

31+ function move(xy,m) {

32+ var x = xy._0;

33+ var y = xy._1;

32 var m11 = m[0], m12 = m[1], m21 = m[3], m22 = m[4];

34 var m11 = m[0], m12 = m[1], m21 = m[3], m22 = m[4];

33 return new A([m11, m12, m11*x + m12*y + m[2],

35 return new A([m11, m12, m11*x + m12*y + m[2],

34 m21, m22, m21*x + m22*y + m[5]]);

36 m21, m22, m21*x + m22*y + m[5]]);

@@ -60,7 +62,7 @@ Elm.Native.Matrix2D = function(elm) {

60

62

61 transform:F7(transform),

63 transform:F7(transform),

62 rotate:F2(rotate),

64 rotate:F2(rotate),

63− move:F3(move),

65+ move:F2(move),

64 scale:F2(scale),

66 scale:F2(scale),

65 scaleX:F2(scaleX),

67 scaleX:F2(scaleX),

66 scaleY:F2(scaleY),

68 scaleY:F2(scaleY),

libraries/Native/Signal/Keyboard.js+1−1

@@ -66,7 +66,7 @@ Elm.Native.Keyboard = function(elm) {

66 isDown:is,

67 directions:F4(dir),

68 keysDown:keysDown,

69− lastKey:lastKey

69+ lastPressed:lastKey

70 };

71

72};

libraries/Native/Signal/Signal.js−23

@@ -6,10 +6,8 @@ Elm.Native.Signal = function(elm) {

6 if (elm.Native.Signal) return elm.Native.Signal;

7

8 var Utils = Elm.Native.Utils(elm);

9− var Either = Elm.Either(elm);

10 var foldl1 = Elm.List(elm).foldl1;

9 var foldl1 = Elm.List(elm).foldl1;

11

10

12−

13 function send(node, timestep, changed) {

11 function send(node, timestep, changed) {

14 var kids = node.kids;

12 var kids = node.kids;

15 for (var i = kids.length; i--; ) {

13 for (var i = kids.length; i--; ) {

@@ -195,25 +193,6 @@ Elm.Native.Signal = function(elm) {

195

193

196 function merge(s1,s2) { return new Merge(s1,s2); }

194 function merge(s1,s2) { return new Merge(s1,s2); }

197 function merges(ss) { return A2(foldl1, F2(merge), ss); }

195 function merges(ss) { return A2(foldl1, F2(merge), ss); }

198− function mergeEither(s1,s2) { return new Merge(lift(Either.Left, s1),

199− lift(Either.Right,s2)); }

200−

201− function average(sampleSize, s) {

202− var sample = new Array(sampleSize);

203− var i = sampleSize;

204− while (i--) { sample[i] = 0; }

205− i = 0;

206− var full = false;

207− var total = 0;

208− function f(n) {

209− total += n - sample[i];

210− sample[i] = n;

211− var avg = total / Math.max(1, full ? sampleSize : i);

212− if (++i == sampleSize) { full = true; i = 0; }

213− return avg;

214− }

215− return lift(f,s);

216− }

217

196

218 return elm.Native.Signal = {

197 return elm.Native.Signal = {

219 constant : function(v) { return new Input(v); },

198 constant : function(v) { return new Input(v); },

@@ -229,8 +208,6 @@ Elm.Native.Signal = function(elm) {

229 delay : F2(delay),

208 delay : F2(delay),

230 merge : F2(merge),

209 merge : F2(merge),

231 merges : merges,

210 merges : merges,

232− mergeEither : F2(mergeEither),

233− average : F2(average),

234 count : function(s) { return foldp(F2(function(_,c) { return c+1; }), 0, s); },

211 count : function(s) { return foldp(F2(function(_,c) { return c+1; }), 0, s); },

235 countIf : F2(function(pred,s) {

212 countIf : F2(function(pred,s) {

236 return foldp(F2(function(x,c){

213 return foldp(F2(function(x,c){

libraries/Native/Signal/Time.js+1−12

@@ -42,18 +42,6 @@ Elm.Native.Time = function(elm) {

42 var dcount = Signal.count(A2(Signal.delay, t, s));

43 return A3( Signal.lift2, F2(cmp), Signal.count(s), dcount );

44 }

45− function after(t) {

46− t *= 1000;

47− var thread = Signal.constant(false);

48− setTimeout(function() { elm.notify(thread.id, true); }, t);

49− return thread;

50− }

51− function before(t) {

52− t *= 1000;

53− var thread = Signal.constant(true);

54− setTimeout(function() { elm.notify(thread.id, false); }, t);

55− return thread;

56− }

57 function read(s) {

45 function read(s) {

58 var t = Date.parse(s);

46 var t = Date.parse(s);

59 return isNaN(t) ? Maybe.Nothing : Maybe.Just(t);

47 return isNaN(t) ? Maybe.Nothing : Maybe.Just(t);

@@ -63,6 +51,7 @@ Elm.Native.Time = function(elm) {

63 fps : function(t) { return fpsWhen(t, Signal.constant(true)); },

51 fps : function(t) { return fpsWhen(t, Signal.constant(true)); },

64 every : function(t) { return everyWhen(t, Signal.constant(true)) },

52 every : function(t) { return everyWhen(t, Signal.constant(true)) },

65 delay : Signal.delay,

53 delay : Signal.delay,

54+ timestamp : Signal.timestamp,

66 since : F2(since),

55 since : F2(since),

67 after : after,

56 after : after,

68 before : before,

57 before : before,

libraries/Prelude.elm+19

@@ -3,18 +3,34 @@ module Prelude where

3

4import Native.Prelude as N

5

6+-- Convert radians to standard Elm angles (radians).

6radians : Float -> Float

7radians : Float -> Float

7radians t = t

8radians t = t

8

9

10+-- Convert degrees to standard Elm angles (radians).

9degrees : Float -> Float

11degrees : Float -> Float

10degrees d = d * Math.PI / 180

12degrees d = d * Math.PI / 180

11

13

14+-- Convert turns to standard Elm angles (radians).

15+-- One turn is equal to 360°.

12turns : Float -> Float

16turns : Float -> Float

13turns r = 2 * Math.PI * r

17turns r = 2 * Math.PI * r

14

18

19+-- Start with polar coordinates (r,θ)

20+-- and get out cartesian coordinates (x,y).

21+fromPolar : (Float,Float) -> (Float,Float)

22+fromPolar (r,t) = (r * N.cos t, r * N.sin t)

23+

24+-- Start with cartesian coordinates (x,y)

25+-- and get out polar coordinates (r,θ).

26+toPolar : (Float,Float) -> (Float,Float)

27+toPolar (x,y) = (N.sqrt (x^2 + y^2), N.atan2 y x)

28+

15(+) : Number a -> Number a -> Number a

29(+) : Number a -> Number a -> Number a

16(-) : Number a -> Number a -> Number a

30(-) : Number a -> Number a -> Number a

17(*) : Number a -> Number a -> Number a

31(*) : Number a -> Number a -> Number a

32+

33+-- Floating point division.

18(/) : Float -> Float -> Float

34(/) : Float -> Float -> Float

19

35

20-- Integer division, remainder is discarded.

36-- Integer division, remainder is discarded.

@@ -26,6 +42,9 @@ rem : Int -> Int -> Int

26-- Perform modular arithmetic: 7 `mod` 2 == 1

42-- Perform modular arithmetic: 7 `mod` 2 == 1

27mod : Int -> Int -> Int

43mod : Int -> Int -> Int

28

44

45+-- Exponentiation: `3^2 == 9`

46+(^) : Number a -> Number a -> Number a

47+

29-- Basic functions of trigonometry.

48-- Basic functions of trigonometry.

30cos : Float -> Float

49cos : Float -> Float

31sin : Float -> Float

50sin : Float -> Float

libraries/Random.elm+1−1

@@ -9,5 +9,5 @@ import Native.Random as R

9range : Int -> Int -> Signal a -> Signal Int

10

11-- Produces a new signal that changes whenever the input signal changes.

12−-- The new values are random number in [0..1).

12+-- The new values are random numbers in [0..1).

13float : Signal a -> Signal Float

libraries/Signal.elm+11−17

@@ -23,9 +23,12 @@ lift2 : (a -> b -> c) -> Signal a -> Signal b -> Signal c

23lift3 : (a -> b -> c -> d) -> Signal a -> Signal b -> Signal c -> Signal d

24lift4 : (a -> b -> c -> d -> e) -> Signal a -> Signal b -> Signal c -> Signal d -> Signal e

25lift5 : (a -> b -> c -> d -> e -> f) -> Signal a -> Signal b -> Signal c -> Signal d -> Signal e -> Signal f

26+lift6 : (a -> b -> c -> d -> e -> f -> g)

26−lift6 : (a -> b -> c -> d -> e -> f -> g) -> Signal a -> Signal b -> Signal c -> Signal d -> Signal e -> Signal f -> Signal g

27+ -> Signal a -> Signal b -> Signal c -> Signal d -> Signal e -> Signal f -> Signal g

28+lift7 : (a -> b -> c -> d -> e -> f -> g -> h)

27−lift7 : (a -> b -> c -> d -> e -> f -> g -> h) -> Signal a -> Signal b -> Signal c -> Signal d -> Signal e -> Signal f -> Signal g -> Signal h

29+ -> Signal a -> Signal b -> Signal c -> Signal d -> Signal e -> Signal f -> Signal g -> Signal h

30+lift8 : (a -> b -> c -> d -> e -> f -> g -> h -> i)

28−lift8 : (a -> b -> c -> d -> e -> f -> g -> h -> i) -> Signal a -> Signal b -> Signal c -> Signal d -> Signal e -> Signal f -> Signal g -> Signal h -> Signal i

31+ -> Signal a -> Signal b -> Signal c -> Signal d -> Signal e -> Signal f -> Signal g -> Signal h -> Signal i

29

32

30-- Create a past-dependent signal. Each value given on the input signal will

33-- Create a past-dependent signal. Each value given on the input signal will

31-- be accumulated, producing a new output value.

34-- be accumulated, producing a new output value.

@@ -41,14 +44,14 @@ merge : Signal a -> Signal a -> Signal a

41-- signals update simultaneously.

44-- signals update simultaneously.

42merges : [Signal a] -> Signal a

45merges : [Signal a] -> Signal a

43

46

44−-- Combine many signals into one, with an array of results.

47+-- Combine a list of signals into a signal of lists.

45combine : [Signal a] -> Signal [a]

48combine : [Signal a] -> Signal [a]

46combine = L.foldr (S.lift2 (::)) (S.constant [])

49combine = L.foldr (S.lift2 (::)) (S.constant [])

47

50

48−-- Merge two signals into one, but distinguishing the values by marking the first

51+ -- Merge two signals into one, but distinguishing the values by marking the first

49−-- signal as `Left` and the second signal as `Right`. This allows you to easily

52+ -- signal as `Left` and the second signal as `Right`. This allows you to easily

50−-- fold over non-homogeneous inputs.

53+ -- fold over non-homogeneous inputs.

51−mergeEither : Signal a -> Signal b -> Signal (Either a b)

54+ -- mergeEither : Signal a -> Signal b -> Signal (Either a b)

52

55

53-- Count the number of events that have occured.

56-- Count the number of events that have occured.

54count : Signal a -> Signal Int

57count : Signal a -> Signal Int

@@ -90,15 +93,6 @@ dropRepeats : Signal a -> Signal a

90-- time of the latest click.

93-- time of the latest click.

91sampleOn : Signal a -> Signal b -> Signal b

94sampleOn : Signal a -> Signal b -> Signal b

92

95

93−-- Add a timestamp to any signal. Timestamps increase monotonically. Each timestamp is

94−-- related to a specfic event, so `Mouse.x` and `Mouse.y` will always have the same

95−-- timestamp because they both rely on the same underlying event.

96−timestamp : Signal a -> Signal (Time, a)

97−

98−-- Delay a signal by a certain amount of time. So `(delay second Mouse.clicks)`

99−-- will update one second later than any mouse click.

100−delay : Time -> Signal a -> Signal a

101−

102-- An alias for `lift`. A prettier way to apply a

96-- An alias for `lift`. A prettier way to apply a

103-- function to the current value of a signal.

97-- function to the current value of a signal.

104(<~) : (a -> b) -> Signal a -> Signal b

98(<~) : (a -> b) -> Signal a -> Signal b

libraries/Time.elm+9−4

@@ -56,7 +56,12 @@ every : Time -> Signal Time

56-- otherwise.

57since : Time -> Signal a -> Signal Bool

58

59−{-- TODO: Only found in docs

59+-- Add a timestamp to any signal. Timestamps increase monotonically. Each

60+-- timestamp is related to a specfic event, so `Mouse.x` and `Mouse.y` will

61+-- always have the same timestamp because they both rely on the same

62+-- underlying event.

60− , ("timeOf", "Signal a -> Signal Time", [markdown|

63+timestamp : Signal a -> Signal (Time, a)

61− Same as `timestamp` but it throws out the incoming value. So `(timeOf == lift fst . timestamp)`.|])

64+

62−--}

65+-- Delay a signal by a certain amount of time. So `(delay second Mouse.clicks)`

66+-- will update one second later than any mouse click.

67+delay : Time -> Signal a -> Signal a